5-phase-workflow 1.1.1 → 1.2.0

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

@@ -1,307 +1,371 @@
 ---
 name: 5:verify-implementation
-description: Verifies completed feature implementation by delegating checks to verification-agent. Runs in forked context to minimize main context usage.
-allowed-tools: Read, Glob, Write, AskUserQuestion, Bash, Task, mcp__jetbrains__*
+description: Verifies a feature implementation is complete and working with multi-layer checks. Phase 4 of the 5-phase workflow.
+allowed-tools: Read, Glob, Grep, Bash, Write, Task, AskUserQuestion
 context: fork
 user-invocable: true
 ---
 
 # Verify Implementation (Phase 4)
 
-## Overview
+Verify that an implementation is complete, correct, and meets feature requirements through multi-layer verification.
 
-This skill provides comprehensive verification of a completed feature implementation. It is typically invoked:
-1. Automatically by `/implement-feature` at the end of Wave 7
-2. Manually by the developer to verify a feature
-3. After fixing issues to re-verify
+## Scope
 
-**Architecture:** `Command -> Agent -> Tools`
-- This command runs in forked context to minimize main context usage
-- Delegates verification work to the verification-agent (also forked context)
-- Handles reporting, state updates, and user interaction within the forked context
+**This command verifies the implementation across three layers:**
+1. Infrastructure — files exist, build passes, tests pass
+2. Feature completeness — code satisfies acceptance criteria and requirements from the feature spec
+3. Quality — new files have corresponding tests
 
-## Verification Process
+If verification finds gaps, it generates a fix plan and offers to apply fixes automatically.
 
-### Step 1: Load Implementation Plan
+## Process
 
-Read the implementation plan from `.5/{feature-name}/plan/` where `{feature-name}` is the argument provided by the user.
+### Step 1: Load All Artifacts
 
-**Error Handling:** If the plan directory is missing:
-- Return fail status immediately
-- Display clear error message: "Error: Implementation plan not found at `.5/{feature-name}/plan/`. Please run /5:plan-implementation first."
-- Do not proceed to Step 2
+Read all workflow artifacts for the feature:
 
-**Load metadata:**
-- Read `.5/{feature-name}/plan/meta.md`
-- Parse YAML frontmatter for basic plan info
+**Required:**
+- `.5/{feature-name}/plan.md` — implementation plan (Phase 2)
+- `.5/{feature-name}/state.json` — implementation state (Phase 3)
 
-**Load verification config:**
-- Read `.5/{feature-name}/plan/verification.md`
-- Extract:
-  - `build_command`
-  - `test_command`
-  - Expected New Files list
-  - Expected Modified Files list
-  - Build Targets list
-  - Test Modules list
+**Optional:**
+- `.5/{feature-name}/feature.md` — feature spec (Phase 1)
 
-**Load component checklist (aggregate from all step files):**
-- For each step (1 to total_steps from meta.md):
-  - Read `.5/{feature-name}/plan/step-{N}.md`
-  - Extract "Expected Outputs" section (files created/modified)
-- Build comprehensive expected files list to pass to verification-agent
+**If `plan.md` or `state.json` is missing:** hard stop.
+```
+Cannot verify — missing required artifacts.
+
+Missing: {plan.md | state.json | both}
+
+Run these first:
+- /5:plan-implementation {feature-name}  (creates plan.md)
+- /5:implement-feature {feature-name}    (creates state.json)
+```
+
+**If `feature.md` is missing:** warn and continue. Feature completeness verification (Layer 2) will be skipped.
+```
+Note: feature.md not found — skipping feature completeness checks.
+This is normal for quick-implement workflows. Infrastructure and quality checks will still run.
+```
+
+Extract from artifacts:
+- Components table from `plan.md` (step, component, action, file, description, complexity)
+- Build and test commands from `plan.md`
+- Completed/failed components from `state.json`
+- Acceptance criteria and functional requirements from `feature.md` (if present)
+
+### Step 2: Infrastructure Verification (Layer 1)
 
-### Step 2: Spawn verification-agent
+#### 2a. Check Files Exist
 
