corvus-phase-4

1. Identify all tasks in the current phase
2. Note which tasks have requires_ux_dx_review: true (for Phase 5)
3. Prepare the phase validation scope

Metadata Extraction Format:

PHASE METADATA EXTRACTION - Phase [N]
─────────────────────────────────────
Tasks in Phase: [NN, NN, NN, NN]
Total Tasks: [count]

UX/DX Review Flags:
- Task NN: requires_ux_dx_review = [true/false]
- Task NN: requires_ux_dx_review = [true/false]

Phase 5 UX/DX Required: [YES if ANY task is true / NO if all false]
─────────────────────────────────────

4b. Objective Quality Gate - ENTIRE PHASE (MANDATORY)

When `tests_enabled: true` AND `tests_deferred: false`:
- Tests: PASS (for all affected code)
- Acceptance criteria: ALL tasks in phase PASS

When `tests_enabled: true` AND `tests_deferred: true` (deferred mode):
- Acceptance criteria: ALL tasks in phase PASS (verified via file inspection, code review, command output)
- Tests are NOT run during Phase 4 — deferred to Phase 5 final validation
- This is functionally identical to acceptance-only mode for Phase 4 purposes

When `tests_enabled: false` (acceptance-only mode):
- Acceptance criteria: ALL tasks in phase PASS (verified via file inspection, code review, command output)
- Tests are NOT run and NOT required

NOTE: code-implementer already validated lint, type check, and build.
code-quality focuses on TESTS and acceptance criteria verification
(or acceptance criteria only when tests_enabled: false OR tests_deferred: true).

If ANY check returns FAIL:
1. FIRST: Invoke task-planner LEARNING MODE (FAILURE_ANALYSIS)
2. THEN: Invoke code-implementer with fix instructions (ONLY failing tasks)
3. THEN: Loop back to 4b (full phase revalidation)
4. Repeat until PASS (max 3 iterations per phase)
5. If still failing after 3 iterations, escalate to user

NEVER skip this gate. NEVER proceed with FAIL status.
NEVER fix without first analyzing the failure.
NEVER fix passing tasks - only fix failing tasks.

Template Selection for 4b:

• If tests_enabled: true AND tests_deferred: false (default): Use the standard delegation template below
• If tests_enabled: true AND tests_deferred: true (deferred mode): Use the "Acceptance-Only Mode" delegation template (tests deferred to Phase 5)
• If tests_enabled: false: Use the "Acceptance-Only Mode" delegation template

DELEGATE TO: @code-quality

4b Delegation: Standard Mode (when tests_enabled: true)

**TASK**: Validate Phase [N] implementation

**PHASE TASKS**: 
- Task NN: [name] - `.corvus/tasks/[feature]/NN-task.md`
- Task NN: [name] - `.corvus/tasks/[feature]/NN-task.md`
- Task NN: [name] - `.corvus/tasks/[feature]/NN-task.md`

**SCOPE**: All files created/modified in 4a for this phase

**PRIMARY JOB**: RUN TESTS

Code-implementer already validated:
- ✅ Lint passed
- ✅ Type check passed  
- ✅ Build succeeded

Your job is to run the TESTS that code-implementer did not run.

