sdlc-framework 1.0.0

package/src/commands/close.md

@@ -0,0 +1,200 @@
+---
+name: sdlc:close
+description: Reconcile spec vs actual and close the loop
+argument-hint: "[spec-path]"
+allowed-tools: [Read, Write, Bash, Glob, Grep, Edit]
+---
+
+<objective>
+Close the current SDLC loop by reconciling what was planned (SPEC.md) against what was built (IMPL.md, VERIFY.md, REVIEW.md). Record deviations, decisions, and lessons learned. Advance the state to the next plan or phase.
+
+**When to use:** After /sdlc:review completes with no blockers. This is the CLOSE phase of the SDLC loop.
+
+**What it does:**
+1. Read all artifacts from the current loop: SPEC, IMPL, VERIFY, REVIEW.
+2. Compare planned vs actual: tasks completed, ACs met, scope adhered to.
+3. Record deviations with reasons (scope changes, discovered complexity, design pivots).
+4. Create SUMMARY.md with deliverables, results, deviations, decisions, and lessons.
+5. Update STATE.md to advance to the next plan or phase.
+
+**What happens next:**
+- More plans in the current phase: Framework directs you to /sdlc:spec for the next plan.
+- Phase complete (all plans done): Framework directs you to the next milestone/phase.
+- All milestones complete: Project is done.
+
+**Critical rule:** No loop closes without reconciliation. Every deviation from the spec is documented with a reason. Lessons learned feed into the next loop.
+</objective>
+
+<execution_context>
+@~/.claude/sdlc-framework/workflows/close-loop.md
+@.sdlc/STATE.md
+@.sdlc/ROADMAP.md
+</execution_context>
+
+<context>
+$ARGUMENTS — optional path to SPEC.md. If not provided, read from .sdlc/STATE.md spec_path field.
+
+Read these files:
+- .sdlc/STATE.md — current plan, all artifact paths.
+- .sdlc/ROADMAP.md — milestones, phases, plans to determine next steps.
+- .sdlc/specs/SPEC-<plan-id>.md — what was planned.
+- .sdlc/impl/IMPL-<plan-id>.md — what was built.
+- .sdlc/verify/VERIFY-<plan-id>.md — what was verified.
+- .sdlc/review/REVIEW-<plan-id>.md — what was reviewed.
+</context>
+
+<process>
+Follow workflow: @~/.claude/sdlc-framework/workflows/close-loop.md
+
+Step-by-step:
+
+1. **Load all loop artifacts**
+   - Read .sdlc/STATE.md. Confirm loop_position is REVIEW_COMPLETE. If not, warn: "Review not complete. Run /sdlc:review first."
+   - Read SPEC-<plan-id>.md — extract: objective, acceptance criteria, tasks, boundaries.
+   - Read IMPL-<plan-id>.md — extract: tasks completed, files modified, build status.
+   - Read VERIFY-<plan-id>.md — extract: AC results (pass/fail per criterion).
+   - Read REVIEW-<plan-id>.md — extract: findings summary, warnings count.
+
+2. **Reconcile: Planned vs Actual**
+
+   **Tasks reconciliation:**
+   - List every task from SPEC.md.
+   - For each task, determine: completed, skipped, or modified.
+   - If a task was skipped: record why.
+   - If a task was modified from the original plan: record what changed and why.
+   - If additional tasks were added during implementation: record what and why.
+
+   **Acceptance criteria reconciliation:**
+   - List every AC from SPEC.md.
+   - Map each AC to its verification result (pass/fail).
+   - All ACs should pass (otherwise /sdlc:verify would not have advanced). Confirm this.
+
+   **Scope reconciliation:**
+   - Compare files modified against SPEC.md "Files to Modify" list.
+   - Identify files modified that were NOT in the original spec.
+   - Identify files in the spec that were NOT modified.
+   - Record each deviation with a reason.
+
+   **Boundary reconciliation:**
+   - Check if any out-of-scope work was performed.
+   - Check if any deferred items were pulled in.
+   - Record each boundary violation with a reason.
+
+3. **Record deviations**
+   For each deviation from the original spec, document:
+   - What was planned.
+   - What actually happened.
+   - Why the deviation occurred (discovered complexity, user request, design pivot, bug found).
+   - Impact on future work (does this change subsequent plans?).
+
+4. **Record decisions**
+   Compile all design decisions made during this loop:
+   - Decisions from /sdlc:spec (architectural choices).
+   - Decisions from /sdlc:impl (implementation choices).
+   - Decisions from /sdlc:review (remediation approaches).
+   Include the rationale for each decision.
+
+5. **Extract lessons learned**
+   Analyze the loop for process improvements:
+   - What went well? (Patterns to repeat.)
+   - What went poorly? (Patterns to avoid.)
+   - What was surprising? (Unknown unknowns discovered.)
+   - Estimation accuracy: was task complexity estimated correctly?
+   - Spec quality: were acceptance criteria clear enough? Did implementation reveal gaps?
+
+6. **Create SUMMARY.md**
+   Write .sdlc/summaries/SUMMARY-<plan-id>.md with:
+   ```
+   # Loop Summary: <plan title>
+
+   ## Objective
+   <from SPEC.md>
+
+   ## Deliverables
+   - Files created: <list>
+   - Files modified: <list>
+   - Tests added: <list>
+
+   ## Acceptance Criteria Results
+   | AC | Title | Status |
+   |----|-------|--------|
+   | AC-1 | <title> | PASS |
+   | AC-2 | <title> | PASS |
+
+   ## Review Summary
+   - Blockers found and fixed: <count>
+   - Warnings: <count> (<count> addressed, <count> deferred)
+   - Info: <count>
+
+   ## Deviations from Spec
+   ### D-1: <title>
+   - Planned: <what was planned>
+   - Actual: <what happened>
+   - Reason: <why>
+   - Impact: <effect on future work>
+
+   ## Key Decisions
+   ### Decision 1: <title>
+   - Context: <why the decision was needed>
+   - Options considered: <list>
+   - Chosen: <which option>
+   - Rationale: <why>
+
+   ## Lessons Learned
+   - <lesson 1>
+   - <lesson 2>
+
+   ## Metrics
+   - Tasks planned: <count>
+   - Tasks completed: <count>
+   - Tasks skipped: <count>
+   - Execution waves: <count>
+   - ACs defined: <count>
+   - ACs passed: <count>
+   - Review findings: <blockers>/<warnings>/<info>
+   ```
+
+7. **Update STATE.md**
+   - Set `loop_position: SPEC` (ready for next loop).
+   - Archive the current plan: move plan-id to `completed_plans` list.
+   - Determine next action:
+     - Read ROADMAP.md to find the next plan in the current phase.
+     - If more plans exist: set `current_plan: <next-plan-id>`.
+     - If no more plans in this phase: mark the phase as complete, advance to the next phase.
+     - If no more phases in this milestone: mark the milestone as complete.
+
+8. **Update ROADMAP.md**
+   - Mark the completed plan as done.
+   - If phase is complete: mark the phase as done.
+   - If milestone is complete: mark the milestone as done.
+
+9. **Determine and output next action**
+   - If more plans in the current phase:
+     - Output: "Plan <plan-id> complete. Next plan: <next-plan-id>."
+     - End with: NEXT ACTION REQUIRED: /sdlc:spec
+   - If phase is complete but more phases exist:
+     - Output: "Phase <phase-name> complete. Next phase: <next-phase-name>."
+     - End with: NEXT ACTION REQUIRED: /sdlc:spec
+   - If milestone is complete but more milestones exist:
+     - Output: "Milestone <milestone-name> complete. Next milestone: <next-milestone-name>."
+     - End with: NEXT ACTION REQUIRED: /sdlc:spec
+   - If all milestones are complete:
+     - Output: "All milestones complete. Project roadmap fulfilled."
+     - End with: "Project complete. Run /sdlc:init to start a new project or update ROADMAP.md with new milestones."
+</process>
+
+<success_criteria>
+- [ ] All loop artifacts read: SPEC, IMPL, VERIFY, REVIEW
+- [ ] Task reconciliation complete: each task marked completed, skipped, or modified
+- [ ] Acceptance criteria reconciliation complete: every AC mapped to pass/fail
+- [ ] Scope reconciliation complete: files planned vs files modified compared
+- [ ] Boundary reconciliation complete: out-of-scope work identified
+- [ ] Every deviation documented with: what was planned, what happened, why, impact
+- [ ] Key decisions recorded with rationale
+- [ ] Lessons learned extracted from the loop
+- [ ] SUMMARY-<plan-id>.md created with full reconciliation
+- [ ] STATE.md updated: loop_position reset to SPEC, current plan advanced
+- [ ] ROADMAP.md updated: completed plan/phase/milestone marked as done
+- [ ] Correct next action determined based on roadmap position
+- [ ] Output ends with NEXT ACTION REQUIRED: /sdlc:spec (or project complete message)
+</success_criteria>