-Read `.claude/agents/verification-agent.md` for agent instructions, then spawn via Task tool:
+For each component in the plan:
+- Use Glob to verify the file exists
+- Record: EXISTS / MISSING
+
+#### 2b. Run Build
+
+Execute the build command from the plan (or auto-detect from `.claude/.5/config.json`):
+
+```bash
+{build-command}
+```
+
+Record: SUCCESS / FAILED with errors.
+
+**If build fails, stop here.** Broken code cannot be meaningfully verified for completeness. Set overall status to FAILED and skip to Step 6.
+
+#### 2c. Run Tests
+
+Execute the test command from the plan (or auto-detect):
+
+```bash
+{test-command}
+```
+
+Record: SUCCESS / FAILED with details (which tests failed, error messages).
+
+### Step 3: Feature Completeness Verification (Layer 2)
+
+**Skip this step entirely if `feature.md` was not found in Step 1.**
+
+Spawn a sonnet agent to cross-reference the implementation against the feature spec:
 
 ```
 Task tool call:
   subagent_type: general-purpose
-  description: "Verify {feature-name}"
+  model: sonnet
+  description: "Verify feature completeness for {feature-name}"
   prompt: |
-    {Contents of verification-agent.md}
-
-    ---
-
-    ## Your Task
-
-    Feature Name: {feature-name}
-    Implementation Plan Path: .5/{feature-name}/plan/
-    Expected Files:
-    - {path/to/file1.ext}
-    - {path/to/file2.ext}
-    (aggregated from all step files in Step 1)
-    Affected Modules:
-    - {module-path-1}
-    - {module-path-2}
-    (from verification.md)
-    Test Modules:
-    - {module-path-for-tests}
-    (from verification.md)
-    Build Command: {from verification.md}
-    Test Command: {from verification.md}
+    You are verifying that an implementation satisfies its feature specification.
+
+    ## Feature Specification
+    {full text of feature.md}
+
+    ## Implementation Plan
+    {full text of plan.md}
+
+    ## Instructions
+
+    1. **Read each implemented file** listed in the components table below:
+       {components table from plan.md}
+
+    2. **Check acceptance criteria** from the feature spec.
+       For each acceptance criterion, determine:
+       - SATISFIED — code clearly implements this criterion (cite file:line as evidence)
+       - NOT SATISFIED — no code found that implements this criterion
+
+    3. **Check functional requirements** from the feature spec.
+       For each requirement, determine:
+       - IMPLEMENTED — code implements this requirement (cite file:line)
+       - NOT IMPLEMENTED — no code found for this requirement
+
+    4. **Check component completeness** from the plan.
+       For each component in the table, read the file and determine:
+       - COMPLETE — file exists and implements what the description says
+       - PARTIAL — file exists but is missing described functionality
+       - MISSING — file does not exist
+
+    ## Output Format
+    Return EXACTLY this structure:
+
+    ACCEPTANCE_CRITERIA:
+    - criterion: "{text of criterion}"
+      status: SATISFIED | NOT SATISFIED
+      evidence: "{file:line}" or "none"
+      notes: "{brief explanation}"
+
+    REQUIREMENTS:
+    - requirement: "{text of requirement}"
+      status: IMPLEMENTED | NOT IMPLEMENTED
+      evidence: "{file:line}" or "none"
+      notes: "{brief explanation}"
+
+    COMPONENTS:
+    - component: "{component name}"
+      file: "{file path}"
+      status: COMPLETE | PARTIAL | MISSING
+      notes: "{what's missing if partial}"
+
+    SUMMARY:
+    - criteria_satisfied: {N}/{M}
+    - requirements_implemented: {N}/{M}
+    - components_complete: {N}/{M}
+
+    ## Rules
+    - Read every file referenced in the components table
+    - Be precise with evidence — cite actual file paths and line numbers
+    - PARTIAL means the file exists but is missing specific functionality described in the plan
+    - Do NOT interact with the user
+    - Do NOT modify any files
 ```
 
-### Step 3: Process Agent Results
+Parse the agent's structured output into:
+- Acceptance criteria results (satisfied/not satisfied counts)
+- Requirements results (implemented/not implemented counts)
+- Component completeness results (complete/partial/missing counts)
 
-Receive the structured results from verification-agent:
-- Overall status (passed/passed-with-warnings/failed)
-- Implementation completeness results (tasks, method signatures, test coverage, acceptance criteria)
-- File existence results
-- Problem detection results (errors vs warnings)
-- Compilation results
-- Test results
-- Generated verification report (Markdown)
+### Step 4: Quality Checks (Layer 3)
 
