all-for-claudecode 2.0.0 → 2.2.0

package/commands/auto.md

@@ -6,8 +6,10 @@ argument-hint: "[feature description in natural language]"
 
 # /afc:auto — Full Auto Pipeline
 
-> Runs spec → plan → tasks → implement → review → clean fully automatically from a single feature description.
-> No intermediate confirmation. clarify/analyze are skipped. Critic Loop is performed automatically at each phase.
+> Runs clarify? → spec → plan → implement → review → clean fully automatically from a single feature description.
+> Tasks are generated automatically at implement start (no separate tasks phase).
+> Critic Loop runs at each phase with unified safety cap (5). Convergence terminates early when quality is sufficient.
+> Pre-implementation gates (clarify, TDD pre-gen, blast-radius) run conditionally within the implement phase.
 
 ## Arguments
 
@@ -20,15 +22,16 @@ argument-hint: "[feature description in natural language]"
 ## Config Load
 
 **Always** read `.claude/afc.config.md` first (read manually if not auto-loaded above). Values defined in this file are referenced below as `{config.*}`:
-- `{config.ci}` — full CI command
-- `{config.gate}` — phase gate command
-- `{config.architecture}` — architecture style and rules
-- `{config.framework}` — framework characteristics (server/client boundary etc.)
-- `{config.code_style}` — code style rules
-- `{config.risks}` — project-specific risk patterns
-- `{config.mini_review}` — Mini-Review checklist items
+- `{config.ci}` — full CI command (from `## CI Commands` YAML)
+- `{config.gate}` — phase gate command (from `## CI Commands` YAML)
+- `{config.test}` — test command (from `## CI Commands` YAML)
+- `{config.architecture}` — architecture style and rules (from `## Architecture` section)
+- `{config.code_style}` — code style rules (from `## Code Style` section)
 
-If config file is missing: print "`.claude/afc.config.md` not found. Create project config with `/afc:init`." then **abort**.
+If config file is missing:
+1. Ask the user: "`.claude/afc.config.md` not found. Run `/afc:init` to set up the project?"
+2. If user accepts → run `/afc:init`, then **restart this command** with the original `$ARGUMENTS`
+3. If user declines → **abort**
 
 ---
 
@@ -64,32 +67,122 @@ If config file is missing: print "`.claude/afc.config.md` not found. Create proj
 6. Start notification:
    ```
    Auto pipeline started: {feature}
-   ├─ 1/6 Spec → 2/6 Plan → 3/6 Tasks → 4/6 Implement → 5/6 Review → 6/6 Clean
-   └─ Running fully automatically (no intermediate confirmation)
+   ├─ Clarify? → 1/5 Spec → 2/5 Plan → 3/5 Implement → 4/5 Review → 5/5 Clean
+   └─ Running fully automatically (tasks auto-generated, pre-implementation gates conditional)
    ```
 
-### Phase 1: Spec (1/6)
+### Phase 0.3: Request Triage
+
+Before investing pipeline resources, evaluate whether the request warrants execution:
+
+1. **Necessity check**: Explore codebase for existing implementations related to `$ARGUMENTS`.
+   - If the feature substantially exists → ask user via AskUserQuestion:
+     - "This feature appears to already exist at {path}. (1) Enhance existing (2) Replace entirely (3) Abort"
+   - If user chooses abort → release pipeline flag (`"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" end`), end with: `"Pipeline aborted — feature already exists."`
+
+2. **Scope check**: Estimate the scope of `$ARGUMENTS`:
+   - If description implies 10+ files or multiple unrelated concerns → warn:
+     - "This request spans multiple concerns: {list}. Recommended: split into {N} separate pipeline runs."
+   - Ask: "(1) Proceed as single pipeline (2) Reduce scope to {suggestion} (3) Abort"
+
+3. **Proportionality check**: If the request is trivially small (single file, single-line change, config edit):
+   - Suggest: "This change is small enough to implement directly. Skip full pipeline?"
+   - If user agrees → execute fast-path directly, skip spec/plan/tasks
+
+If all checks pass, proceed to Phase 0.8.
+
+### Phase 0.8: Size-Based Fast-Path Detection (conditional)
+
+**Trigger condition**: Evaluate `$ARGUMENTS` against ALL 3 criteria. Fast-path activates only when ALL are met:
+
+| Criterion | Check | Example |
+|-----------|-------|---------|
+| Trivial scope | Description explicitly mentions 1-2 specific files or a single-line fix | "fix typo in README", "update version in package.json" |
+| No script impact | Description does not reference `.sh` scripts, hooks, or pipeline logic | NOT: "fix the hook script" |
+| Low ambiguity | Clarify gate score < 2 (very clear, specific request) | "change 'foo' to 'bar' in config.md" |
+
+**If ALL 3 criteria met** (fast-path):
+1. Print: `⚡ Fast path detected — skipping spec/plan phases`
+2. Jump directly to **Fast-Path Execution** (see below)
+3. Skip Phases 0.5 through 3.3 entirely
+
+**If ANY criterion fails**: proceed to Phase 0.5 (full pipeline).
+
+**Fast-Path Execution** (implement → review → clean):
+1. Implement the change directly (no tasks.md, no plan.md)
+2. Run `{config.ci}` verification
+   - On fail: **abort fast-path**, restart with full pipeline: `⚠ Fast-path aborted — change is more complex than expected. Running full pipeline.`
+3. If change touches > 2 files OR modifies any `.sh` script: **abort fast-path**, restart with full pipeline
+4. **Checkpoint**:
+   ```bash
+   "${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase fast-path
+   "${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" ci-pass
+   ```
+5. Run `/afc:review` logic inline (mini-review only — single Critic pass)
+6. Run Phase 5 Clean logic (artifact cleanup, CI gate, pipeline flag release)
+7. Final output:
+   ```
+   Fast path complete: {feature}
+   ├─ Mode: ⚡ Fast path (spec/plan skipped)
+   ├─ Changed files: {N}
+   ├─ CI: ✓
+   └─ Review: mini-review passed
+   ```
+
+### Phase 0.5: Auto-Clarify Gate (conditional)
+
+`"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase clarify`
+
+**Trigger condition**: Score `$ARGUMENTS` on 5 ambiguity signals. If score >= 3, trigger clarification.
+
+| Signal | Detection | Example |
+|--------|-----------|---------|
+| Vague scope | No specific file, component, or module mentioned | "add caching" |
+| Missing quantifiers | No numbers, sizes, limits, or thresholds | "improve performance" |
+| Undefined entities | References to concepts not in the codebase | "integrate the new service" |
+| Unclear boundaries | No start/end conditions or scope limits | "refactor the system" |
+| Multiple interpretations | Ambiguous verbs or overloaded terms | "fix the pipeline" (which one?) |
+
+**If score >= 3** (ambiguous):
+1. Generate at most 3 clarification questions targeting the highest-signal areas
+2. Present via AskUserQuestion with multiple-choice options
+3. Apply answers to refine `$ARGUMENTS` before proceeding to Spec
+4. If in full-auto mode and user prefers no interruption: auto-resolve with best-guess, tag with `[AUTO-RESOLVED: clarify]`, emit warning
+5. Progress: `✓ Clarify gate triggered ({N} questions, {M} auto-resolved)`
+
+**If score < 3** (clear): skip silently, proceed to Phase 1.
+
+### Phase 1: Spec (1/5)
 
 `"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase spec`
 
 Execute `/afc:spec` logic inline:
 
 1. Explore codebase for related code (Glob, Grep) — explore by `{config.architecture}` layer