package/src/commands/debug.md

@@ -0,0 +1,124 @@
+---
+name: sdlc:debug
+description: "Structured debugging with reproduce-isolate-fix-verify"
+argument-hint: "<issue-description>"
+allowed-tools: [Read, Write, Bash, Glob, Grep, Edit, Agent, mcp__plugin_playwright_playwright__browser_navigate, mcp__plugin_playwright_playwright__browser_snapshot, mcp__plugin_playwright_playwright__browser_click, mcp__plugin_playwright_playwright__browser_fill_form, mcp__plugin_playwright_playwright__browser_take_screenshot, mcp__plugin_playwright_playwright__browser_evaluate, mcp__plugin_playwright_playwright__browser_console_messages, mcp__plugin_playwright_playwright__browser_network_requests, mcp__plugin_playwright_playwright__browser_close, AskUserQuestion]
+---
+
+<objective>
+Structured debugging that follows a disciplined flow: REPRODUCE, ISOLATE, ROOT-CAUSE, FIX, VERIFY. No guessing. No shotgun debugging.
+
+**When to use:** Something is broken. You have a bug report, an error message, or unexpected behavior.
+
+**What it does:**
+1. Reproduce the bug with a minimal test case or Playwright sequence.
+2. Isolate the source through binary search and code analysis.
+3. Identify the root cause — WHY it happens, not just WHERE.
+4. Apply a fix that follows engineering laws.
+5. Verify the fix by re-running the reproduction and regression tests.
+
+**What happens next:** /sdlc:review to validate the fix meets engineering standards.
+</objective>
+
+<execution_context>
+@~/.claude/sdlc-framework/workflows/debug.md
+@.sdlc/STATE.md
+@.sdlc/LAWS.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+Read .sdlc/STATE.md to confirm framework is initialized.
+Read .sdlc/LAWS.md to load engineering laws — the fix must comply.
+Gather any error messages, stack traces, or reproduction steps from the user's description.
+</context>
+
+<process>
+Follow workflow: @~/.claude/sdlc-framework/workflows/debug.md
+
+Step-by-step:
+
+1. **Pre-flight check**
+   - Verify .sdlc/ exists. If not, tell the user to run /sdlc:init first.
+   - Read .sdlc/STATE.md. Update loop_position to DEBUG.
+   - Parse $ARGUMENTS for: error message, affected area, steps to reproduce.
+
+2. **REPRODUCE — Create a minimal reproduction**
+   - Goal: A failing test or Playwright sequence that demonstrates the bug.
+   - For code bugs:
+     - Search the codebase for the affected function/module using Grep.
+     - Write a minimal test case that triggers the failure.
+     - Run the test. Confirm it fails with the reported error.
+   - For UI bugs:
+     - Use Playwright to navigate to the affected page.
+     - Execute the steps that trigger the bug.
+     - Take a screenshot of the broken state.
+     - Capture console messages and network requests for clues.
+   - If reproduction fails, ask the user for more details via AskUserQuestion.
+   - Record the reproduction steps in the debug log.
+
+3. **ISOLATE — Binary search for the source**
+   - Start from the error location and work backward.
+   - Use Grep to find all callers of the failing function.
+   - Use Read to examine suspicious code paths.
+   - Narrow down: which specific line or condition causes the failure?
+   - Techniques:
+     - Add logging to confirm execution path.
+     - Check recent git changes to the affected files (`git log --oneline -10 <file>`).
+     - Test with simplified inputs to isolate the trigger.
+   - Record: "Bug is in [file]:[line] — triggered when [condition]."
+
+4. **ROOT-CAUSE — Explain WHY, not just WHERE**
+   - Answer these questions:
+     - What assumption does the code make that is wrong?
+     - When was this assumption introduced?
+     - What edge case does it fail to handle?
+     - Are there other locations with the same flawed assumption?
+   - Record the root cause explanation in plain language.
+   - Search for similar patterns elsewhere in the codebase that might have the same bug.
+
+5. **FIX — Apply the fix following engineering laws**
+   - Fix the root cause, not the symptom.
+   - Enforce engineering laws:
+     - DRY: if a similar fix exists elsewhere, use the same pattern.
+     - Handle edge cases: null, undefined, empty arrays, empty strings.
+     - Max 40 lines per function. Extract helpers if needed.
+     - Named types for complex objects.
+     - No lint suppression.
+   - If similar bugs exist elsewhere (found in step 4), fix ALL of them.
+
+6. **VERIFY — Confirm the fix works**
+   - Re-run the reproduction test from step 2. It MUST pass now.
+   - Run the full test suite to check for regressions.
+   - For UI bugs: re-run the Playwright sequence. Take a screenshot of the fixed state.
+   - If verification fails: return to step 3 (ISOLATE) — the root cause was wrong.
+
+7. **Create DEBUG-LOG.md**
+   - Save to .sdlc/debug-logs/DEBUG-{timestamp}.md with:
+     - Bug description (from $ARGUMENTS)
+     - Reproduction steps and test case
+     - Isolation path (how you narrowed it down)
+     - Root cause explanation
+     - Fix applied (files and lines changed)
+     - Verification results
+     - Related patterns found (if any)
+   - This log serves as knowledge retention for future debugging.
+
+8. **Update STATE.md and force next action**
+   - Update .sdlc/STATE.md: record the debug session, files changed.
+   - Output: "NEXT ACTION REQUIRED: /sdlc:review — validate the fix meets engineering standards."
+</process>
+
+<success_criteria>
+- [ ] Bug reproduced with a failing test case or Playwright sequence
+- [ ] Source isolated to specific file and line
+- [ ] Root cause explained (WHY, not just WHERE)
+- [ ] Fix applied following engineering laws from LAWS.md
+- [ ] Reproduction test passes after fix
+- [ ] Full test suite passes (no regressions)
+- [ ] Similar bugs in other locations identified and fixed
+- [ ] DEBUG-LOG.md created in .sdlc/debug-logs/
+- [ ] STATE.md updated
+- [ ] Output ends with NEXT ACTION REQUIRED: /sdlc:review
+</success_criteria>