-### Step 4: Save Verification Report
+For each component with action `create` in the plan:
+- Determine the expected test file path using common patterns:
+  - `src/foo/Bar.ts` → look for `src/foo/Bar.test.ts`, `src/foo/Bar.spec.ts`, `test/foo/Bar.test.ts`, `tests/foo/Bar.test.ts`
+  - `src/foo/bar.py` → look for `tests/foo/test_bar.py`, `tests/test_bar.py`, `src/foo/test_bar.py`
+  - Adapt pattern based on project conventions
+- Use Glob to check if a test file exists
+- Record: HAS TEST / NO TEST
 
-Write the verification report from the agent to:
-`.5/{feature-name}/verification.md`
+This is a lightweight check — it only verifies test files exist for new code, not test quality.
 
-### Step 5: Update State File
+### Step 5: Determine Status
 
-Update `.5/{feature-name}/state.json` with verification results:
+Evaluate all three layers:
 
-```json
-{
-  "verificationResults": {
-    "status": "passed | passed-with-warnings | failed",
-    "timestamp": "{ISO timestamp}",
-    "implementationCompleteness": {
-      "tasksTotal": N,
-      "tasksCompleted": N,
-      "tasksPartial": N,
-      "tasksMissing": N
-    },
-    "filesChecked": N,
-    "filesExist": N,
-    "compilationStatus": "success | failed",
-    "testStatus": "passed | failed",
-    "testsTotal": N,
-    "testsPassed": N,
-    "testsFailed": N,
-    "errorsFound": N,
-    "warningsFound": N,
-    "reportPath": ".5/{feature-name}/verification.md"
-  }
-}
-```
+**PASSED** — all conditions met:
+- All files exist
+- Build succeeds
+- Tests pass
+- All acceptance criteria satisfied (or Layer 2 skipped)
+- All requirements implemented (or Layer 2 skipped)
+- All components complete
+
+**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
+
+**FAILED** — infrastructure problems:
+- Any files missing, OR build fails, OR tests fail
+
+### Step 6: Generate Verification Report
+
+Write `.5/{feature-name}/verification.md` using the template structure from `.claude/templates/workflow/VERIFICATION-REPORT.md`.
+
+The report covers:
+- **Header:** ticket, feature, status, timestamp
+- **Layer 1 — Infrastructure:** file existence checklist, build result, test result
+- **Layer 2 — Feature Completeness:** acceptance criteria status, requirements status, component completeness (or "Skipped — no feature.md" if not available)
+- **Layer 3 — Quality:** test coverage for new files
+- **Summary table:** layer-by-layer pass/fail overview
 
-If status is "passed" or "passed-with-warnings", also update:
+### Step 7: Update State
+
+Update `.5/{feature-name}/state.json`:
 ```json
 {
-  "status": "completed",
-  "completedAt": "{ISO timestamp}"
+  "verificationStatus": "passed | partial | failed",
+  "verifiedAt": "{ISO-timestamp}",
+  "verificationLayers": {
+    "infrastructure": "passed | failed",
+    "featureCompleteness": "passed | partial | skipped",
+    "quality": "passed | partial"
+  }
 }
 ```
 
-### Step 6: Inform Developer
+### Step 8: Handle Results
 
 **If PASSED:**
+
 ```
-Verification PASSED!
+Verification passed!
 
-All checks completed successfully:
-- Implementation: {N}/{N} tasks completed
-- Files: {N}/{N} exist
-- Compilation: Success
-- Tests: All passing ({N} tests)
-- Errors: 0
-- Warnings: {N}
+Layer 1 (Infrastructure): All files exist, build OK, tests OK
+Layer 2 (Feature Completeness): {N}/{N} criteria satisfied, {N}/{N} requirements implemented
+Layer 3 (Quality): {N}/{N} new files have tests
 
-Verification report: .5/{feature-name}/verification.md
+Report: .5/{feature-name}/verification.md
 
-Next steps:
-1. Commit your changes (recommended before code review)
-2. Run `/clear` to reset context
-3. Run `/5:review-code` for CodeRabbit review
+Would you like to commit these changes?
 ```
 