-2. Create `.claude/afc/specs/{feature}/spec.md`
-3. `[NEEDS CLARIFICATION]` items are **auto-resolved with best-guess** (clarify skipped)
-   - Tag auto-resolved items with `[AUTO-RESOLVED]`
-4. **Retrospective check**: if `.claude/afc/memory/retrospectives/` exists, load and check:
+2. **Research Gate** (conditional):
+   - Scan `$ARGUMENTS` for external library/API/technology references not present in the codebase
+   - If external references found: run focused WebSearch for each (latest stable version, key constraints, compatibility)
+   - Optionally use Context7 for library-specific documentation
+   - Use research findings to inform spec writing (accurate requirements instead of guesses)
+   - Tag researched items with `[RESEARCHED]` in spec
+   - If no external references: skip (all internal → no research needed)
+3. Create `.claude/afc/specs/{feature}/spec.md`
+4. `[NEEDS CLARIFICATION]` items: **research first, then auto-resolve remaining** (clarify skipped if Phase 0.5 already ran)
+   - Items answerable via research → resolve with researched facts, tag `[RESEARCHED]`
+   - Items requiring user judgment → auto-resolve with best-guess, tag `[AUTO-RESOLVED]`
+5. **Retrospective check**: if `.claude/afc/memory/retrospectives/` exists, load and check:
    - Were there previous `[AUTO-RESOLVED]` items that turned out wrong? Flag similar patterns.
    - Were there scope-related issues in past specs? Warn about similar ambiguities.
-5. **Critic Loop until convergence** (safety cap: 5, follow Critic Loop rules):
+6. **Critic Loop until convergence** (safety cap: 5, follow Critic Loop rules):
    - COMPLETENESS: does every User Story have acceptance scenarios? Any missing requirements?
    - MEASURABILITY: are success criteria measurable, not subjective? **Is quantitative evidence provided for numerical targets?**
    - INDEPENDENCE: are implementation details (code, library names) absent from the spec?
    - EDGE_CASES: are at least 2 identified? Any missing boundary conditions?
    - FAIL → auto-fix and continue. ESCALATE → pause, present options, resume after response. DEFER → record reason, mark clean.
-6. Progress: `✓ 1/6 Spec complete (US: {N}, FR: {N}, Critic: converged ({N} passes, {M} fixes, {E} escalations))`
+7. **Checkpoint**: phase transition already recorded by `afc-pipeline-manage.sh phase spec` at phase start
+8. Progress: `✓ 1/5 Spec complete (US: {N}, FR: {N}, researched: {N}, Critic: converged ({N} passes, {M} fixes, {E} escalations))`
 
-### Phase 2: Plan (2/6)
+### Phase 2: Plan (2/5)
 
 `"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase plan`
 
@@ -97,109 +190,242 @@ Execute `/afc:plan` logic inline:
 
 1. Load spec.md
 2. If technical uncertainties exist → auto-resolve via WebSearch/code exploration → create research.md