**CHECKS REQUIRED**:
1. Run test suite (targeting tests for this phase's code)
2. Verify acceptance criteria from ALL task files (with evidence)
3. Check for regressions (if existing tests exist)

**MUST DO**:
- Identify test files for the scope
- Run tests with appropriate test runner
- Report actual test output (not just "PASS")
- Verify each acceptance criterion with evidence (test name or observation)
- Attribute any failures to specific task(s)

**MUST NOT DO**:
- Re-run lint (code-implementer did this)
- Re-run type check (code-implementer did this)
- Re-run build (unless tests require it)
- Just read files and check boxes without running tests
- Report failures without task attribution

**IF NO TESTS EXIST**:
- Report "NO TESTS FOUND" as a gap
- Verify acceptance criteria through other automated means
- Mark criteria requiring manual verification as "MANUAL (deferred to 5b)"

**REPORT FORMAT**:

PHASE GATE STATUS: PASS / FAIL

Test Results (PRIMARY)

Command: {actual test command run} Output: {actual output} Tests: [N] run, [N] passed, [N] failed

Acceptance Criteria

Task Attribution

Fix Scope (if FAIL)

Only tasks [NN] require fixes. Tasks [NN] should NOT be modified.

4b Delegation: Acceptance-Only Mode (when tests_enabled: false OR tests_deferred: true)

**TASK**: Validate Phase [N] implementation (acceptance-only mode)

**PHASE TASKS**: 
- Task NN: [name] - `.corvus/tasks/[feature]/NN-task.md`
- Task NN: [name] - `.corvus/tasks/[feature]/NN-task.md`

**SCOPE**: All files created/modified in 4a for this phase

**MODE**: ACCEPTANCE-ONLY (`tests_enabled: false` OR `tests_deferred: true`)

**PRIMARY JOB**: VERIFY ACCEPTANCE CRITERIA

Code-implementer already validated:
- ✅ Lint passed
- ✅ Type check passed  
- ✅ Build succeeded

Your job is to verify acceptance criteria from task files WITHOUT running tests.

**CHECKS REQUIRED**:
1. Verify acceptance criteria from ALL task files (with evidence)
2. Evidence must be concrete: file inspection, code review, or command output
3. Check for regressions via code review (if existing code was modified)

**MUST DO**:
- Read all task files for the phase
- For each acceptance criterion, provide concrete evidence
- Attribute any failures to specific task(s)
- Report PASS/FAIL with evidence type for each criterion

**MUST NOT DO**:
- Attempt to run tests
- Report "NO TESTS FOUND" as a gap
- Recommend test creation
- Just read files and check boxes without evidence
- Report failures without task attribution

**REPORT FORMAT**:

PHASE GATE STATUS: PASS / FAIL MODE: ACCEPTANCE-ONLY

Acceptance Criteria Verification (PRIMARY)

Task Attribution

Fix Scope (if FAIL)

Only tasks [NN] require fixes. Tasks [NN] should NOT be modified.

GATE DECISION:

• If PHASE GATE STATUS = PASS → Proceed to 4c (update master plan)
• If PHASE GATE STATUS = FAIL → Invoke failure learning, then fix failing tasks, then loop to 4b

On FAIL: Learning-First Fix Cycle

When the phase quality gate returns FAIL, follow this exact sequence:

Step F1: Failure Analysis (MANDATORY before fixing)

DELEGATE TO: @task-planner

MODE: LEARNING (FAILURE_ANALYSIS)

**TASK**: Analyze phase quality gate failure

**MODE**: LEARNING

**TRIGGER**: FAILURE_ANALYSIS

**FAILED GATE**: 4b (phase-level)

**PHASE**: [phase number]

**FAILURE DETAILS**:
- Failing task(s): [list with task IDs]
- What failed: [specific test/build/criteria per task]
- Error messages: [exact errors]
- Files involved: [list per task]

**QUESTIONS TO ANSWER**:
1. What is the root cause of each failure?
2. Are the task definitions correct, or do they need updating?
3. Was there missing context that caused the failure?
4. What should the fix approach be for each failing task?

**MUST DO**:
- Analyze the failure root cause per failing task
- Determine if task files need updating
- Update task files if definitions were wrong
- Provide clear fix instructions for code-implementer
- Scope fixes to ONLY failing tasks

**REPORT BACK**:
- Root cause analysis per failing task
- Task file updates made (if any)
- Recommended fix approach per task
- Specific fix instructions for code-implementer
- Confirmation that passing tasks should NOT be modified

Step F2: Fix Implementation (ONLY Failing Tasks)

DELEGATE TO: @code-implementer

**TASK**: Fix implementation based on failure analysis

**FAILING TASKS ONLY**:
- Task NN: [fix instructions]
- Task NN: [fix instructions]

**DO NOT MODIFY**: Tasks [NN, NN, NN] - these passed validation

**FAILURE ANALYSIS**:
[Include root cause and recommended fix approach from F1]

**SPECIFIC FIXES REQUIRED**:
[Exact changes needed per failing task based on F1 analysis]

**MUST DO**:
- Follow the fix approach from failure analysis
- Address the root cause, not just symptoms
- Ensure fix aligns with updated task definition (if changed)
- ONLY modify files related to failing tasks

**MUST NOT DO**:
- Modify files for passing tasks
- Make unrelated changes
- Skip validation

**REPORT BACK**:
- Changes made per failing task
- How root cause was addressed
- Ready for re-validation

Step F3: Loop Back to 4b

After fix, ALWAYS loop back to 4b (code-quality) for full phase revalidation. This ensures fixes don't break other tasks in the phase.

ITERATION TRACKING:

• Track iterations through the loop per phase
• Max 3 iterations per phase
• If still failing after 3 iterations, escalate to user

4c. Update Master Plan

After the phase quality gate passes, update the master plan directly (no subagent needed).

Actions (Corvus does this directly):

1. Mark ALL phase tasks as complete: [ ] → [x]
2. Update progress count at bottom of document
3. Update phase status: [ ] → [x]
4. Check for next phase (respecting phase order)
5. If more phases remain, loop back to 4a with next phase (reset fix_iterations = 0)
6. If all phases complete, proceed to Phase 5 (Final Validation)

Why no subagent?: SUCCESS_EXTRACTION adds overhead without immediate value. Learnings are extracted once at Phase 6 for the entire feature instead.

Exit Criteria: All phases complete, proceed to Phase 5.