5-phase-workflow 1.5.4 → 1.7.0

package/src/commands/5/reconfigure.md

@@ -0,0 +1,156 @@
+---
+name: 5:reconfigure
+description: Lightweight refresh of project documentation and skills without full Q&A. Re-detects codebase changes, regenerates .5/*.md docs, updates CLAUDE.md, and refreshes all skills.
+allowed-tools: Read, Write, Bash, Glob, Grep, Task, AskUserQuestion
+context: fork
+user-invocable: true
+disable-model-invocation: true
+---
+
+# Reconfigure (Lightweight Refresh)
+
+## Overview
+
+Single-command refresh that skips the full Q&A of `/5:configure`. Re-detects codebase state, regenerates documentation and skills based on existing `config.json` preferences.
+
+**When to use which:**
+
+| Scenario | Command |
+|----------|---------|
+| First-time setup | `/5:configure` |
+| Change preferences (ticket pattern, review tool, etc.) | `/5:configure` |
+| Codebase evolved, refresh docs/skills | **`/5:reconfigure`** |
+| Add new skill patterns | `/5:configure` |
+
+## ⚠️ CRITICAL SCOPE CONSTRAINT
+
+**THIS COMMAND REGENERATES DOCS AND SKILLS. IT DOES NOT CHANGE USER PREFERENCES.**
+
+Your job:
+✅ Validate that config.json exists
+✅ Re-detect codebase patterns and commands (same as configure Steps 1b-1h)
+✅ Compare detected state with config.json skill selections
+✅ Show summary and ask for confirmation
+✅ Invoke configure-project skill in refresh mode
+✅ Update version.json with artifacts and timestamps
+✅ Clean up .reconfig-reminder flag
+✅ Report what was updated
+
+Your job is NOT:
+❌ Ask preference questions (ticket pattern, branch convention, review tool, etc.)
+❌ Modify config.json preferences (only the `skills` section may be updated if user confirms new patterns)
+❌ Skip confirmation — always show what will be regenerated
+
+## Process
+
+### Step 1: Validate Config
+
+Read `.5/config.json`. If it does not exist:
+- Tell the user: "No configuration found. Please run `/5:configure` first to set up your project."
+- **EXIT IMMEDIATELY**
+
+Read `.5/version.json` for current state (configuredAt, configuredAtCommit).
+
+### Step 2: Re-detect Codebase State
+
+Perform the same detection as configure Steps 1b-1h:
+
+**2a. Detect project type** — same table as configure Step 1b (package.json deps, build files, etc.)
+
+**2b. Detect build/test commands** — same as configure Step 1c
+
+**2c. Detect codebase patterns** — same as configure Step 1g:
+- Scan for architectural patterns (Controllers, Services, Components, etc.)
+- Use both suffix-based and directory-based globs
+- For each pattern: count files, identify location, sample filename
+
+**2d. Detect runnable commands** — same as configure Step 1h:
+- Scan package.json scripts, Makefile targets, etc.
+- Categorize: Build, Test, Lint, Format, Type Check, etc.
+
+**2e. Scan existing skills** — list ALL skills in `.claude/skills/`:
+- Read each skill's SKILL.md frontmatter
+- Categorize as workflow-generated (create-*, run-*) or user-created
+
+### Step 3: Compare and Prepare Summary
+
+Use the existing skills in `.claude/skills/` (from Step 2e) as the source of truth — not config.json. Compare what's installed with what's detected in the codebase:
+
+- **Existing `create-*` skills** — extract the pattern name from each (e.g., `create-controller` → `controller`)
+- **Existing `run-*` skills** — extract the command name from each (e.g., `run-tests` → `tests`)
+- **New patterns**: detected in codebase (Step 2c) but no matching `create-*` skill exists → offer to create
+- **Stale patterns**: a `create-*` skill exists but the pattern is no longer detected in the codebase → offer to remove or keep
+- **New commands**: detected (Step 2d) but no matching `run-*` skill exists → offer to create
+- **Stale commands**: a `run-*` skill exists but the command is no longer detected → offer to remove or keep
+- **User-created skills** (not matching `create-*` or `run-*` naming) → always refresh with current conventions, never remove
+
+### Step 4: Confirm with User
+
+Use `AskUserQuestion` to show a summary and get confirmation. Present:
+
+1. **Documentation files that will be rewritten** — list all 7 `.5/*.md` files + CLAUDE.md
+2. **Skills that will be refreshed** — list ALL skills found in `.claude/skills/` (both workflow-generated and user-created)
+3. **New patterns detected** (if any) — "These patterns were found in your codebase but don't have skills yet: [list]. Create skills for them?"
+4. **Stale patterns** (if any) — "These patterns are in your config but weren't found in the codebase: [list]. Remove them?"
+
+Options:
+- "Proceed with refresh" — regenerate everything as shown
+- "Cancel" — exit without changes
+
+If there are new or stale patterns, use additional `AskUserQuestion` calls with multiSelect to let the user pick which new patterns to add and which stale patterns to remove.
+
+New skills will be created and stale skills removed based on the user's choices.
+
+### Step 5: Regenerate
+
+Invoke the `configure-project` skill in **refresh mode** via the Task tool:
+
+```
+Task prompt: "Run configure-project skill in REFRESH MODE.
+
+Refresh ALL existing skills in .claude/skills/:
+- Existing create-* skills: [list from Step 2e]
+- Existing run-* skills: [list from Step 2e]
+- User-created skills: [list from Step 2e]
+- New skills to create: [list from user confirmation, if any]
+- Skills to remove: [list from user confirmation, if any]
+
+Re-analyze the entire codebase (A1 analysis) and:
+1. Rewrite all 7 .5/*.md documentation files
+2. Update CLAUDE.md (preserve user-written sections)
+3. Refresh ALL skills in .claude/skills/ — read current conventions from codebase and update each skill
+4. Create new skills for newly-added patterns
+5. Remove skills the user chose to drop"
+```
+
+Use `subagent_type: "general-purpose"` for the Task.
+
+### Step 6: Track
+
+After the skill completes, update `.5/version.json`:
+
+1. Read current version.json
+2. Set `configuredAt` to current ISO timestamp
+3. Set `configuredAtCommit` to current short commit hash (`git rev-parse --short HEAD`)
+4. Write back version.json preserving all other fields
+
+### Step 7: Clean Up
+
+Remove the `.5/.reconfig-reminder` flag file if it exists:
+```bash
+rm -f .5/.reconfig-reminder
+```
+
+### Step 8: Report
+
+Show the user a summary:
+- List of documentation files updated
+- List of skills refreshed
+- List of new skills created (if any)
+- List of skills removed (if any)
+- Timestamp of reconfiguration
+- Suggest running `/clear` to reset context
+
+## Related Documentation
+- [configure command](./configure.md) — full Q&A configuration
+- [configure-project skill](../../skills/configure-project/SKILL.md) — the skill that does the heavy lifting

package/src/commands/5/review-code.md

@@ -1,19 +1,19 @@
 ---
 name: 5:review-code
-description: Reviews code changes using Claude (built-in) or CodeRabbit CLI. Handles user interaction and fix application in main context.
-allowed-tools: Bash, Read, Edit, Write, Glob, Grep, AskUserQuestion, Task, mcp__jetbrains__*
+description: Reviews code changes using Claude (built-in) or CodeRabbit CLI. Categorizes findings and saves them for /5:address-review-findings.
+allowed-tools: Bash, Read, Glob, Grep, AskUserQuestion, Task, mcp__jetbrains__*
 model: sonnet
 context: fork
 user-invocable: true
+disable-model-invocation: true
 ---
 
 <role>
-You are a Code Reviewer. You review code and apply user-approved fixes.
-You do NOT implement new features. You do NOT refactor beyond review findings.
-You ALWAYS get user consent before applying ANY fix.
-You ALWAYS verify changes after applying fixes (build + test).
+You are a Code Reviewer. Your job is to review code, categorize findings, and save them to a findings file.
+You do NOT apply fixes. You do NOT implement new features. You do NOT refactor code.
+Fix application is handled by /5:address-review-findings.
 You follow the exact step sequence below. Do not skip or reorder steps.
-After saving the review report, you are DONE.
+After saving the findings file, you are DONE.
 </role>
 
 # Review Code (Phase 5)
@@ -44,35 +44,23 @@ If not installed or not authenticated, ask user via AskUserQuestion:
 - "Switch to Claude for this review? (Recommended)" / "I'll install CodeRabbit first"
 - If they choose CodeRabbit setup, provide install instructions and STOP
 
-### Step 2: Check for Apply Mode
-
-If user invoked with `apply` argument (`/5:review-code apply`):
-- Skip to Step 10 (Apply Annotated Findings)
-- Do NOT run a new review
-
-Otherwise, continue with new review.
-
-### Step 3: Determine What to Review
+### Step 2: Determine What to Review
 
 Ask the user via AskUserQuestion:
 
-**Question 1: What to review?**
+**Question: What to review?**
 1. Staged changes (`git diff --cached`) — default
 2. Unstaged changes (`git diff`)
 3. All changes (`git diff HEAD`)
 4. Current branch vs main/master (`git diff main...HEAD`)
 
-**Question 2: How to present results?**
-1. Interactive (show findings, apply fixes immediately) — default
-2. Save to file (for later annotation with `[FIX]`/`[SKIP]`/`[MANUAL]`)
-
-### Step 4: Spawn Review Agent
+### Step 3: Spawn Review Agent
 
 Spawn a single agent to execute the review. Do NOT run the review yourself.
 
-**Architecture:** You (main agent) handle user interaction and fix application. The spawned agent runs the review and categorizes findings.
+**Architecture:** You (main agent) handle user interaction. The spawned agent runs the review and categorizes findings.
 
-#### 4A: CodeRabbit Review Agent
+#### 3A: CodeRabbit Review Agent
 
 ```
 Task tool call:
@@ -83,7 +71,7 @@ Task tool call:
     Run CodeRabbit CLI and categorize findings.
 
     ## Review Scope
-    Scope: {scope from Step 3}
+    Scope: {scope from Step 2}
     Base Branch: {branch-name if scope is "branch"}
 
     ## Process
@@ -115,7 +103,7 @@ Task tool call:
     - Include ALL findings
 ```
 
-#### 4B: Claude Review Agent
+#### 3B: Claude Review Agent
 
 ```
 Task tool call:
@@ -127,7 +115,7 @@ Task tool call:
     Review this code blind, purely on its merits.
 
     ## Review Scope
-    Scope: {scope from Step 3}
+    Scope: {scope from Step 2}
     Base Branch: {branch-name if scope is "branch"}
 
     ## Process
@@ -169,17 +157,13 @@ Task tool call:
     - Be thorough but practical — focus on real issues, not style nitpicks
 ```
 
-### Step 5: Process Agent Results
+### Step 4: Process Agent Results
 
 Receive structured results from the agent. If agent returned failure, report error and STOP.
 
-**If user selected "Save to file":** Skip to Step 9.
+### Step 5: Present Findings
 
-**If user selected "Interactive":** Continue to Step 6.
-
-### Step 6: Present Overview and Ask User
-
-Present ALL findings to the user first. Do NOT apply anything yet.
+Present ALL findings to the user.
 
 ```
 Code Review Results:
@@ -200,87 +184,31 @@ Manual Review Needed:
 - {file}:{line} - {description}
 ```
 
-Ask via AskUserQuestion: "Which fixable issues should be applied?"
-- Options: All / Selected / None
-
-### Step 7: Apply User-Approved Fixes
-
-**ONLY apply fixes the user has agreed to.**
-
-- If "All": Apply all fixable issues
-- If "Selected": Ask which specific fixes, then apply only those
-- If "None": Skip to Step 8
-
-For each fix:
-1. Read the file
-2. Apply the fix using Edit tool
-3. Track applied fixes
-
-### Step 8: Handle Questions
-
-If there are questions from the reviewer, ask via AskUserQuestion:
-- "Ask me each question" / "Skip all questions"
-
-If "Ask me each": Present each question individually via AskUserQuestion. If the answer requires a code change, apply it.
-
-### Step 9: Save Findings to File (File-Based Mode)
-
-For "Save to file" mode only.
+### Step 6: Save Findings to File
 
 Determine feature name from `.5/features/*/state.json` (most recent by `startedAt` field) or ask user.
 
-Write to `.5/features/{feature-name}/review-{YYYYMMDD-HHmmss}-findings.md`.
-
-Use the template structure from `.claude/templates/workflow/REVIEW-FINDINGS.md`. Include all findings with `[FIX]`/`[SKIP]`/`[MANUAL]` action markers.
-
-Tell user: "Findings saved. Edit the file to mark actions, then run `/5:review-code apply`"
-
-Skip to REVIEW COMPLETE.
-
-### Step 10: Apply Annotated Findings (Apply Mode)
-
-When invoked with `apply`:
-
-1. Determine feature name from `.5/features/*/state.json` (most recent by `startedAt` field) or ask user
-2. Find most recent `review-*-findings.md` in the feature folder
-3. If none found, tell user to run `/5:review-code` first and STOP
-4. Parse each finding and its action marker: `[FIX]`, `[SKIP]`, `[MANUAL]`
-5. Apply `[FIX]` findings using Edit tool
-6. Apply `[MANUAL]` findings using custom instructions from the file
-7. Skip `[SKIP]` findings
-8. Continue to Step 11
+Write to `.5/features/{feature-name}/review-findings-{YYYYMMDD-HHmmss}.md`.
 
-### Step 11: Verify Changes
-
-After applying any fixes (interactive or file-based):
-
-1. **Build:** Use the `/build-project` skill: `Skill tool: skill="build-project", args="target=compile"`
-2. **Test:** Use the `/run-tests` skill: `Skill tool: skill="run-tests", args="target=all"`
-3. If build fails: report which fixes caused issues
-4. If tests fail: report which tests failed
-
-### Step 12: Save Review Report
-
-**Interactive mode:** Save summary to `.5/features/{feature-name}/review-{YYYYMMDD-HHmmss}.md`
-
-Use the template structure from `.claude/templates/workflow/REVIEW-SUMMARY.md`.
-
-**Apply mode:** Append application results to the findings file with: fixes applied count, custom fixes count, skipped count, build/test status.
+Use the template structure from `.claude/templates/workflow/REVIEW-FINDINGS.md`. All findings get their default action markers:
+- Fixable items → `[FIX]`
+- Manual items → `[MANUAL]`
+- Questions → `[FIX]` (with the question as the suggested fix instruction)
 
 ## REVIEW COMPLETE
 
-After saving the report, output exactly:
+Output exactly:
 
 ```
 Review complete.
 
-- Fixes applied: {N}
-- Questions resolved: {N}
+- Fixable: {N}
+- Questions: {N}
 - Manual review needed: {N}
-- Build: {passed/failed}
-- Tests: {passed/failed}
 
-Report saved at `.5/features/{feature-name}/review-{timestamp}.md`
+Findings saved at `.5/features/{feature-name}/review-findings-{timestamp}.md`
+
+Edit the file to adjust actions ([FIX] / [SKIP] / [MANUAL]), then run `/5:address-review-findings {feature-name}` to apply fixes and optionally address GitHub PR comments.
 ```
 
 STOP. You are a reviewer. Your job is done. Do not implement new features.

package/src/commands/5/unlock.md

@@ -4,6 +4,7 @@ description: Remove the planning guard lock to allow edits outside the workflow
 allowed-tools: Bash
 context: inherit
 user-invocable: true
+disable-model-invocation: true
 ---
 
 # Unlock Planning Guard

package/src/commands/5/update.md

@@ -4,6 +4,7 @@ description: Update the 5-Phase Workflow to the latest version
 allowed-tools: Bash, Read, AskUserQuestion
 context: inherit
 user-invocable: true
+disable-model-invocation: true
 ---
 
 # Update 5-Phase Workflow

package/src/commands/5/verify-implementation.md

@@ -4,6 +4,7 @@ description: Verifies a feature implementation is complete and working with mult
 allowed-tools: Read, Glob, Grep, Bash, Write, Task, AskUserQuestion
 context: fork
 user-invocable: true
+disable-model-invocation: true
 ---
 
 # Verify Implementation (Phase 4)
@@ -154,6 +155,12 @@ For each component with action `create` in the plan:
 
 This is a lightweight check — it only verifies test files exist for new code, not test quality.
 
+**Test requirement enforcement:**
+- Components with logic (services, controllers, repositories, hooks, utilities, helpers) without tests → MISSING_REQUIRED_TEST (error-level)
+- Declarative components (types, interfaces, models without logic) without tests → MISSING_OPTIONAL_TEST (info-level, not counted as issues)
+
+If no test framework detected (no test runner in config, no existing test files found via Glob for `**/*.test.*`, `**/*.spec.*`, `**/test_*.*`), downgrade all MISSING_REQUIRED_TEST to warnings with note: "No test framework detected."
+
 ### Step 5: Determine Status
 
 Evaluate all three layers:
@@ -168,10 +175,11 @@ Evaluate all three layers:
 
 **PARTIAL** — infrastructure OK but gaps exist:
 - All files exist AND build succeeds AND tests pass
-- BUT: some acceptance criteria not satisfied, OR some requirements not implemented, OR some components partial, OR some new files lack tests
+- BUT: some acceptance criteria not satisfied, OR some requirements not implemented, OR some components partial, OR logic-bearing components lack tests but project has no test framework
 
 **FAILED** — infrastructure problems:
 - Any files missing, OR build fails, OR tests fail
+- Any logic-bearing components lack test files (MISSING_REQUIRED_TEST) AND project has a test framework
 
 ### Step 6: Generate Verification Report
 
@@ -223,7 +231,8 @@ Build fix entries from verification results:
 - Partial components → fix: describe what's missing from the component
 
 **From Layer 3 (Quality):**
-- Missing test files → fix: create test file for the component
+- Missing required test files (logic-bearing components) → fix: create test file for the component (priority: high)
+- Missing optional test files (declarative components) → note in report, no fix entry
 
 Each fix entry follows the same table format as `plan.md`:
 

package/src/hooks/check-reconfig.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Read JSON from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    let workspaceDir = process.cwd();
+    if (input.trim()) {
+      const data = JSON.parse(input);
+      workspaceDir = data.cwd || data.workspace?.current_dir || workspaceDir;
+    }
+
+    checkReconfigure(workspaceDir);
+  } catch (e) {
+    // Silent failure - don't block on errors
+    process.exit(0);
+  }
+});
+
+function checkReconfigure(workspaceDir) {
+  const versionFile = path.join(workspaceDir, '.5', 'version.json');
+  const flagFile = path.join(workspaceDir, '.5', '.reconfig-reminder');
+
+  if (!fs.existsSync(versionFile)) {
+    process.exit(0);
+  }
+
+  let versionData;
+  try {
+    versionData = JSON.parse(fs.readFileSync(versionFile, 'utf8'));
+  } catch (e) {
+    process.exit(0);
+  }
+
+  const { configuredAt, configuredAtCommit } = versionData;
+
+  // No configure data yet - skip (user hasn't run /5:configure)
+  if (!configuredAt) {
+    process.exit(0);
+  }
+
+  // Calculate days elapsed
+  let daysElapsed = 0;
+  try {
+    daysElapsed = Math.floor((Date.now() - new Date(configuredAt).getTime()) / (1000 * 60 * 60 * 24));
+  } catch (e) {
+    process.exit(0);
+  }
+
+  // Count commits since configured
+  let commitCount = 0;
+  if (configuredAtCommit) {
+    try {
+      const result = execSync(`git rev-list --count ${configuredAtCommit}..HEAD`, {
+        cwd: workspaceDir,
+        timeout: 3000,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+      commitCount = parseInt(result.trim(), 10) || 0;
+    } catch (e) {
+      // Git command failed (commit not found, not a repo, etc.) - skip
+    }
+  }
+
+  // Write or remove temp flag file (never touches version.json)
+  const COMMIT_THRESHOLD = 50;
+  const DAYS_THRESHOLD = 30;
+  const shouldRemind = daysElapsed >= DAYS_THRESHOLD || commitCount >= COMMIT_THRESHOLD;
+
+  try {
+    if (shouldRemind) {
+      fs.writeFileSync(flagFile, '1');
+    } else if (fs.existsSync(flagFile)) {
+      fs.unlinkSync(flagFile);
+    }
+  } catch (e) {
+    // Can't write/delete temp file - skip
+  }
+
+  process.exit(0);
+}

package/src/hooks/statusline.js

@@ -43,22 +43,31 @@ process.stdin.on('end', () => {
     // Shorten directory path for display
     const shortDir = dir.replace(os.homedir(), '~');
 
-    // Check for available update
+    // Check for available update and reconfigure reminder
     let updateIndicator = '';
+    let reconfigIndicator = '';
     try {
       const versionFile = path.join(dir, '.5', 'version.json');
       const versionData = JSON.parse(fs.readFileSync(versionFile, 'utf8'));
+
+      // Update check
       const latest = versionData.latestAvailableVersion;
       const installed = versionData.installedVersion;
       if (latest && installed && compareVersions(installed, latest) < 0) {
         updateIndicator = ` | \x1b[33m↑${latest} → /5:update\x1b[0m`;
       }
+
+      // Reconfigure check (reads flag file in .5/, gitignored)
+      const flagFile = path.join(dir, '.5', '.reconfig-reminder');
+      if (fs.existsSync(flagFile)) {
+        reconfigIndicator = ` | \x1b[35m↻ /5:reconfigure\x1b[0m`;
+      }
     } catch (e) {
       // No version file or parse error — no indicator
     }
 
-    // Build and output statusline: model | directory | context | update
-    const statusline = `\x1b[36m${model}\x1b[0m | \x1b[90m${shortDir}\x1b[0m${ctx}${updateIndicator}`;
+    // Build and output statusline: model | directory | context | update | reconfig
+    const statusline = `\x1b[36m${model}\x1b[0m | \x1b[90m${shortDir}\x1b[0m${ctx}${updateIndicator}${reconfigIndicator}`;
     process.stdout.write(statusline);
 
   } catch (e) {

package/src/settings.json

@@ -14,6 +14,16 @@
             "timeout": 10
           }
         ]
+      },
+      {
+        "matcher": "startup",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/check-reconfig.js",
+            "timeout": 10
+          }
+        ]
       }
     ],
     "PreToolUse": [

package/src/skills/configure-project/SKILL.md

@@ -22,6 +22,29 @@ Note: config.json is written directly by `/5:configure` during the Q&A phase.
 
 ---
 
+## Modes
+
+This skill supports two modes. The analysis (A1), template filling (A2-A3), CLAUDE.md update (A4-A5), and skill generation (B) logic is the same in both modes — only the **input source** changes.
+
+### Full Mode (default)
+
+Used by `/5:configure` → `/5:implement-feature CONFIGURE` flow.
+
+- **Input:** Pattern/command selections from feature spec (`.5/features/CONFIGURE/feature.md`)
+- **Behavior:** Creates everything from scratch based on feature spec requirements
+
+### Refresh Mode
+
+Used by `/5:reconfigure` for lightweight refresh.
+
+- **Input:** The Task prompt lists which skills to refresh, create, and remove (determined by `/5:reconfigure` after scanning `.claude/skills/` and comparing with detected codebase patterns)
+- **Behavior:** Re-analyzes codebase, overwrites docs and refreshes/creates/removes skills as specified
+- **Trigger:** Task prompt includes "REFRESH MODE"
+
+In both modes, the analysis and generation logic is identical — only where the skill list comes from differs.
+
+---
+
 ## A. Analyze Codebase and Create/Update CLAUDE.md
 
 **Process:**

package/src/templates/workflow/PLAN.md

@@ -9,6 +9,8 @@ created: {ISO-timestamp}
 - Description column: one action-oriented sentence per component
 - Implementation Notes: reference existing files as patterns, no code snippets
 - Components table must cover all functional requirements from feature.md
+- Every "create" component with logic (services, controllers, repositories, utilities) must have a corresponding test component
+- Declarative-only components (types, interfaces, route wiring) are exempt from test requirements
 -->
 
 # Implementation Plan: {TICKET-ID}
@@ -24,6 +26,7 @@ created: {ISO-timestamp}
 | 2 | {name} | create | {path} | {what it does} | moderate |
 | 2 | {name} | modify | {path} | {what to change} | moderate |
 | 3 | {name} | create | {path} | {what it does} | complex |
+| 4 | {name} tests | create | {test-path} | Test {what it tests} | moderate |
 
 ## Implementation Notes
 

package/src/templates/workflow/REVIEW-FINDINGS.md

@@ -14,9 +14,9 @@
    - `[SKIP]` - Don't apply this fix (change FIX to SKIP)
    - `[MANUAL]` - Custom instructions (change FIX to MANUAL and add instructions)
 3. Save this file
-4. Run: `/review-code apply`
+4. Run: `/5:address-review-findings`
 
-The apply command will read your annotations and apply marked fixes.
+The command will read your annotations and apply marked fixes.
 
 ---
 
@@ -55,4 +55,4 @@ The apply command will read your annotations and apply marked fixes.
 
 **Next Steps:**
 1. Edit this file to mark which findings to fix
-2. Run: `/review-code apply`
+2. Run: `/5:address-review-findings`

package/src/templates/workflow/VERIFICATION-REPORT.md

@@ -73,14 +73,22 @@
 
 ### Test Coverage for New Files
 
+**Required Tests (logic-bearing components):**
+
+| New File | Test File | Status |
+|----------|-----------|--------|
+| {src/path/Service.ts} | {src/path/Service.test.ts} | HAS TEST |
+| {src/path/Controller.ts} | — | MISSING REQUIRED TEST |
+
+**Optional Tests (declarative components):**
+
 | New File | Test File | Status |
 |----------|-----------|--------|
-| {src/path/File.ts} | {src/path/File.test.ts} | HAS TEST |
-| {src/path/Other.ts} | — | NO TEST |
+| {src/path/types.ts} | — | NO TEST (exempt) |
 
-**Result:** {N}/{M} new files have tests
+**Result:** {N}/{M} required test files exist
 
-**Layer 3 Result:** PASSED | PARTIAL
+**Layer 3 Result:** PASSED | FAILED | PARTIAL
 
 ---