-3. Create `.claude/afc/specs/{feature}/plan.md`
+3. **Memory loading** (skip gracefully if directories are empty or absent):
+   - **Quality history**: if `.claude/afc/memory/quality-history/*.json` exists, load recent entries and display trend summary: "Last {N} pipelines: avg critic_fixes {X}, avg ci_failures {Y}, avg escalations {Z}". Use trends to inform plan risk assessment.
+   - **Decisions**: if `.claude/afc/memory/decisions/` exists, load ADR entries and check for conflicts with the current feature's design direction. Flag any contradictions.
+   - **Reviews**: if `.claude/afc/memory/reviews/` exists, scan for recurring finding patterns (same file/category appearing in 2+ reviews). Flag as known risk areas.
+4. Create `.claude/afc/specs/{feature}/plan.md`
    - **If setting numerical targets (line counts etc.), include structure-analysis-based estimates** (e.g., "function A ~50 lines, component B ~80 lines → total ~130 lines")
-4. **Critic Loop until convergence** (safety cap: 7, follow Critic Loop rules):
-   - Criteria: COMPLETENESS, FEASIBILITY, ARCHITECTURE, RISK, PRINCIPLES
+5. **Critic Loop until convergence** (safety cap: 5, follow Critic Loop rules):
+   - Criteria: COMPLETENESS, FEASIBILITY, ARCHITECTURE, **CROSS_CONSISTENCY**, RISK, PRINCIPLES
+   - **CROSS_CONSISTENCY criterion** (spec↔plan cross-validation, check all 5):
+     1. Entity coverage: every spec Key Entity → File Change Map row. `{M}/{N} entities covered`
+     2. NFR traceability: every NFR-* → Architecture Decision or Risk mitigation. `{M}/{N} NFRs traced`
+     3. Terminology consistency: same concept = same name across spec and plan
+     4. Constraint propagation: every spec Constraint → Risk & Mitigation or Implementation Context Must NOT. `{M}/{N} constraints propagated`
+     5. Acceptance anchor alignment: Implementation Context Acceptance Anchors faithfully reflect spec acceptance scenarios
    - **RISK criterion mandatory checks**:
      - Enumerate **at least 3** `{config.ci}` failure scenarios and describe mitigation
-     - Check each pattern in `{config.risks}` one by one
-     - Consider `{config.framework}` characteristics (server/client boundary etc.)
+     - Check each risk pattern described in config's Project Context section one by one
+     - Consider framework characteristics from config's Project Context (server/client boundary etc.)
    - **ARCHITECTURE criterion**: explicitly describe import paths for moved/created files and pre-validate against `{config.architecture}` rules
    - Each pass must **explicitly explore what was missed in the previous pass** ("Pass 2: {X} was missed in pass 1. Further review: ...")
    - FAIL → auto-fix and continue. ESCALATE → pause, present options, resume after response. DEFER → record reason, mark clean.
-5. Progress: `✓ 2/6 Plan complete (Critic: converged ({N} passes, {M} fixes, {E} escalations), files: {N})`
+6. **Research persistence**: If research.md was created in step 2, persist a copy to long-term memory:
+   - Copy research findings to `.claude/afc/memory/research/{feature}.md`
+   - This enables future pipelines to reference prior research decisions
+7. **ADR recording via architect agent**: After plan.md is written, invoke the architect agent to record architectural decisions:
+   ```
+   Task("ADR: Record architecture decisions for {feature}", subagent_type: "afc:afc-architect",
+     prompt: "Review the following plan and record key architecture decisions to your persistent memory.
+
+     ## Plan Summary
+     {paste Architecture Decision + File Change Map sections from plan.md}
+
+     ## Instructions
+     1. Read your MEMORY.md for prior ADR history
+     2. Check for conflicts between new decisions and existing ADRs
+     3. If conflicts found: return CONFLICT with details (orchestrator will ESCALATE)
+     4. If no conflicts: record new ADRs to your MEMORY.md
+     5. Return: { decisions_recorded: N, conflicts: [] }")
+   ```
+   - If architect returns conflicts → **ESCALATE** to user with conflict details
+   - If no conflicts → proceed (ADR recorded for future reference)
+8. **Session context preservation**: Save key decisions and constraints for context compaction resilience:
+   ```
+   save_session_context({
+     goal: { original_request: "$ARGUMENTS", current_objective: "Implement {feature}" },
+     decisions: [{ what: "{key design decision}", why: "{rationale}" }],
+     discoveries: [{ file: "{path}", insight: "{finding}" }]
+   })
+   ```
+9. **Checkpoint**: phase transition already recorded by `afc-pipeline-manage.sh phase plan` at phase start
+10. Progress: `✓ 2/5 Plan complete (Critic: converged ({N} passes, {M} fixes, {E} escalations), files: {N}, ADR: {N} recorded, Implementation Context: {W} words)`
 
-### Phase 3: Tasks (3/6)
+### Phase 3: Implement (3/5)
 
-`"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase tasks`
+`"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase implement`
 
-Execute `/afc:tasks` logic inline:
+**Session context reload**: At implement start, call `load_session_context()` to restore key decisions and constraints from Plan phase (resilient to context compaction).
 