-**If PASSED WITH WARNINGS:**
-```
-Verification PASSED with warnings
+Use AskUserQuestion with options:
+1. "Yes - commit now (Recommended)"
+2. "No - I'll commit later"
 
-All critical checks passed, but warnings were found:
-- Implementation: {N}/{N} tasks completed ({N} partial or minor deviations)
-- Files: {N}/{N} exist
-- Compilation: Success
-- Tests: All passing ({N} tests)
-- Errors: 0
-- Warnings: {N}
+If yes: stage and commit with message format `{TICKET-ID} {description}`.
 
-See warnings in verification report:
-.5/{feature-name}/verification.md
+Then go to Step 11 (Next Steps).
 
-You may address warnings before committing, but they don't block completion.
+**If PARTIAL or FAILED:**
 
-Next steps:
-1. Commit your changes (recommended before code review)
-2. Run `/clear` to reset context
-3. Run `/5:review-code` for CodeRabbit review
 ```
+Verification {status}.
+
+Layer 1 (Infrastructure): {summary}
+Layer 2 (Feature Completeness): {summary}
+Layer 3 (Quality): {summary}
 
-**If FAILED:**
+{Count} issue(s) found. Generating fix plan...
+
+Report: .5/{feature-name}/verification.md
 ```
-Verification FAILED
 
-Issues found:
-- Implementation: {N}/{N} tasks incomplete
-- Files missing: {N}
-- Compilation: Failed
-- Tests: {N} failures
-- Errors: {N}
+Continue to Step 9.
 
-See detailed errors in verification report:
-.5/{feature-name}/verification.md
+### Step 9: Generate Fix Plan (PARTIAL or FAILED only)
 
-Please fix the errors and complete missing tasks, then re-run /verify-implementation {feature-name}
-```
+Write `.5/{feature-name}/fix-plan.md` using the template structure from `.claude/templates/workflow/FIX-PLAN.md`.
 
-### Step 7: Prompt for Commit
+Build fix entries from verification results:
 
-**Only if verification PASSED or PASSED WITH WARNINGS**, use AskUserQuestion to ask if the user wants to commit the changes:
+**From Layer 1 (Infrastructure):**
+- Missing files → fix: create the file (reference the plan component)
+- Build failures → fix: describe the build error and likely cause
+- Test failures → fix: describe failing test and likely cause
 
-**Question:**
-```
-Would you like to commit these changes now?
+**From Layer 2 (Feature Completeness):**
+- Unsatisfied acceptance criteria → fix: describe what code needs to change
+- Unimplemented requirements → fix: describe what needs to be added
+- Partial components → fix: describe what's missing from the component
+
+**From Layer 3 (Quality):**
+- Missing test files → fix: create test file for the component
+
+Each fix entry follows the same table format as `plan.md`:
+
+| # | Category | File | Issue | Fix | Complexity |
+|---|----------|------|-------|-----|------------|
+| 1 | infrastructure | src/models/Foo.ts | File missing | Create file per plan component #3 | simple |
+| 2 | feature-gap | src/services/Bar.ts | Missing validation for criterion "..." | Add input validation in processOrder() | moderate |
+| 3 | quality | tests/services/Bar.test.ts | No test file for BarService | Create test file with basic CRUD tests | simple |
+
+### Step 10: Offer Fix Options
+
+Use AskUserQuestion:
+1. "Apply fixes automatically (Recommended)" — spawn agents to apply each fix
+2. "I'll fix manually, then re-run /5:verify-implementation"
+
+**If user selects "Apply fixes automatically":**
+
+For each fix in the fix plan, spawn an agent following the same pattern as `implement-feature`:
+
+- **simple** fixes → `haiku` model
+- **moderate** fixes → `haiku` or `sonnet` depending on context
+- **complex** fixes → `sonnet` model
+
+Group independent fixes for parallel execution. Fixes modifying the same file must be sequential.
 
-It's recommended to commit changes before running CodeRabbit review (/review-code).
 ```
+Task tool call:
+  subagent_type: general-purpose
+  model: {based on complexity}
+  description: "Fix: {short description}"
+  prompt: |
+    You are fixing a verification issue in a codebase.
 
