Prompt file imported from eai-support/eai (.github/prompts/6a_gofer_engineering_review.prompt.md). Fill in {{arguments}} before use. Copyright stays with the author.

Gofer Engineering Review

Name: 6a_gofer_engineering_review
Author: eai-support

You are performing a post-implementation engineering review that cross-checks the actual code against spec, research, tasks, and validation artifacts. This stage runs after #6_gofer_validate passes and performs 1-5 iterative "review → fix → re-review" cycles until all findings are resolved or 5 cycles complete.

User Input

{{arguments}}

You MUST consider the user input before proceeding (if not empty).

Prerequisites

This command expects in .specify/specs/{feature}/:

research.md - Codebase analysis (from #1_gofer_research)
spec.md - Feature specification (from #2_gofer_specify)
plan.md - Implementation plan (from #3_gofer_plan)
tasks.md - Task breakdown (from #4_gofer_tasks)
validation-report.md - Validation results (from #6_gofer_validate, PASS)
Implemented code (from #5_gofer_implement)

Outline

Load context and artifacts
Spawn 3 parallel review agents (per cycle)
Run build/test/lint verification
Synthesize findings
Fix Red and Yellow findings
Loop or complete (up to 5 cycles)
Generate engineering review report

Step 1: Load Context

Run setup script:

.specify/scripts/bash/check-prerequisites.sh --json --require-tasks

Parse JSON for FEATURE_DIR

Load all artifacts:
- spec.md (user stories, acceptance criteria)
- research.md (codebase patterns, technology context)
- plan.md (architecture, file structure, tech stack)
- tasks.md (task completion status, file paths)
- validation-report.md (validation results from stage 6)
Initialize cycle counter: CYCLE = 1
Initialize findings history: Empty array to accumulate across cycles

Step 2: Spawn 3 Parallel Review Agents (Cycle N of 5)

Launch all 3 agents in parallel using the Task tool. Each agent receives the feature context and returns structured findings.

Agent 1: Engineer Review (Spec↔Plan↔Tasks↔Research Alignment)

Task: subagent_type="engineer-review", model="sonnet"
Prompt: "Post-implementation engineering review for feature [FEATURE_NAME].

Feature directory: {FEATURE_DIR}
Spec: {FEATURE_DIR}/spec.md
Plan: {FEATURE_DIR}/plan.md
Tasks: {FEATURE_DIR}/tasks.md
Research: {FEATURE_DIR}/research.md

This is a POST-IMPLEMENTATION review (code is already written).
In addition to your standard spec↔plan↔tasks alignment checks:
1. Verify spec completeness against research.md — are all research findings addressed?
2. Check all acceptance criteria are addressed in the actual code (not just tasks)
3. Verify research.md patterns were followed in implementation

Return findings in your standard report format (<2000 tokens)."

Agent 2: Codebase Analyzer (Code↔Tasks Verification)

Task: subagent_type="codebase-analyzer", model="sonnet"
Prompt: "Post-implementation code verification for feature [FEATURE_NAME].

Feature directory: {FEATURE_DIR}
Tasks: {FEATURE_DIR}/tasks.md

Verify the following:
1. Every task marked [x] in tasks.md has corresponding code changes — check file paths
2. Search for TODO/FIXME/HACK comments in files listed in tasks.md
3. Check for dead code or unused imports in changed files
4. Verify any API contracts/interfaces match their actual implementations
5. Check for inconsistencies between task descriptions and what was implemented

Return findings with Red/Yellow/Gray severity (<2000 tokens).
Red = task marked complete but no code found, or API contract mismatch
Yellow = TODO/FIXME comments, unused imports, minor inconsistencies
Gray = style suggestions, optional improvements"

Agent 3: Correctness Re-verification

Task: subagent_type="validation-correctness", model="sonnet"
Prompt: "Post-implementation correctness re-verification for feature [FEATURE_NAME].

Feature directory: {FEATURE_DIR}
Spec: {FEATURE_DIR}/spec.md
Plan: {FEATURE_DIR}/plan.md

This is a focused re-check after validation passed. Look for issues that
rubric-based validation might miss:
1. Edge cases from spec that may not have explicit tests
2. Error handling completeness — are all failure modes covered?
3. Race conditions or concurrency issues in async code
4. Input validation at system boundaries
5. Any acceptance criteria that are technically 'covered' by tests but
   the implementation doesn't fully satisfy the spirit of the requirement

Return findings with Red/Yellow/Gray severity (<2000 tokens).
Red = acceptance criterion not genuinely satisfied, critical error path missing
Yellow = edge case not covered, partial error handling
Gray = potential improvement, defensive coding suggestion"

Run all 3 agents in parallel. Collect all results before proceeding.

Step 3: Run Build/Test/Lint Verification

Execute verification commands and capture results:

Build Check

cd extension && npm run compile

Test Check

cd extension && npm test

Lint Check

cd extension && npm run lint

Record results:

| Check  | Command              | Result      |
|--------|----------------------|-------------|
| Build  | npm run compile      | PASS / FAIL |
| Tests  | npm test             | PASS / FAIL |
| Lint   | npm run lint         | PASS / FAIL |

If any check FAILS: Record as a Red finding.

Step 4: Synthesize Findings

Collect all agent reports and build/test/lint results. Classify each finding:

Red (blocking): Task marked complete but no code, API contract mismatch, acceptance criterion not genuinely satisfied, build/test/lint failure, critical error path missing
Yellow (should fix): TODO/FIXME comments, unused imports, edge cases not covered, partial error handling, minor inconsistencies
Gray (informational): Style suggestions, optional improvements, defensive coding suggestions

Compile Finding Table

| # | Finding | Severity | Agent | File | Line | Status |
|---|---------|----------|-------|------|------|--------|
| 1 | [desc]  | Red      | [agent] | [file] | [line] | OPEN |
| 2 | [desc]  | Yellow   | [agent] | [file] | [line] | OPEN |

Decision Logic

If NO Red or Yellow findings → PASS → proceed to Step 7 (Report)
If Red or Yellow findings exist → proceed to Step 5 (Fix)

Step 5: Fix Findings

For each Red and Yellow finding from the current cycle:

Read the affected file at the specified line
Apply the fix directly using Edit tool
Mark the finding as FIXED in the finding table

Fix Priority

Red findings first (blocking issues)
Yellow findings second (should fix)
Gray findings are logged but NOT auto-fixed

After Fixing

Re-run build/test/lint to verify fixes don't introduce regressions:

cd extension && npm run compile && npm test && npm run lint

If the verification fails after fixes, record new failures as Red findings for the next cycle.

Step 6: Loop or Complete

Increment Cycle

CYCLE = CYCLE + 1

Decision

If CYCLE <= 5 AND findings were fixed in the previous cycle → Go to Step 2 (re-review with fresh agent runs to verify fixes and catch any new issues)
If CYCLE > 5 AND Red/Yellow findings still remain → Generate escalation section in the report, declare pipeline complete with warnings
If all findings resolved (no Red or Yellow) → Declare pipeline complete (proceed to Step 7)

Step 7: Generate Engineering Review Report

Write to {FEATURE_DIR}/engineering-review-report.md:

---
feature: [Feature Name]
reviewed: [ISO timestamp]
reviewer: Claude
status: [PASS/PASS_WITH_WARNINGS/ESCALATED]
cycles: [N]
total_findings: [N]
resolved_findings: [N]
---

# Engineering Review Report: [Feature Name]

## Summary

- **Status**: [PASS / PASS_WITH_WARNINGS / ESCALATED]
- **Review cycles**: [N] of 5 max
- **Total findings**: [N] (Red: [N], Yellow: [N], Gray: [N])
- **Resolved**: [N] findings fixed across [N] cycles
- **Remaining**: [N] findings (if any)

## Cycle History

### Cycle 1

**Agents**: engineer-review, codebase-analyzer, validation-correctness
**Build/Test/Lint**: [PASS/FAIL details]

| #   | Finding | Severity | Agent   | File   | Line   | Resolution   |
| --- | ------- | -------- | ------- | ------ | ------ | ------------ |
| 1   | [desc]  | [sev]    | [agent] | [file] | [line] | [FIXED/OPEN] |

### Cycle 2 (if applicable)

...

## Remaining Findings (if any)

| #   | Finding | Severity | Agent   | File   | Line   | Reason Not Fixed |
| --- | ------- | -------- | ------- | ------ | ------ | ---------------- |
| 1   | [desc]  | [sev]    | [agent] | [file] | [line] | [why]            |

## Recommendations

### Must Address Before Merge

- [Any remaining Red/Yellow findings]

### Future Improvements

- [Gray findings and suggestions]

Step 8: Output Completion Banner

If PASS (all findings resolved or no findings):

════════════════════════════════════════════════════════════════
  ENGINEERING REVIEW PASSED: [Feature Name]
════════════════════════════════════════════════════════════════

  Cycles: [N] of 5 max
  Findings: [N] found, [N] resolved
  Report: {FEATURE_DIR}/engineering-review-report.md

════════════════════════════════════════════════════════════════
  FEATURE PIPELINE COMPLETE!

  All Gofer stages finished:
  1. #1_gofer_research ✓
  2. #2_gofer_specify ✓
  3. #3_gofer_plan ✓
  4. #4_gofer_tasks ✓
  5. #5_gofer_implement ✓
  6. #6_gofer_validate ✓
  6a. #6a_gofer_engineering_review ✓

  The feature is ready for review and merge.
════════════════════════════════════════════════════════════════

If PASS_WITH_WARNINGS (5 cycles exhausted, only Gray remaining):

════════════════════════════════════════════════════════════════
  ENGINEERING REVIEW PASSED (WITH WARNINGS): [Feature Name]
════════════════════════════════════════════════════════════════

  Cycles: 5 of 5 max
  Findings: [N] found, [N] resolved, [N] Gray remaining
  Report: {FEATURE_DIR}/engineering-review-report.md

  ⚠ Gray findings remain — see report for details.

════════════════════════════════════════════════════════════════
  FEATURE PIPELINE COMPLETE!

  All Gofer stages finished:
  1. #1_gofer_research ✓
  2. #2_gofer_specify ✓
  3. #3_gofer_plan ✓
  4. #4_gofer_tasks ✓
  5. #5_gofer_implement ✓
  6. #6_gofer_validate ✓
  6a. #6a_gofer_engineering_review ✓ (warnings)

  The feature is ready for review and merge (review Gray findings).
════════════════════════════════════════════════════════════════

If ESCALATED (5 cycles exhausted, Red/Yellow remain):

════════════════════════════════════════════════════════════════
  ENGINEERING REVIEW ESCALATED: [Feature Name]
════════════════════════════════════════════════════════════════

  Cycles: 5 of 5 max (exhausted)
  Findings: [N] found, [N] resolved, [N] Red/Yellow remaining

  Remaining issues:
  ✗ [Finding] — [severity]: [brief reason]

  Report: {FEATURE_DIR}/engineering-review-report.md

  This feature requires human review of remaining findings
  before merging.

════════════════════════════════════════════════════════════════

Step 9: Observability Logging

Log stage completion:

.specify/scripts/bash/log-stage.sh 6a_engineering_review --complete --tokens [N] --compactions [N]

Key Rules

3 agents per cycle — spawn all in parallel, do not serialize
5 cycles maximum — hard cap to prevent infinite loops
Fix Red before Yellow — priority ordering matters
Re-verify after fixes — always re-run build/test/lint after changes
Gray findings are logged, not auto-fixed — they go in the report
Be specific — cite file paths and line numbers for all findings
This stage is the pipeline terminal — "PIPELINE COMPLETE" only appears here
Log stage completion for observability tracking

# Gofer Engineering Review You are performing a **post-implementation engineering review** that cross-checks the actual code against spec, research, tasks, and validation artifacts. This stage runs **after** `#6_gofer_validate` passes and performs 1-5 iterative "review → fix → re-review" cycles until all findings are resolved or 5 cycles complete. ## User Input ```text {{arguments}} ``` You **MUST** consider the user input before proceeding (if not empty). ## Prerequisites This command expects in `.specify/specs/{feature}/`: - `research.md` - Codebase analysis (from #1_gofer_research) - `spec.md` - Feature specification (from #2_gofer_specify) - `plan.md` - Implementation plan (from #3_gofer_plan) - `tasks.md` - Task breakdown (from #4_gofer_tasks) - `validation-report.md` - Validation results (from #6_gofer_validate, PASS) - Implemented code (from #5_gofer_implement) --- ## Outline 1. Load context and artifacts 2. Spawn 3 parallel review agents (per cycle) 3. Run build/test/lint verification 4. Synthesize findings 5. Fix Red and Yellow findings 6. Loop or complete (up to 5 cycles) 7. Generate engineering review report --- ## Step 1: Load Context 1. **Run setup script**: ```bash .specify/scripts/bash/check-prerequisites.sh --json --require-tasks ``` Parse JSON for FEATURE_DIR 2. **Load all artifacts**: - spec.md (user stories, acceptance criteria) - research.md (codebase patterns, technology context) - plan.md (architecture, file structure, tech stack) - tasks.md (task completion status, file paths) - validation-report.md (validation results from stage 6) 3. **Initialize cycle counter**: `CYCLE = 1` 4. **Initialize findings history**: Empty array to accumulate across cycles --- ## Step 2: Spawn 3 Parallel Review Agents (Cycle N of 5) Launch all 3 agents **in parallel** using the Task tool. Each agent receives the feature context and returns structured findings. ### Agent 1: Engineer Review (Spec↔Plan↔Tasks↔Research Alignment) ``` Task: subagent_type="engineer-review", model="sonnet" Prompt: "Post-implementation engineering review for feature [FEATURE_NAME]. Feature directory: {FEATURE_DIR} Spec: {FEATURE_DIR}/spec.md Plan: {FEATURE_DIR}/plan.md Tasks: {FEATURE_DIR}/tasks.md Research: {FEATURE_DIR}/research.md This is a POST-IMPLEMENTATION review (code is already written). In addition to your standard spec↔plan↔tasks alignment checks: 1. Verify spec completeness against research.md — are all research findings addressed? 2. Check all acceptance criteria are addressed in the actual code (not just tasks) 3. Verify research.md patterns were followed in implementation Return findings in your standard report format (<2000 tokens)." ``` ### Agent 2: Codebase Analyzer (Code↔Tasks Verification) ``` Task: subagent_type="codebase-analyzer", model="sonnet" Prompt: "Post-implementation code verification for feature [FEATURE_NAME]. Feature directory: {FEATURE_DIR} Tasks: {FEATURE_DIR}/tasks.md Verify the following: 1. Every task marked [x] in tasks.md has corresponding code changes — check file paths 2. Search for TODO/FIXME/HACK comments in files listed in tasks.md 3. Check for dead code or unused imports in changed files 4. Verify any API contracts/interfaces match their actual implementations 5. Check for inconsistencies between task descriptions and what was implemented Return findings with Red/Yellow/Gray severity (<2000 tokens). Red = task marked complete but no code found, or API contract mismatch Yellow = TODO/FIXME comments, unused imports, minor inconsistencies Gray = style suggestions, optional improvements" ``` ### Agent 3: Correctness Re-verification ``` Task: subagent_type="validation-correctness", model="sonnet" Prompt: "Post-implementation correctness re-verification for feature [FEATURE_NAME]. Feature directory: {FEATURE_DIR} Spec: {FEATURE_DIR}/spec.md Plan: {FEATURE_DIR}/plan.md This is a focused re-check after validation passed. Look for issues that rubric-based validation might miss: 1. Edge cases from spec that may not have explicit tests 2. Error handling completeness — are all failure modes covered? 3. Race conditions or concurrency issues in async code 4. Input validation at system boundaries 5. Any acceptance criteria that are technically 'covered' by tests but the implementation doesn't fully satisfy the spirit of the requirement Return findings with Red/Yellow/Gray severity (<2000 tokens). Red = acceptance criterion not genuinely satisfied, critical error path missing Yellow = edge case not covered, partial error handling Gray = potential improvement, defensive coding suggestion" ``` **Run all 3 agents in parallel.** Collect all results before proceeding. --- ## Step 3: Run Build/Test/Lint Verification Execute verification commands and capture results: ### Build Check ```bash cd extension && npm run compile ``` ### Test Check ```bash cd extension && npm test ``` ### Lint Check ```bash cd extension && npm run lint ``` Record results: ``` | Check | Command | Result | |--------|----------------------|-------------| | Build | npm run compile | PASS / FAIL | | Tests | npm test | PASS / FAIL | | Lint | npm run lint | PASS / FAIL | ``` **If any check FAILS**: Record as a Red finding. --- ## Step 4: Synthesize Findings Collect all agent reports and build/test/lint results. Classify each finding: - **Red** (blocking): Task marked complete but no code, API contract mismatch, acceptance criterion not genuinely satisfied, build/test/lint failure, critical error path missing - **Yellow** (should fix): TODO/FIXME comments, unused imports, edge cases not covered, partial error handling, minor inconsistencies - **Gray** (informational): Style suggestions, optional improvements, defensive coding suggestions ### Compile Finding Table ``` | # | Finding | Severity | Agent | File | Line | Status | |---|---------|----------|-------|------|------|--------| | 1 | [desc] | Red | [agent] | [file] | [line] | OPEN | | 2 | [desc] | Yellow | [agent] | [file] | [line] | OPEN | ``` ### Decision Logic - If **NO Red or Yellow findings** → PASS → proceed to Step 7 (Report) - If **Red or Yellow findings exist** → proceed to Step 5 (Fix) --- ## Step 5: Fix Findings For each Red and Yellow finding from the current cycle: 1. **Read the affected file** at the specified line 2. **Apply the fix** directly using Edit tool 3. **Mark the finding as FIXED** in the finding table ### Fix Priority 1. Red findings first (blocking issues) 2. Yellow findings second (should fix) 3. Gray findings are logged but NOT auto-fixed ### After Fixing Re-run build/test/lint to verify fixes don't introduce regressions: ```bash cd extension && npm run compile && npm test && npm run lint ``` If the verification fails after fixes, record new failures as Red findings for the next cycle. --- ## Step 6: Loop or Complete ### Increment Cycle ``` CYCLE = CYCLE + 1 ``` ### Decision - If `CYCLE <= 5` AND findings were fixed in the previous cycle → **Go to Step 2** (re-review with fresh agent runs to verify fixes and catch any new issues) - If `CYCLE > 5` AND Red/Yellow findings still remain → **Generate escalation section** in the report, declare pipeline complete with warnings - If **all findings resolved** (no Red or Yellow) → **Declare pipeline complete** (proceed to Step 7) --- ## Step 7: Generate Engineering Review Report Write to `{FEATURE_DIR}/engineering-review-report.md`: ```markdown --- feature: [Feature Name] reviewed: [ISO timestamp] reviewer: Claude status: [PASS/PASS_WITH_WARNINGS/ESCALATED] cycles: [N] total_findings: [N] resolved_findings: [N] --- # Engineering Review Report: [Feature Name] ## Summary - **Status**: [PASS / PASS_WITH_WARNINGS / ESCALATED] - **Review cycles**: [N] of 5 max - **Total findings**: [N] (Red: [N], Yellow: [N], Gray: [N]) - **Resolved**: [N] findings fixed across [N] cycles - **Remaining**: [N] findings (if any) ## Cycle History ### Cycle 1 **Agents**: engineer-review, codebase-analyzer, validation-correctness **Build/Test/Lint**: [PASS/FAIL details] | # | Finding | Severity | Agent | File | Line | Resolution | | --- | ------- | -------- | ------- | ------ | ------ | ------------ | | 1 | [desc] | [sev] | [agent] | [file] | [line] | [FIXED/OPEN] | ### Cycle 2 (if applicable) ... ## Remaining Findings (if any) | # | Finding | Severity | Agent | File | Line | Reason Not Fixed | | --- | ------- | -------- | ------- | ------ | ------ | ---------------- | | 1 | [desc] | [sev] | [agent] | [file] | [line] | [why] | ## Recommendations ### Must Address Before Merge - [Any remaining Red/Yellow findings] ### Future Improvements - [Gray findings and suggestions] ``` --- ## Step 8: Output Completion Banner ### If PASS (all findings resolved or no findings): ``` ════════════════════════════════════════════════════════════════ ENGINEERING REVIEW PASSED: [Feature Name] ════════════════════════════════════════════════════════════════ Cycles: [N] of 5 max Findings: [N] found, [N] resolved Report: {FEATURE_DIR}/engineering-review-report.md ════════════════════════════════════════════════════════════════ FEATURE PIPELINE COMPLETE! All Gofer stages finished: 1. #1_gofer_research ✓ 2. #2_gofer_specify ✓ 3. #3_gofer_plan ✓ 4. #4_gofer_tasks ✓ 5. #5_gofer_implement ✓ 6. #6_gofer_validate ✓ 6a. #6a_gofer_engineering_review ✓ The feature is ready for review and merge. ════════════════════════════════════════════════════════════════ ``` ### If PASS_WITH_WARNINGS (5 cycles exhausted, only Gray remaining): ``` ════════════════════════════════════════════════════════════════ ENGINEERING REVIEW PASSED (WITH WARNINGS): [Feature Name] ════════════════════════════════════════════════════════════════ Cycles: 5 of 5 max Findings: [N] found, [N] resolved, [N] Gray remaining Report: {FEATURE_DIR}/engineering-review-report.md ⚠ Gray findings remain — see report for details. ════════════════════════════════════════════════════════════════ FEATURE PIPELINE COMPLETE! All Gofer stages finished: 1. #1_gofer_research ✓ 2. #2_gofer_specify ✓ 3. #3_gofer_plan ✓ 4. #4_gofer_tasks ✓ 5. #5_gofer_implement ✓ 6. #6_gofer_validate ✓ 6a. #6a_gofer_engineering_review ✓ (warnings) The feature is ready for review and merge (review Gray findings). ════════════════════════════════════════════════════════════════ ``` ### If ESCALATED (5 cycles exhausted, Red/Yellow remain): ``` ════════════════════════════════════════════════════════════════ ENGINEERING REVIEW ESCALATED: [Feature Name] ════════════════════════════════════════════════════════════════ Cycles: 5 of 5 max (exhausted) Findings: [N] found, [N] resolved, [N] Red/Yellow remaining Remaining issues: ✗ [Finding] — [severity]: [brief reason] Report: {FEATURE_DIR}/engineering-review-report.md This feature requires human review of remaining findings before merging. ════════════════════════════════════════════════════════════════ ``` --- ## Step 9: Observability Logging Log stage completion: ```bash .specify/scripts/bash/log-stage.sh 6a_engineering_review --complete --tokens [N] --compactions [N] ``` --- ## Key Rules - **3 agents per cycle** — spawn all in parallel, do not serialize - **5 cycles maximum** — hard cap to prevent infinite loops - **Fix Red before Yellow** — priority ordering matters - **Re-verify after fixes** — always re-run build/test/lint after changes - **Gray findings are logged, not auto-fixed** — they go in the report - **Be specific** — cite file paths and line numbers for all findings - **This stage is the pipeline terminal** — "PIPELINE COMPLETE" only appears here - Log stage completion for observability tracking

{ "prompt": "# Gofer Engineering Review\n\nYou are performing a **post-implementation engineering review** that\ncross-checks the actual code against spec, research, tasks, and validation\nartifacts. This stage runs **after** `#6_gofer_validate` passes and performs 1-5\niterative \"review → fix → re-review\" cycles until all findings are resolved or 5\ncycles complete.\n\n## User Input\n\n```text\n{{arguments}}\n```\n\nYou **MUST** consider the user input before proceeding (if not empty).\n\n## Prerequisites\n\nThis command expects in `.specify/specs/{feature}/`:\n\n- `research.md` - Codebase analysis (from #1_gofer_research)\n- `spec.md` - Feature specification (from #2_gofer_specify)\n- `plan.md` - Implementation plan (from #3_gofer_plan)\n- `tasks.md` - Task breakdown (from #4_gofer_tasks)\n- `validation-report.md` - Validation results (from #6_gofer_validate, PASS)\n- Implemented code (from #5_gofer_implement)\n\n---\n\n## Outline\n\n1. Load context and artifacts\n2. Spawn 3 parallel review agents (per cycle)\n3. Run build/test/lint verification\n4. Synthesize findings\n5. Fix Red and Yellow findings\n6. Loop or complete (up to 5 cycles)\n7. Generate engineering review report\n\n---\n\n## Step 1: Load Context\n\n1. **Run setup script**:\n\n ```bash\n .specify/scripts/bash/check-prerequisites.sh --json --require-tasks\n ```\n\n Parse JSON for FEATURE_DIR\n\n2. **Load all artifacts**:\n - spec.md (user stories, acceptance criteria)\n - research.md (codebase patterns, technology context)\n - plan.md (architecture, file structure, tech stack)\n - tasks.md (task completion status, file paths)\n - validation-report.md (validation results from stage 6)\n\n3. **Initialize cycle counter**: `CYCLE = 1`\n\n4. **Initialize findings history**: Empty array to accumulate across cycles\n\n---\n\n## Step 2: Spawn 3 Parallel Review Agents (Cycle N of 5)\n\nLaunch all 3 agents **in parallel** using the Task tool. Each agent receives the\nfeature context and returns structured findings.\n\n### Agent 1: Engineer Review (Spec↔Plan↔Tasks↔Research Alignment)\n\n```\nTask: subagent_type=\"engineer-review\", model=\"sonnet\"\nPrompt: \"Post-implementation engineering review for feature [FEATURE_NAME].\n\nFeature directory: {FEATURE_DIR}\nSpec: {FEATURE_DIR}/spec.md\nPlan: {FEATURE_DIR}/plan.md\nTasks: {FEATURE_DIR}/tasks.md\nResearch: {FEATURE_DIR}/research.md\n\nThis is a POST-IMPLEMENTATION review (code is already written).\nIn addition to your standard spec↔plan↔tasks alignment checks:\n1. Verify spec completeness against research.md — are all research findings addressed?\n2. Check all acceptance criteria are addressed in the actual code (not just tasks)\n3. Verify research.md patterns were followed in implementation\n\nReturn findings in your standard report format (<2000 tokens).\"\n```\n\n### Agent 2: Codebase Analyzer (Code↔Tasks Verification)\n\n```\nTask: subagent_type=\"codebase-analyzer\", model=\"sonnet\"\nPrompt: \"Post-implementation code verification for feature [FEATURE_NAME].\n\nFeature directory: {FEATURE_DIR}\nTasks: {FEATURE_DIR}/tasks.md\n\nVerify the following:\n1. Every task marked [x] in tasks.md has corresponding code changes — check file paths\n2. Search for TODO/FIXME/HACK comments in files listed in tasks.md\n3. Check for dead code or unused imports in changed files\n4. Verify any API contracts/interfaces match their actual implementations\n5. Check for inconsistencies between task descriptions and what was implemented\n\nReturn findings with Red/Yellow/Gray severity (<2000 tokens).\nRed = task marked complete but no code found, or API contract mismatch\nYellow = TODO/FIXME comments, unused imports, minor inconsistencies\nGray = style suggestions, optional improvements\"\n```\n\n### Agent 3: Correctness Re-verification\n\n```\nTask: subagent_type=\"validation-correctness\", model=\"sonnet\"\nPrompt: \"Post-implementation correctness re-verification for feature [FEATURE_NAME].\n\nFeature directory: {FEATURE_DIR}\nSpec: {FEATURE_DIR}/spec.md\nPlan: {FEATURE_DIR}/plan.md\n\nThis is a focused re-check after validation passed. Look for issues that\nrubric-based validation might miss:\n1. Edge cases from spec that may not have explicit tests\n2. Error handling completeness — are all failure modes covered?\n3. Race conditions or concurrency issues in async code\n4. Input validation at system boundaries\n5. Any acceptance criteria that are technically 'covered' by tests but\n the implementation doesn't fully satisfy the spirit of the requirement\n\nReturn findings with Red/Yellow/Gray severity (<2000 tokens).\nRed = acceptance criterion not genuinely satisfied, critical error path missing\nYellow = edge case not covered, partial error handling\nGray = potential improvement, defensive coding suggestion\"\n```\n\n**Run all 3 agents in parallel.** Collect all results before proceeding.\n\n---\n\n## Step 3: Run Build/Test/Lint Verification\n\nExecute verification commands and capture results:\n\n### Build Check\n\n```bash\ncd extension && npm run compile\n```\n\n### Test Check\n\n```bash\ncd extension && npm test\n```\n\n### Lint Check\n\n```bash\ncd extension && npm run lint\n```\n\nRecord results:\n\n```\n| Check | Command | Result |\n|--------|----------------------|-------------|\n| Build | npm run compile | PASS / FAIL |\n| Tests | npm test | PASS / FAIL |\n| Lint | npm run lint | PASS / FAIL |\n```\n\n**If any check FAILS**: Record as a Red finding.\n\n---\n\n## Step 4: Synthesize Findings\n\nCollect all agent reports and build/test/lint results. Classify each finding:\n\n- **Red** (blocking): Task marked complete but no code, API contract mismatch,\n acceptance criterion not genuinely satisfied, build/test/lint failure,\n critical error path missing\n- **Yellow** (should fix): TODO/FIXME comments, unused imports, edge cases not\n covered, partial error handling, minor inconsistencies\n- **Gray** (informational): Style suggestions, optional improvements, defensive\n coding suggestions\n\n### Compile Finding Table\n\n```\n| # | Finding | Severity | Agent | File | Line | Status |\n|---|---------|----------|-------|------|------|--------|\n| 1 | [desc] | Red | [agent] | [file] | [line] | OPEN |\n| 2 | [desc] | Yellow | [agent] | [file] | [line] | OPEN |\n```\n\n### Decision Logic\n\n- If **NO Red or Yellow findings** → PASS → proceed to Step 7 (Report)\n- If **Red or Yellow findings exist** → proceed to Step 5 (Fix)\n\n---\n\n## Step 5: Fix Findings\n\nFor each Red and Yellow finding from the current cycle:\n\n1. **Read the affected file** at the specified line\n2. **Apply the fix** directly using Edit tool\n3. **Mark the finding as FIXED** in the finding table\n\n### Fix Priority\n\n1. Red findings first (blocking issues)\n2. Yellow findings second (should fix)\n3. Gray findings are logged but NOT auto-fixed\n\n### After Fixing\n\nRe-run build/test/lint to verify fixes don't introduce regressions:\n\n```bash\ncd extension && npm run compile && npm test && npm run lint\n```\n\nIf the verification fails after fixes, record new failures as Red findings for\nthe next cycle.\n\n---\n\n## Step 6: Loop or Complete\n\n### Increment Cycle\n\n```\nCYCLE = CYCLE + 1\n```\n\n### Decision\n\n- If `CYCLE <= 5` AND findings were fixed in the previous cycle → **Go to Step\n 2** (re-review with fresh agent runs to verify fixes and catch any new issues)\n- If `CYCLE > 5` AND Red/Yellow findings still remain → **Generate escalation\n section** in the report, declare pipeline complete with warnings\n- If **all findings resolved** (no Red or Yellow) → **Declare pipeline\n complete** (proceed to Step 7)\n\n---\n\n## Step 7: Generate Engineering Review Report\n\nWrite to `{FEATURE_DIR}/engineering-review-report.md`:\n\n```markdown\n---\nfeature: [Feature Name]\nreviewed: [ISO timestamp]\nreviewer: Claude\nstatus: [PASS/PASS_WITH_WARNINGS/ESCALATED]\ncycles: [N]\ntotal_findings: [N]\nresolved_findings: [N]\n---\n\n# Engineering Review Report: [Feature Name]\n\n## Summary\n\n- **Status**: [PASS / PASS_WITH_WARNINGS / ESCALATED]\n- **Review cycles**: [N] of 5 max\n- **Total findings**: [N] (Red: [N], Yellow: [N], Gray: [N])\n- **Resolved**: [N] findings fixed across [N] cycles\n- **Remaining**: [N] findings (if any)\n\n## Cycle History\n\n### Cycle 1\n\n**Agents**: engineer-review, codebase-analyzer, validation-correctness\n**Build/Test/Lint**: [PASS/FAIL details]\n\n| # | Finding | Severity | Agent | File | Line | Resolution |\n| --- | ------- | -------- | ------- | ------ | ------ | ------------ |\n| 1 | [desc] | [sev] | [agent] | [file] | [line] | [FIXED/OPEN] |\n\n### Cycle 2 (if applicable)\n\n...\n\n## Remaining Findings (if any)\n\n| # | Finding | Severity | Agent | File | Line | Reason Not Fixed |\n| --- | ------- | -------- | ------- | ------ | ------ | ---------------- |\n| 1 | [desc] | [sev] | [agent] | [file] | [line] | [why] |\n\n## Recommendations\n\n### Must Address Before Merge\n\n- [Any remaining Red/Yellow findings]\n\n### Future Improvements\n\n- [Gray findings and suggestions]\n```\n\n---\n\n## Step 8: Output Completion Banner\n\n### If PASS (all findings resolved or no findings):\n\n```\n════════════════════════════════════════════════════════════════\n ENGINEERING REVIEW PASSED: [Feature Name]\n════════════════════════════════════════════════════════════════\n\n Cycles: [N] of 5 max\n Findings: [N] found, [N] resolved\n Report: {FEATURE_DIR}/engineering-review-report.md\n\n════════════════════════════════════════════════════════════════\n FEATURE PIPELINE COMPLETE!\n\n All Gofer stages finished:\n 1. #1_gofer_research ✓\n 2. #2_gofer_specify ✓\n 3. #3_gofer_plan ✓\n 4. #4_gofer_tasks ✓\n 5. #5_gofer_implement ✓\n 6. #6_gofer_validate ✓\n 6a. #6a_gofer_engineering_review ✓\n\n The feature is ready for review and merge.\n════════════════════════════════════════════════════════════════\n```\n\n### If PASS_WITH_WARNINGS (5 cycles exhausted, only Gray remaining):\n\n```\n════════════════════════════════════════════════════════════════\n ENGINEERING REVIEW PASSED (WITH WARNINGS): [Feature Name]\n════════════════════════════════════════════════════════════════\n\n Cycles: 5 of 5 max\n Findings: [N] found, [N] resolved, [N] Gray remaining\n Report: {FEATURE_DIR}/engineering-review-report.md\n\n ⚠ Gray findings remain — see report for details.\n\n════════════════════════════════════════════════════════════════\n FEATURE PIPELINE COMPLETE!\n\n All Gofer stages finished:\n 1. #1_gofer_research ✓\n 2. #2_gofer_specify ✓\n 3. #3_gofer_plan ✓\n 4. #4_gofer_tasks ✓\n 5. #5_gofer_implement ✓\n 6. #6_gofer_validate ✓\n 6a. #6a_gofer_engineering_review ✓ (warnings)\n\n The feature is ready for review and merge (review Gray findings).\n════════════════════════════════════════════════════════════════\n```\n\n### If ESCALATED (5 cycles exhausted, Red/Yellow remain):\n\n```\n════════════════════════════════════════════════════════════════\n ENGINEERING REVIEW ESCALATED: [Feature Name]\n════════════════════════════════════════════════════════════════\n\n Cycles: 5 of 5 max (exhausted)\n Findings: [N] found, [N] resolved, [N] Red/Yellow remaining\n\n Remaining issues:\n ✗ [Finding] — [severity]: [brief reason]\n\n Report: {FEATURE_DIR}/engineering-review-report.md\n\n This feature requires human review of remaining findings\n before merging.\n\n════════════════════════════════════════════════════════════════\n```\n\n---\n\n## Step 9: Observability Logging\n\nLog stage completion:\n\n```bash\n.specify/scripts/bash/log-stage.sh 6a_engineering_review --complete --tokens [N] --compactions [N]\n```\n\n---\n\n## Key Rules\n\n- **3 agents per cycle** — spawn all in parallel, do not serialize\n- **5 cycles maximum** — hard cap to prevent infinite loops\n- **Fix Red before Yellow** — priority ordering matters\n- **Re-verify after fixes** — always re-run build/test/lint after changes\n- **Gray findings are logged, not auto-fixed** — they go in the report\n- **Be specific** — cite file paths and line numbers for all findings\n- **This stage is the pipeline terminal** — \"PIPELINE COMPLETE\" only appears\n here\n- Log stage completion for observability tracking", "variables": [ "arguments" ], "notes": "Post-implementation engineering review with iterative fix cycles (up to 5) Tools: Read, Grep, Glob, Bash, WebSearch. Arguments: feature-name-or-description.", "metadata": { "source": { "provider": "github-prompts", "repository": "https://github.com/eai-support/eai", "path": ".github/prompts/6a_gofer_engineering_review.prompt.md", "ref": "10619126104d95997b9218c73894c301e66980c3", "url": "https://github.com/eai-support/eai/blob/10619126104d95997b9218c73894c301e66980c3/.github/prompts/6a_gofer_engineering_review.prompt.md", "key": "eai-support/eai/.github/prompts/6a_gofer_engineering_review.prompt.md" } } }

6a_gofer_engineering_review

About