-1. Load plan.md
-2. Decompose tasks by phase (T001, T002, ...)
-3. **[P] marker and dependency rules**:
-   - Assign `[P]` marker to independent tasks with no overlapping file paths
-   - Use explicit `depends: [TXXX]` for cross-task dependencies (replaces informal `(after TXXX)`)
-   - Validate dependency graph is a DAG (no circular references)
-   - [P] tasks **must be executed in parallel** in Phase 4 (declaring [P] then running sequentially is prohibited)
-4. Coverage mapping (FR → Task)
-5. **Retrospective check**: if `.claude/afc/memory/retrospectives/` exists, load and check:
-   - Were there previous parallel conflict issues ([P] file overlaps)? Flag similar file patterns.
-   - Were there tasks that were over-decomposed or under-decomposed? Adjust granularity.
-6. **Critic Loop until convergence** (safety cap: 5, follow Critic Loop rules):
-   - COVERAGE: is every FR/NFR mapped to at least 1 task?
-   - DEPENDENCIES: is the dependency graph a valid DAG? Do [P] tasks have no file overlaps?
-   - FAIL → auto-fix and continue. ESCALATE → pause, present options, resume after response. DEFER → record reason, mark clean.
-7. Create `.claude/afc/specs/{feature}/tasks.md`
-8. Progress: `✓ 3/6 Tasks complete (tasks: {N}, parallel: {N}, Critic: converged ({N} passes, {M} fixes, {E} escalations))`
+Execute `/afc:implement` logic inline — **follow all orchestration rules defined in `commands/implement.md`** (task generation, mode selection, batch/swarm execution, failure recovery, task execution pattern). The implement command is the single source of truth for orchestration details.
 
-### Phase 4: Implement (4/6)
+**Auto-specific additions** (beyond implement.md):
 
-`"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase implement`
+#### Step 3.1: Task Generation + Validation
 
-Execute `/afc:implement` logic inline with **dependency-aware orchestration**:
+1. Generate tasks.md from plan.md File Change Map (as defined in implement.md Step 1.3)
+2. **Retrospective check**: if `.claude/afc/memory/retrospectives/` exists, load and check:
+   - Were there previous parallel conflict issues ([P] file overlaps)? Flag similar file patterns.
+   - Were there tasks that were over-decomposed or under-decomposed? Adjust granularity.
+3. Script validation (DAG + parallel overlap) — no critic loop, script-based only
+4. Progress: `  ├─ Tasks generated: {N} ({P} parallelizable)`
 
-1. Parse tasks.md — extract task IDs, [P] markers, `depends:` lists, file paths
-2. Build dependency graph per phase (validate DAG)
-3. **Orchestration mode selection** (per phase, automatic):
+#### Step 3.2: TDD Pre-Generation (conditional)
 
-   | [P] tasks in phase | Mode | Strategy |
-   |---------------------|------|----------|
-   | 0 | Sequential | Execute tasks one by one |
-   | 1–5 | Parallel Batch | Register tasks → set dependencies → launch Task() calls |
-   | 6+ | Swarm | Task pool + self-organizing worker agents (max 5 workers) |
+`"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase test-pre-gen`
 
-4. **Parallel Batch mode** (1–5 [P] tasks):
+**Trigger condition**: tasks.md contains at least 1 task targeting a `.sh` file in `scripts/`.
+
+**If triggered**:
+1. Run the test pre-generation script:
+   ```bash
+   "${CLAUDE_PLUGIN_ROOT}/scripts/afc-test-pre-gen.sh" ".claude/afc/specs/{feature}/tasks.md" "spec/"
    ```
-   TaskCreate({ subject: "T012: Move AudioFadeControl", ... })
-   TaskCreate({ subject: "T013: Move AudioVolumeControl", ... })
-   TaskUpdate({ taskId: "T013", addBlockedBy: ["T011"] })  // if dependency exists
-   → launch unblocked tasks as parallel Task() calls in a single message
-   → read results → launch newly-unblocked → repeat until phase complete
+2. Review generated skeleton files — verify they are parseable:
+   ```bash
+   {config.test}  # should show Pending examples, not errors
    ```
+3. Create `.claude/afc/specs/{feature}/tests-pre.md` listing generated test expectations per task
+4. Progress: `  ├─ TDD pre-gen: {N} skeletons generated`
 
-5. **Swarm mode** (6+ [P] tasks):
-   ```
-   // 1. Register all phase tasks via TaskCreate
-   // 2. Set up dependencies via TaskUpdate(addBlockedBy)
-   // 3. Spawn N worker agents (N = min(5, unblocked count))
-   Task("Swarm Worker 1", subagent_type: "general-purpose",
-     prompt: "Self-organizing worker: TaskList → claim → implement → complete → repeat until empty")
-   Task("Swarm Worker 2", ...)
-   // 4. Workers self-balance — fast workers claim more tasks
-   // 5. Read all worker results before proceeding to gate
+**If not triggered** (no `.sh` tasks): skip silently.
+
+**Note**: Generated tests contain `Pending` examples — implementation agents replace these with real assertions during implementation.
+
+#### Step 3.3: Blast Radius Analysis (conditional)
+
+`"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase blast-radius`
+
+**Trigger condition**: plan.md File Change Map lists >= 3 files to change.
+
+**If triggered**:
+1. Run the blast radius analysis:
+   ```bash
+   "${CLAUDE_PLUGIN_ROOT}/scripts/afc-blast-radius.sh" ".claude/afc/specs/{feature}/plan.md" "${CLAUDE_PROJECT_DIR}"
    ```