package/src/commands/fast.md

@@ -0,0 +1,149 @@
+---
+name: sdlc:fast
+description: "Quick entry point — describe work, framework routes and executes"
+argument-hint: "<description>"
+allowed-tools: [Read, Write, Bash, Glob, Grep, Edit, Agent, TaskCreate, TaskUpdate, TaskGet, TaskList, mcp__plugin_playwright_playwright__browser_navigate, mcp__plugin_playwright_playwright__browser_snapshot, mcp__plugin_playwright_playwright__browser_click, mcp__plugin_playwright_playwright__browser_fill_form, mcp__plugin_playwright_playwright__browser_take_screenshot, mcp__plugin_playwright_playwright__browser_evaluate, mcp__plugin_playwright_playwright__browser_close, AskUserQuestion]
+---
+
+<objective>
+The primary entry point for getting work done. Describe what you need in plain language — the framework classifies the work, estimates complexity, and either handles it inline or routes to the appropriate command.
+
+**When to use:** Anytime. This is the default command for starting work. Use it instead of figuring out which specific command to run.
+
+**What it does:**
+1. Classify the work type (feature, bug, refactor, test, docs, research).
+2. Estimate complexity (files, lines, dependencies).
+3. Route based on classification and complexity:
+   - Simple work (≤3 files, ≤100 lines): execute full loop inline (spec→impl→verify→review→close).
+   - Complex feature: route to /sdlc:spec with pre-filled context.
+   - Bug: route to /sdlc:debug with reproduction context.
+   - Research question: route to /sdlc:research with topic.
+   - Critical production issue: route to /sdlc:hotfix with context.
+4. For inline execution: run compressed loop with full engineering law enforcement.
+
+**What happens next:** Depends on routing — either the task is complete, or you are directed to the appropriate specialized command.
+
+**This is the "I just want to tell you what to do" command.** No ceremony. No choosing commands. Describe the work, the framework handles the rest.
+</objective>
+
+<execution_context>
+@~/.claude/sdlc-framework/workflows/fast-forward.md
+@~/.claude/sdlc-framework/references/prompt-detection.md
+@.sdlc/STATE.md
+@.sdlc/LAWS.md
+@.sdlc/PROJECT.md
+</execution_context>
+
+<context>
+$ARGUMENTS — natural language description of the work to be done.
+
+Read these files to understand current state:
+- .sdlc/STATE.md — current loop position, active phase, what was last done.
+- .sdlc/PROJECT.md — project context, tech stack.
+- .sdlc/LAWS.md — engineering laws for enforcement.
+</context>
+
+<process>
+Follow workflow: @~/.claude/sdlc-framework/workflows/fast-forward.md
+
+Step-by-step:
+
+1. **Pre-flight check**
+   - Verify .sdlc/ exists. If not: "Run /sdlc:init first."
+   - Read .sdlc/STATE.md to understand current position.
+   - Read .sdlc/LAWS.md to load engineering laws.
+
+2. **Classify the work** (prompt detection)
+   Parse $ARGUMENTS to determine work type:
+
+   | Type | Indicators | Route |
+   |------|-----------|-------|
+   | BUG | "fix", "bug", "error", "broken", "crash", "fails", "wrong", "regression" | /sdlc:debug |
+   | CRITICAL | "urgent", "production", "down", "outage", "critical", "P0", "hotfix" | /sdlc:hotfix |
+   | RESEARCH | "explore", "investigate", "research", "compare", "evaluate", "options" | /sdlc:research |
+   | FEATURE | "add", "create", "build", "implement", "new", "introduce" | complexity-dependent |
+   | REFACTOR | "refactor", "clean", "rename", "extract", "move", "simplify" | complexity-dependent |
+   | TEST | "test", "coverage", "spec", "assertion" | complexity-dependent |
+   | DOCS | "doc", "readme", "comment", "describe" | complexity-dependent |
+
+   Display: "Classified as: {type}"
+
+3. **Immediate routing** (for specialized types)
+   - BUG → Display: "Bug detected. NEXT ACTION REQUIRED: /sdlc:debug {original description}" — STOP.
+   - CRITICAL → Display: "Critical issue. NEXT ACTION REQUIRED: /sdlc:hotfix {original description}" — STOP.
+   - RESEARCH → Display: "Research task. NEXT ACTION REQUIRED: /sdlc:research {original description}" — STOP.
+
+4. **Complexity estimation** (for feature/refactor/test/docs)
+   - Scan codebase for files related to the description.
+   - Estimate file count and line count.
+   - Check for cross-module dependencies.
+
+   | Complexity | Files | Lines | Route |
+   |-----------|-------|-------|-------|
+   | Simple | ≤3 | ≤100 | Execute inline (fast loop) |
+   | Medium | 4-6 | 101-300 | Route to /sdlc:spec with pre-filled context |
+   | Complex | 7+ | 300+ | Route to /sdlc:spec with pre-filled context |
+
+   For MEDIUM/COMPLEX:
+   Display:
+   ```
+   Task exceeds inline threshold ({N} files, ~{N} lines).
+   Routing to full spec for proper task decomposition and parallel sub-agent execution.
+
+   NEXT ACTION REQUIRED: /sdlc:spec
+   Context pre-loaded: {task description, identified files, estimated scope}
+   ```
+   Write pre-filled context to .sdlc/STATE.md fast_context field so /sdlc:spec picks it up.
+   STOP.
+
+5. **Inline execution — Mini-SPEC**
+   Create lightweight inline spec (not written to file):
+   ```
+   Task: {name}
+   Type: {type}
+   Files: {list}
+   ACs:
+     AC-1: GIVEN ... WHEN ... THEN ...
+   Boundaries: do not modify files outside {list}
+   ```
+   Display to user and ask: "Proceed? (yes/no)"
+
+6. **Inline execution — Mini-IMPLEMENT**
+   - Read every file to modify first.
+   - Search for existing patterns before writing new code.
+   - Implement following engineering laws.
+   - No sub-agents (single-threaded for simple work).
+
+7. **Inline execution — Mini-VERIFY**
+   - Run build + lint.
+   - Run tests relevant to changed files.
+   - For UI work: Playwright MCP verification.
+   - Check each AC: PASS or FAIL.
+   - If ANY FAIL: display failures, suggest fixes. User must fix and re-run.
+
+8. **Inline execution — Mini-REVIEW**
+   - Quick engineering laws check on changed files only.
+   - Function length, params, nesting, DRY, security, error handling, tests.
+   - If BLOCKERS: fix inline (do not route to /sdlc:fix for fast tasks).
+   - If CLEAN: proceed.
+
+9. **Inline execution — Mini-CLOSE**
+   - Create .sdlc/phases/{phase}/FF-{timestamp}-SUMMARY.md.
+   - Update STATE.md history.
+   - Restore prior state (fast does not advance the phase).
+   - Display completion summary.
+</process>
+
+<success_criteria>
+- [ ] Work classified correctly from natural language description
+- [ ] Bugs routed to /sdlc:debug — never processed inline
+- [ ] Critical issues routed to /sdlc:hotfix
+- [ ] Research tasks routed to /sdlc:research
+- [ ] Complex work (>3 files or >100 lines) routed to /sdlc:spec with pre-filled context
+- [ ] Simple work executed inline through full compressed loop
+- [ ] All code changes comply with engineering laws
+- [ ] Tests run and pass
+- [ ] STATE.md updated appropriately
+- [ ] Summary created for audit trail
+- [ ] Routing decisions are explained to the user
+</success_criteria>