-**Options:**
-1. "Yes - Create commit now (Recommended)"
-2. "No - I'll commit manually later"
+    ## Issue
+    Category: {infrastructure | feature-gap | quality}
+    File: {file-path}
+    Issue: {description of what's wrong}
+    Fix: {description of what to do}
 
-**If user selects "Yes":**
-- Create commit using the standard commit message format below
-- Stage all relevant files
-- Create commit with proper message format
-- After committing, tell user: "Changes committed. Next steps: Run `/clear` followed by `/5:review-code` for CodeRabbit review."
+    ## Context
+    {relevant section from plan.md or feature.md}
 
-**If user selects "No":**
-- Tell user: "You can commit the changes manually when ready. After committing, run `/clear` followed by `/5:review-code` for CodeRabbit review."
+    ## Instructions
+    1. If creating a new file: find a similar existing file using Glob, read it to understand the pattern, create the new file following that pattern
+    2. If modifying a file: read the file, make the described change
+    3. Verify the file exists after changes
+    4. Report what you did
 
-#### Commit Message Format
+    Use Glob to find similar files. Use Read to understand patterns. Use Write/Edit to create/modify files.
+```
 
-**CRITICAL:** Follow this exact format when creating commits:
+After all fixes are applied, re-run build and tests:
 
+```bash
+{build-command}
+{test-command}
 ```
-{TICKET-ID} Short description of what is done (~50 chars)
 
-- What changed and why (important points only)
-- Another change and reason
-- Keep it concise, no verbose descriptions
-- No emojis
+Update `fix-plan.md` with results:
+- Mark each fix as APPLIED / FAILED
+- Record build and test results after fixes
+
+Report to user:
 ```
+Applied {N} fixes.
 
-**Guidelines:**
-- First line: `{TICKET-ID}` + space + short description (~50 characters max)
-- Blank line after first line
-- Bullet points for changes (what changed and why)
-- Only important points, no verbose descriptions
-- No emojis
-- No AI attribution or Co-Authored-By lines
+Build: {status}
+Tests: {status}
 
-**Implementation:**
-When creating the commit, use HEREDOC format:
+{If any fixes failed, list them}
 
-```bash
-git add [relevant files]
-git commit -m "$(cat <<'EOF'
-PROJ-1234 Short description here
-
-- Change 1 and reason
-- Change 2 and reason
-EOF
-)"
+Updated: .5/{feature-name}/fix-plan.md
 ```
 
-## Instructions Summary
-
-1. **Load implementation plan** from `.5/{feature-name}/plan/`:
-   - Read meta.md for plan metadata
-   - Read verification.md for build/test config and targets
-   - Aggregate expected files from all step-N.md files
-2. **Spawn verification-agent** with aggregated expected files, modules, and test modules
-3. **Process agent results** - extract status, report, and structured data
-4. **Save verification report** to state directory
-5. **Update state file** with verification results
-6. **Inform developer** with clear status
-7. **Prompt for commit** (if PASSED or PASSED WITH WARNINGS) - Recommended before CodeRabbit review
-
-## Key Principles
-
-1. **Thin orchestrator** - Delegate verification work to agent, keep interactive parts in main context
-2. **Comprehensive** - Agent checks everything (files, problems, compilation, tests)
-3. **Categorized** - Separate errors (block) from warnings (report)
-4. **Actionable** - Clear report of what needs fixing
-5. **Persistent** - Save report for reference
-6. **Resumable** - Can be re-run after fixes
-7. **Commit ready** - Prompt for commit after successful verification
-
-## DO NOT
-
-- DO NOT run compilation or tests directly (agent handles this)
-- DO NOT run problem detection directly (agent handles this)
-- DO NOT block on warnings (only errors block)
-- DO NOT skip state file update
-- DO NOT skip saving verification report
-- DO NOT skip asking about commit if verification passed
-- DO NOT automatically create commits without user approval
-- DO NOT use emojis in commit messages
-- DO NOT include AI attribution or Co-Authored-By lines in commit messages
-
-## Error Handling
-
-If the verification-agent fails to return results:
-1. Record the failure in the state file
-2. Mark overall verification as FAILED
-3. Include diagnostic information in report
-4. Suggest re-running verification
-
-## Related Documentation
-
-- [Agent: verification-agent](../agents/verification-agent.md)
-- [/implement-feature command](implement-feature.md)
-- [/plan-implementation command](plan-implementation.md)
+**If user selects manual fix:** exit with guidance.
+```
+Fix plan saved: .5/{feature-name}/fix-plan.md
+
+When ready, re-run: /5:verify-implementation {feature-name}
+```
+
+### Step 11: Next Steps
+
+Tell user:
+```
+Next steps:
+1. Run `/clear` to reset context (recommended between phases)
+2. Run `/5:review-code`
+```

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

@@ -57,7 +57,7 @@ It handles three distinct tasks, invoked with different parameters per component
       "type": null
     }
   },
-  "reviewTool": "coderabbit" or "none"
+  "reviewTool": "claude" or "coderabbit" or "none"
 }
 ```