+2. If exit 1 (cycle detected): **ESCALATE** — present the cycle to user with options:
+   - Option 1: Refactor plan to break the cycle
+   - Option 2: Acknowledge the cycle and proceed (mark as [DEFERRED])
+3. If high fan-out files detected (>5 dependents): emit warning, add as RISK note in plan.md
+4. Save output to `.claude/afc/specs/{feature}/impact.md`
+5. Progress: `  ├─ Blast radius: {N} planned, {M} dependents`
 
-6. Perform **3-step gate** on each Implementation Phase completion — **always** read `${CLAUDE_PLUGIN_ROOT}/docs/phase-gate-protocol.md` first. Cannot advance to next phase without passing the gate.
+**If not triggered** (< 3 files): skip silently (small changes have bounded blast radius).
+
+#### Step 3.4: Execution
+
+1. Execute tasks phase by phase using implement.md orchestration rules (sequential/batch/swarm based on [P] count)
+2. **Implementation Context injection**: Every sub-agent prompt includes the `## Implementation Context` section from plan.md (ensures spec intent propagates to workers)
+3. Perform **3-step gate** on each Implementation Phase completion — **always** read `${CLAUDE_PLUGIN_ROOT}/docs/phase-gate-protocol.md` first. Cannot advance to next phase without passing the gate.
    - On gate pass: create phase rollback point `"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase-tag {phase_number}`
-7. Real-time `[x]` updates in tasks.md
-8. After full completion, run `{config.ci}` final verification
+4. Real-time `[x]` updates in tasks.md
+5. After full completion, run `{config.ci}` final verification
    - On pass: `"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" ci-pass` (releases Stop Gate)
-9. **Implement retrospective**: if unexpected problems arose that weren't predicted in Plan, record in `.claude/afc/specs/{feature}/retrospective.md` (for memory update in Clean)
-10. Progress: `✓ 4/6 Implement complete ({completed}/{total} tasks, CI: ✓, Mini-Review: ✓, Checkpoint: ✓)`
+   - **On fail: Debug-based RCA** (replaces blind retry):
+     1. Execute `/afc:debug` logic inline with the CI error output as input
+     2. Debug performs RCA: error trace → data flow → hypothesis → targeted fix
+     3. Re-run `{config.ci}` after fix
+     4. If debug-fix cycle fails 3 times → **abort** (not a simple fix — requires user intervention)
+     5. This replaces the previous "retry max 3 attempts" pattern with intelligent diagnosis
+
+#### Step 3.5: Acceptance Test Generation (conditional)
+
+**Trigger condition**: spec.md contains acceptance scenarios (Given/When/Then blocks) AND `{config.test}` is configured (non-empty).
+
+**If triggered**:
+1. Extract all GWT (Given/When/Then) acceptance scenarios from spec.md
+2. Execute `/afc:test` logic inline — generate test cases from acceptance scenarios:
+   ```
+   For each acceptance scenario in spec.md:
+   - Map GWT to a test case: Given → Arrange, When → Act, Then → Assert
+   - Target file: determined by the component/module referenced in the scenario
+   - Test file location: follows project convention (test framework from Project Context)
+   ```
+3. Run `{config.test}` to verify tests pass against the implementation
+   - If tests fail → this reveals a gap between spec and implementation:
+     - Fixable implementation issue → apply targeted fix
+     - Spec-implementation mismatch → record as SC shortfall for Review phase
+4. Progress: `  ├─ Acceptance tests: {N} generated, {M} passing`
+
+**If not triggered** (no GWT scenarios or no test framework configured): skip silently.
 
-### Phase 5: Review (5/6)
+#### Step 3.6: Implement Critic Loop
+
+> **Always** read `${CLAUDE_PLUGIN_ROOT}/docs/critic-loop-rules.md` first and follow it.
+
+**Critic Loop until convergence** (safety cap: 5, follow Critic Loop rules):
+- **SCOPE_ADHERENCE**: Compare `git diff` changed files against plan.md File Change Map. Flag any file modified that is NOT in the plan. Flag any planned file NOT modified. Provide "M of N files match" count.
+- **ARCHITECTURE**: Validate changed files against `{config.architecture}` rules (layer boundaries, naming conventions, import paths). Provide "N of M rules checked" count.
+- **CORRECTNESS**: Cross-check implemented changes against spec.md acceptance criteria (AC). Verify each AC has corresponding code. Provide "N of M AC verified" count.
+- **Adversarial 3-perspective** (mandatory each pass):
+  - Skeptic: "Which implementation assumption is most likely wrong?"
+  - Devil's Advocate: "How could this implementation be misused or fail unexpectedly?"
+  - Edge-case Hunter: "What input would cause this implementation to fail silently?"
+  - State one failure scenario per perspective. If realistic → FAIL + fix. If unrealistic → state quantitative rationale.
+- FAIL → auto-fix, re-run `{config.ci}`, and continue. ESCALATE → pause, present options, resume after response. DEFER → record reason, mark clean.
+
+6. **Implement retrospective**: if unexpected problems arose that weren't predicted in Plan, record in `.claude/afc/specs/{feature}/retrospective.md` (for memory update in Clean)
+7. **Checkpoint**: phase transition already recorded by `afc-pipeline-manage.sh phase implement` at phase start
+8. Progress: `✓ 3/5 Implement complete ({completed}/{total} tasks, CI: ✓, Critic: converged ({N} passes, {M} fixes, {E} escalations))`
+
+### Phase 4: Review (4/5)
 
 `"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase review`
 