package/src/commands/fix.md

@@ -0,0 +1,104 @@
+---
+name: sdlc:fix
+description: Fix review findings and re-verify compliance
+argument-hint: "[review-path]"
+allowed-tools: [Read, Write, Bash, Glob, Grep, Edit, Agent, TaskCreate, TaskUpdate, TaskGet, TaskList, AskUserQuestion]
+---
+
+<objective>
+Systematically fix all blocker findings from /sdlc:review. Read the REVIEW.md, fix each violation, then re-run review to confirm compliance.
+
+**When to use:** After /sdlc:review reports blockers that must be fixed before /sdlc:close.
+
+**What it does:**
+1. Read the REVIEW.md to load all findings.
+2. Separate blockers (must fix) from warnings (should fix) and info (consider).
+3. Analyze dependencies between findings (fixing one may resolve others).
+4. For independent fixes: spawn parallel sub-agents per file.
+5. For dependent fixes: apply sequentially.
+6. After all blockers fixed: automatically re-run /sdlc:review to confirm compliance.
+7. If warnings exist: present to user and ask which to fix (optional).
+
+**What happens next:** Re-runs /sdlc:review automatically. If review passes, routes to /sdlc:close.
+
+**Critical rule:** Fixes MUST follow the same engineering laws. A fix that introduces a new violation is not a fix.
+</objective>
+
+<execution_context>
+@~/.claude/sdlc-framework/workflows/fix-findings.md
+@~/.claude/sdlc-framework/references/engineering-laws.md
+</execution_context>
+
+<context>
+$ARGUMENTS — optional path to REVIEW.md. If not provided, finds the most recent review file.
+
+Read these files:
+- .sdlc/STATE.md — current loop position and plan reference.
+- The current REVIEW.md — findings to fix.
+- .sdlc/LAWS.md — engineering laws for context on each violation.
+- All files listed in REVIEW.md findings.
+</context>
+
+<process>
+Follow workflow: @~/.claude/sdlc-framework/workflows/fix-findings.md
+
+Step-by-step:
+
+1. **Load review findings**
+   - Read REVIEW.md from .sdlc/phases/{phase}/{plan}-REVIEW.md
+   - Parse all findings: file, line, law, severity, description, suggested fix
+   - Count: blockers, warnings, info
+
+2. **Triage findings**
+   - Group findings by file (fixes to the same file should be applied together)
+   - Identify dependencies between findings:
+     - DRY fix (extract utility) may resolve multiple findings across files
+     - SOLID fix (split class) may move code that has Clean Code findings
+     - YAGNI fix (remove code) may eliminate other findings on the removed code
+   - Order: fix dependent findings first, then independent ones in parallel
+
+3. **Present fix plan to user**
+   ```
+   Review Findings Fix Plan:
+   ═══════════════════════════
+   Blockers to fix: {N}
+   Warnings to fix: {N} (optional — will ask)
+
+   Fix order:
+   1. {file}: {N} findings ({list laws violated})
+   2. {file}: {N} findings ({list laws violated})
+
+   Estimated changes: {N} files
+   ```
+   Ask: "Proceed with fixing all blockers? For warnings, which would you like fixed?"
+
+4. **Fix blockers** (parallel where possible)
+   - For each file group with independent fixes: spawn sub-agent
+   - Each agent gets: the file, the findings, the engineering laws, the suggested fixes
+   - Agent instruction: "Fix these findings. Do NOT introduce new violations. Follow engineering laws."
+   - For dependent fixes: apply sequentially in dependency order
+   - Track progress via TaskCreate/TaskUpdate
+
+5. **Fix approved warnings** (after blockers are done)
+   - Same process for user-approved warnings
+
+6. **Re-run review**
+   - After all fixes applied, automatically trigger /sdlc:review
+   - Display: "Fixes applied. Re-running review to confirm compliance..."
+
+7. **Handle re-review results**
+   - If new blockers found (fix introduced new violations): report and loop
+   - If clean: route to /sdlc:close
+</process>
+
+<success_criteria>
+- [ ] All blocker findings from REVIEW.md addressed
+- [ ] Fixes follow engineering laws (no new violations introduced)
+- [ ] Findings grouped by file for efficient parallel fixing
+- [ ] Fix dependencies identified and ordered correctly
+- [ ] User approved the fix plan before execution
+- [ ] Sub-agents spawned for independent file fixes
+- [ ] /sdlc:review automatically re-runs after fixes
+- [ ] If review passes: output ends with NEXT ACTION REQUIRED: /sdlc:close
+- [ ] If review fails again: output ends with "New findings found. Re-run /sdlc:fix"
+</success_criteria>