---
description: Execution Plan: Release Preparation: > Generated by Attune AI v4.5.1 > Template: release-prep > Generated: 2026-01-20T13:30:00Z ## Configuration Based o
---

# Execution Plan: Release Preparation

> Generated by Attune AI v4.5.1
> Template: release-prep
> Generated: 2026-01-20T13:30:00Z

## Configuration

Based on form responses (or defaults):
- **security_scan**: Yes
- **test_coverage_check**: Yes
- **coverage_threshold**: 80%
- **quality_review**: Yes
- **doc_verification**: Yes

---

## Agent Execution Plan

Execute these steps sequentially. Each step can be run as a Claude Code Task agent.

### Step 1: Security Auditor

**Role**: Security Auditor
**Tier Recommendation**: CAPABLE (Sonnet)
**Tools Needed**: grep, file search, code analysis

**Prompt for Claude Code:**
```
You are a Security Auditor analyzing this codebase for release readiness.

Your task:
1. Scan for OWASP Top 10 vulnerabilities (injection, XSS, auth issues)
2. Check for hardcoded secrets or credentials
3. Review dependency security (look for known vulnerable packages)
4. Identify any unsafe patterns (eval, exec, unsanitized input)

Focus areas:
- src/ directory for application code
- Look for patterns: eval(, exec(, subprocess with shell=True
- Check .env files aren't committed
- Review authentication/authorization code

Success Criteria:
- [ ] No critical vulnerabilities found
- [ ] All dependencies are secure
- [ ] No hardcoded secrets

Output a structured report with:
- CRITICAL issues (must fix before release)
- HIGH issues (should fix)
- MEDIUM issues (consider fixing)
- Recommendations
```

**Claude Code invocation:**
```
Use the Task tool with subagent_type="Explore" and this prompt.
Or run directly in conversation.
```

---

### Step 2: Test Coverage Analyst

**Role**: Test Coverage Analyst
**Tier Recommendation**: CAPABLE (start), escalate to PREMIUM if complex
**Tools Needed**: pytest, coverage analysis

**Prompt for Claude Code:**
```
You are a Test Coverage Analyst verifying test coverage for release.

Your task:
1. Run the test suite and check coverage: pytest --cov=src --cov-report=term-missing
2. Identify files/functions with coverage below 80%
3. Analyze which uncovered paths are high-risk
4. Check for any failing tests

Configuration:
- Minimum threshold: 80%
- Focus on src/attune/ directory

Success Criteria:
- [ ] Coverage meets 80% threshold
- [ ] All tests pass
- [ ] Critical paths are covered

Output:
- Current coverage percentage
- List of under-covered files (sorted by risk)
- Specific functions needing tests
- Any test failures with analysis
```

**Claude Code invocation:**
```bash
# Run this first to get data:
pytest --cov=src --cov-report=term-missing -q

# Then analyze the output
```

---

### Step 3: Code Quality Reviewer

**Role**: Code Quality Reviewer
**Tier Recommendation**: CAPABLE
**Tools Needed**: ruff, code search

**Prompt for Claude Code:**
```
You are a Code Quality Reviewer checking code quality for release.

Your task:
1. Run linting: ruff check src/ --statistics
2. Identify code smells and complexity issues
3. Check for TODO/FIXME comments that should be addressed
4. Review recent changes for quality issues

Focus on:
- Functions with high cyclomatic complexity
- Duplicate code patterns
- Missing type hints on public APIs
- Error handling patterns

Success Criteria:
- [ ] No high-severity linting issues
- [ ] Complexity within acceptable bounds
- [ ] Critical TODOs addressed

Output:
- Summary of linting issues by severity
- Top 5 complexity hotspots
- List of unresolved TODOs/FIXMEs
- Recommendations for improvement
```

---

### Step 4: Documentation Specialist

**Role**: Documentation Specialist
**Tier Recommendation**: CHEAP (Haiku) - straightforward analysis
**Tools Needed**: file search, doc analysis

**Prompt for Claude Code:**
```
You are a Documentation Specialist verifying docs for release.

Your task:
1. Check that all public APIs have docstrings
2. Verify README.md is current with latest features
3. Check CHANGELOG.md has entries for this release
4. Verify any API changes are documented

Focus areas:
- src/attune/*.py - public modules
- README.md - feature list accuracy
- CHANGELOG.md - recent entries
- docs/ directory - guide accuracy

Success Criteria:
- [ ] All public APIs documented
- [ ] README reflects current features
- [ ] CHANGELOG updated

Output:
- List of undocumented public APIs
- README accuracy assessment
- CHANGELOG status
- Documentation gaps to address
```

---

## Synthesis Step

After all agents complete, synthesize findings:

**Prompt for Claude Code:**
```
You are synthesizing the release readiness assessment.

Combine the outputs from:
1. Security Auditor findings
2. Test Coverage analysis
3. Code Quality review
4. Documentation check

Create a release readiness report:

## Release Readiness Summary

### Overall Status: [READY / BLOCKED / NEEDS WORK]

### Critical Blockers (must fix)
- List any critical issues

### Recommended Fixes (should fix)
- List high-priority improvements

### Release Checklist
- [ ] Security scan passed
- [ ] Test coverage ≥80%
- [ ] No critical quality issues
- [ ] Documentation complete

### Risk Assessment
- What risks exist if we release now?
- What's the recommended action?
```

---

## Usage Options

### Option A: Interactive (paste prompts into Claude Code)
1. Start Claude Code conversation
2. Copy each step's prompt
3. Review output, proceed to next step
4. Run synthesis at the end

### Option B: As Claude Code Skill
Save this as `.claude/commands/release-prep.md` and run with `/project:release-prep`

### Option C: Automated via Task tool
Have Claude Code run each step as a Task agent:
```
Run these 4 agents in sequence using the Task tool:
1. Explore agent for security scan
2. Bash + Explore for test coverage
3. Explore agent for code quality
4. Explore agent for documentation
Then synthesize the results.
```

---

## Cost Comparison

| Mode | Estimated Cost |
|------|---------------|
| API Execution (--real) | $0.10 - $0.75 |
| Claude Code (Max sub) | $0 (included) |

---

*Generated by `attune meta-workflow plan release-prep`*