-Execute `/afc:review` logic inline:
+Execute `/afc:review` logic inline — **follow all review perspectives defined in `commands/review.md`** (A through H). The review command is the single source of truth for review criteria.
 
 1. Review implemented changed files (`git diff HEAD`)
-2. Check code quality, `{config.architecture}` rules, security, performance, `{config.code_style}` pattern compliance
-3. **Retrospective check**: if `.claude/afc/memory/retrospectives/` exists, load and check:
+2. **Specialist agent delegation** (parallel, perspectives B and C):
+   Launch architect and security agents in a **single message** to leverage their persistent memory:
+   ```
+   Task("Architecture Review: {feature}", subagent_type: "afc:afc-architect",
+     prompt: "Review the following changed files for architecture compliance.
+
+     ## Changed Files
+     {list of changed files from git diff}
+
+     ## Architecture Rules
+     {config.architecture}
+
+     ## Instructions
+     1. Read your MEMORY.md for prior architecture patterns and ADRs
+     2. Check each file against architecture rules (layer boundaries, naming, placement)
+     3. Cross-reference with ADRs recorded during Plan phase — any violations?
+     4. Return findings as: severity (Critical/Warning/Info), file:line, issue, suggested fix
+     5. Update your MEMORY.md with any new architecture patterns discovered")
+
+   Task("Security Review: {feature}", subagent_type: "afc:afc-security",
+     prompt: "Scan the following changed files for security vulnerabilities.
+
+     ## Changed Files
+     {list of changed files from git diff}
+
+     ## Instructions
+     1. Read your MEMORY.md for known vulnerability patterns and false positives
+     2. Check for: command injection, path traversal, unvalidated input, sensitive data exposure
+     3. Skip patterns recorded as false positives in your memory
+     4. Return findings as: severity (Critical/Warning/Info), file:line, issue, suggested fix
+     5. Update your MEMORY.md with new patterns or confirmed false positives")
+   ```
+   - Collect agent outputs and merge into the consolidated review
+   - Agent findings inherit their severity classification directly
+3. Check across **8 perspectives** (A-H as defined in review.md):
+   - A. Code Quality — `{config.code_style}` compliance (direct review)
+   - B. Architecture — **delegated to afc-architect agent** (persistent memory, ADR-aware)
+   - C. Security — **delegated to afc-security agent** (persistent memory, false-positive-aware)
+   - D. Performance — framework-specific patterns from Project Context (direct review)
+   - E. Project Pattern Compliance — conventions and idioms (direct review)
+   - **F. Reusability** — DRY, shared utilities, abstraction level (direct review)
+   - **G. Maintainability** — AI/human comprehension, naming clarity, self-contained files (direct review)
+   - **H. Extensibility** — extension points, OCP, future modification cost (direct review)
+4. **Auto-resolved validation**: Check all `[AUTO-RESOLVED]` items from spec phase — does the implementation match the guess? Flag mismatches as Critical.
+5. **Past reviews check**: if `.claude/afc/memory/reviews/` exists, scan for recurring finding patterns across past review reports. Prioritize those areas.
+6. **Retrospective check**: if `.claude/afc/memory/retrospectives/` exists, load and check:
    - Were there recurring Critical finding categories in past reviews? Prioritize those perspectives.
    - Were there false positives that wasted effort? Reduce sensitivity for those patterns.
-4. **Critic Loop until convergence** (safety cap: 5, follow Critic Loop rules):
-   - COMPLETENESS: cross-check every SC (success criterion) from spec.md one by one. Provide specific metrics if falling short.
+6. **Critic Loop until convergence** (safety cap: 5, follow Critic Loop rules):
+   - COMPLETENESS: were all changed files reviewed across all 8 perspectives (A-H)?
+   - SPEC_ALIGNMENT: cross-check implementation against spec.md — (1) every SC verified with `{M}/{N}` count, (2) every acceptance scenario (GWT) has corresponding code path, (3) no spec constraint is violated
    - PRECISION: are there unnecessary changes? Are there out-of-scope modifications?
    - FAIL → auto-fix and continue. ESCALATE → pause, present options, resume after response. DEFER → record reason, mark clean.
-5. **Handling SC shortfalls**:
+7. **Handling SC shortfalls**:
    - Fixable → attempt auto-fix → re-run `{config.ci}` verification
    - Not fixable → state in final report with reason (no post-hoc rationalization; record as Plan-phase target-setting error)
-6. Progress: `✓ 5/6 Review complete (Critical:{N} Warning:{N} Info:{N}, SC shortfalls: {N})`
+8. **Checkpoint**: phase transition already recorded by `afc-pipeline-manage.sh phase review` at phase start
+9. Progress: `✓ 4/5 Review complete (Critical:{N} Warning:{N} Info:{N}, SC shortfalls: {N})`
 
-### Phase 6: Clean (6/6)
+### Phase 5: Clean (5/5)
 
 `"${CLAUDE_PLUGIN_ROOT}/scripts/afc-pipeline-manage.sh" phase clean`
 
@@ -221,6 +447,8 @@ Artifact cleanup and codebase hygiene check after implementation and review:
    - If there were `[AUTO-RESOLVED]` items → record decisions in `.claude/afc/memory/decisions/`
    - **If retrospective.md exists** → record as patterns missed by the Plan phase Critic Loop in `.claude/afc/memory/retrospectives/` (reuse as RISK checklist items in future runs)
    - **If review-report.md exists** → copy to `.claude/afc/memory/reviews/{feature}-{date}.md` before .claude/afc/specs/ deletion
+   - **If research.md exists** and was not already persisted in Plan phase → copy to `.claude/afc/memory/research/{feature}.md`
+   - **Agent memory consolidation**: architect and security agents have already updated their persistent MEMORY.md during Review phase — no additional action needed (agent memory survives across sessions independently)
 5. **Quality report** (structured pipeline metrics):
    - Generate `.claude/afc/memory/quality-history/{feature}-{date}.json` with the following structure:
      ```json
@@ -228,11 +456,22 @@ Artifact cleanup and codebase hygiene check after implementation and review:
        "feature": "{feature}",
        "date": "{YYYY-MM-DD}",
        "phases": {
-         "spec": { "user_stories": N, "requirements": { "FR": N, "NFR": N }, "auto_resolved": N, "critic_passes": N, "critic_fixes": N, "escalations": N },
-         "plan": { "files_planned": N, "critic_passes": N, "critic_fixes": N, "escalations": N },
-         "tasks": { "total": N, "parallel": N, "phases": N, "critic_passes": N, "critic_fixes": N, "escalations": N },
-         "implement": { "completed": N, "total": N, "ci_passes": N, "ci_failures": N },
-         "review": { "critical": N, "warning": N, "info": N, "sc_shortfalls": N, "critic_passes": N, "critic_fixes": N, "escalations": N }
+         "clarify": { "triggered": true/false, "questions": N, "auto_resolved": N },
+         "spec": { "user_stories": N, "requirements": { "FR": N, "NFR": N }, "researched": N, "auto_resolved": N, "critic_passes": N, "critic_fixes": N, "escalations": N },
+         "plan": { "files_planned": N, "implementation_context_words": N, "adr_recorded": N, "adr_conflicts": N, "research_persisted": true/false, "critic_passes": N, "critic_fixes": N, "escalations": N },
+         "implement": {
+           "tasks": { "total": N, "parallel": N, "phases": N },
+           "test_pre_gen": { "triggered": true/false, "skeletons": N },
+           "blast_radius": { "triggered": true/false, "dependents": N, "high_fan_out": N },
+           "completed": N, "total": N, "ci_passes": N, "ci_failures": N,
+           "acceptance_tests": { "triggered": true/false, "generated": N, "passing": N },
+           "debug_rca": { "triggered": true/false, "cycles": N },
+           "critic_passes": N, "critic_fixes": N, "escalations": N
+         },
+         "review": { "critical": N, "warning": N, "info": N, "sc_shortfalls": N, "auto_resolved_mismatches": N,
+           "architect_agent": { "invoked": true/false, "findings": N },
+           "security_agent": { "invoked": true/false, "findings": N },
+           "critic_passes": N, "critic_fixes": N, "escalations": N }
        },
        "totals": { "changed_files": N, "auto_resolved": N, "escalations": N }
      }
@@ -252,20 +491,26 @@ Artifact cleanup and codebase hygiene check after implementation and review:
    - Change tracking log deleted
    - Safety tag removed (successful completion)
    - Phase rollback tags removed (handled automatically by pipeline end)
-9. Progress: `✓ 6/6 Clean complete (deleted: {N}, dead code: {N}, CI: ✓)`
+9. **Checkpoint**: phase transition already recorded by `afc-pipeline-manage.sh phase clean` at phase start
+10. Progress: `✓ 5/5 Clean complete (deleted: {N}, dead code: {N}, CI: ✓)`
 
 ### Final Output
 
 ```
 Auto pipeline complete: {feature}
-├─ Spec: US {N}, FR {N}
-├─ Plan: Critic converged ({N} passes, {M} fixes, {E} escalations), research {present/absent}
-├─ Tasks: {total} (parallel {N})
-├─ Implement: {completed}/{total} tasks, CI ✓, Checkpoint ✓
-├─ Review: Critical:{N} Warning:{N} Info:{N}, SC shortfalls: {N}
-├─ Clean: {N} artifacts deleted, {N} dead code removed
+├─ 1/5 Spec: US {N}, FR {N}, researched {N}
+├─ 2/5 Plan: Critic converged ({N} passes), ADR {N} recorded, Implementation Context {W} words
+├─ 3/5 Implement: {completed}/{total} tasks ({P} parallel), CI ✓
+│   ├─ TDD: {triggered/skipped}, Blast Radius: {triggered/skipped}
+│   ├─ Acceptance Tests: {N} generated ({M} passing) / skipped
+│   └─ Critic: converged ({N} passes, {M} fixes, {E} escalations)
+├─ 4/5 Review: Critical:{N} Warning:{N} Info:{N}
+│   ├─ Perspectives: Quality, Architecture*, Security*, Performance, Patterns, Reusability, Maintainability, Extensibility
+│   └─ (* = delegated to persistent-memory agent)
+├─ 5/5 Clean: {N} artifacts deleted, {N} dead code removed
 ├─ Changed files: {N}
-├─ Auto-resolved: {N} (review recommended)
+├─ Auto-resolved: {N} ({M} validated in review)
+├─ Agent memory: architect {updated/skipped}, security {updated/skipped}
 ├─ Retrospective: {present/absent}
 └─ .claude/afc/specs/{feature}/ cleaned up
 ```
@@ -280,7 +525,7 @@ Auto pipeline complete: {feature}
 
 On abort:
 ```
-Pipeline aborted (Phase {N}/6)
+Pipeline aborted (Phase {N}/5)
 ├─ Reason: {abort cause}
 ├─ Completed phases: {completed list}
 ├─ Rollback: git reset --hard afc/pre-auto (restores state before implementation)
@@ -291,6 +536,7 @@ Pipeline aborted (Phase {N}/6)
 
 ## Notes
 
+- **Full auto does not mean uncritical**: Phase 0.3 Request Triage may reject, reduce, or redirect requests before the pipeline invests resources. "Auto" automates execution, not judgment.
 - **Full auto**: runs to completion without intermediate confirmation. Fast but direction cannot be changed mid-run.
 - **Review auto-resolved items**: items tagged `[AUTO-RESOLVED]` are estimates; review after the fact is recommended.
 - **Large feature warning**: warn before starting if more than 5 User Stories are expected.
@@ -298,7 +544,14 @@ Pipeline aborted (Phase {N}/6)
 - **Follow project rules**: project rules in `afc.config.md` and `CLAUDE.md` take priority.
 - **Critic Loop is not a ritual**: a single "PASS" line is equivalent to not running Critic at all. Always follow the format in the Critic Loop rules section. Critic uses convergence-based termination — it may finish in 1 pass or take several, depending on the output quality.
 - **ESCALATE pauses auto mode**: when a Critic finds an ambiguous issue requiring user judgment, the pipeline pauses and presents options via AskUserQuestion. Auto mode automates clear decisions but escalates ambiguous ones.
+- **Tasks phase is absorbed**: tasks.md is generated automatically at implement start from plan.md's File Change Map. No separate tasks phase or tasks critic loop. Validation is script-based (DAG + parallel overlap checks).
 - **[P] parallel is mandatory**: if a [P] marker is assigned in tasks.md, it must be executed in parallel. Orchestration mode (batch vs swarm) is selected automatically based on task count. Sequential substitution is prohibited.
-- **Swarm mode is automatic**: when a phase has 6+ [P] tasks, swarm workers self-organize via TaskList/TaskUpdate. Do not manually batch.
+- **Swarm mode is automatic**: when a phase has 6+ [P] tasks, the orchestrator pre-assigns tasks to swarm workers. Do not manually batch.
+- **Implementation Context travels with workers**: every sub-agent prompt includes the Implementation Context section from plan.md, ensuring spec intent propagates to parallel workers.
+- **Session context resilience**: key decisions are saved via `save_session_context` at Plan completion and restored at Implement start, surviving context compaction.
+- **Specialist agents enhance review**: afc-architect and afc-security agents are invoked during Review to provide persistent-memory-aware analysis. Their findings are merged into the consolidated review. Agent memory updates happen automatically during the agent call.
+- **Debug-based RCA replaces blind retry**: CI failures trigger `/afc:debug` logic (hypothesis → targeted fix) instead of generic "retry 3 times". This produces better fixes and records patterns via retrospective.
+- **Acceptance tests close the spec-to-code gap**: When spec contains GWT scenarios and a test framework is configured, acceptance tests are auto-generated after implementation, verifying spec intent is met.
+- **Research and ADR persist across sessions**: Research findings are saved to `.claude/afc/memory/research/`, ADRs to architect agent memory. Future pipelines can reference these to avoid re-research and detect conflicts.
 - **No out-of-scope deletion**: do not delete files/directories in Clean that were not created by the current pipeline.
 - **NEVER use `run_in_background: true` on Task calls**: agents must run in foreground so results are returned before the next step.

package/commands/checkpoint.md

@@ -2,7 +2,6 @@
 name: afc:checkpoint
 description: "Save session state"
 argument-hint: "[checkpoint message]"
-disable-model-invocation: true
 model: haiku
 allowed-tools:
   - Read
@@ -31,8 +30,8 @@ Collect automatically:
    - Last commit hash + message
    - List of changed files (`git status --short`)
 2. **Active Features**:
-   - Check subdirectories under `specs/`
-   - Progress state of each feature (spec only? through plan? through tasks? implementing?)
+   - Check subdirectories under `.claude/afc/specs/`
+   - Progress state of each feature (spec only? through plan? implementing?)
 3. **Tasks Progress**:
    - If tasks.md exists, count `[x]`/`[ ]` items
 4. **Current Work Context**:
@@ -56,7 +55,7 @@ Collect automatically:
 ## Active Features
 | Feature | Status | Progress |
 |---------|--------|----------|
-| {name} | {spec/plan/tasks/implementing/done} | {N/M tasks} |
+| {name} | {spec/plan/implementing/done} | {N/M tasks} |
 
 ## Incomplete Work
 {concrete next steps}