all-for-claudecode 2.13.0 → 2.14.0

package/skills/setup/SKILL.md

@@ -13,109 +13,64 @@ model: sonnet
 # /afc:setup — Global CLAUDE.md Configuration
 
 > Manages the all-for-claudecode routing block in `~/.claude/CLAUDE.md`.
-> Handles injection, updates, conflict detection, and legacy migration of the AFC block.
-> This is a **global config** operation — it modifies `~/.claude/CLAUDE.md`, NOT project files.
-> For project-local setup (config, rules, profile), use `/afc:init` instead.
+> **Global only** — modifies `~/.claude/CLAUDE.md`, not project files. For project-local setup, use `/afc:init`.
 
-This skill is a **prompt-only skill** — there is no bash script.
-All steps below are instructions for the LLM to execute directly using its allowed tools.
+## Current State
+
+!`cat ~/.claude/CLAUDE.md 2>/dev/null || echo "[CLAUDE.md NOT FOUND]"`
 
 ## Arguments
 
-- `$ARGUMENTS` — (optional) flags:
-  - `--force` — skip conflict prompts and use coexistence mode
+- `--force` — skip conflict prompts, default to coexistence mode
 
-## Execution Steps
+## Steps
 
 ### 1. Version Resolution
 
-Read `${CLAUDE_SKILL_DIR}/../../package.json` and extract the `"version"` field. Use this value as `{PLUGIN_VERSION}` throughout.
-
-### 2. Check Current State
-
-Read `~/.claude/CLAUDE.md`. If file does not exist, create it with an empty body and proceed to Step 5.
-
-Check for:
-- `<!-- AFC:START -->` marker → existing AFC block found
-- `<!-- SELFISH:START -->` marker → legacy v1.x block found
-- Neither → fresh install
+Read `${CLAUDE_SKILL_DIR}/../../package.json` → extract `"version"` → use as `{PLUGIN_VERSION}`.
 
-**If existing AFC block found:**
-- Extract version from `<!-- AFC:VERSION:X.Y.Z -->`
-- If version matches `{PLUGIN_VERSION}`: print `AFC block already up to date (v{PLUGIN_VERSION})` and **stop**
-- If version differs: proceed to Step 3 (will replace)
+### 2. Analyze Current State
 
-**If legacy SELFISH block found:**
-- Remove entire `<!-- SELFISH:START -->` ~ `<!-- SELFISH:END -->` block
-- Print: `Removed legacy SELFISH block`
-- Proceed to Step 3
+Parse the pre-fetched CLAUDE.md content above:
 
-### 3. Conflict Pattern Scan
+- `<!-- AFC:START -->` found → existing AFC block
+  - Extract `<!-- AFC:VERSION:X.Y.Z -->`. If matches `{PLUGIN_VERSION}`: print `AFC block already up to date (v{PLUGIN_VERSION})` and **stop**.
+  - Otherwise: replace block in Step 5.
+- `<!-- SELFISH:START -->` found → remove entire `SELFISH:START`…`SELFISH:END` block, print `Removed legacy SELFISH block`, proceed.
+- Neither → fresh install, proceed to Step 5.
 
-Search `~/.claude/CLAUDE.md` for routing conflicts. **IMPORTANT: EXCLUDE content inside any marker blocks (`<!-- *:START -->` ~ `<!-- *:END -->`). Only scan unguarded content outside marker blocks.** Other tools (OMC, etc.) manage their own blocks — their internal agent names are not conflicts.
+### 3. Conflict Scan
 
-**A. Marker Block Detection**
-- Regex: `<!-- ([A-Z0-9_-]+):START -->` ~ `<!-- \1:END -->`
-- Record all found block names and line ranges
-- **Strip these ranges from the scan target** — only scan lines NOT inside any marker block
+Detect conflicts in unguarded content (outside any `<!-- *:START/END -->` blocks).
+See [`conflict-detection.md`](conflict-detection.md) for marker-block algorithm and conflict keyword table.
 
-**B. Agent Routing Conflict Detection**
-In the **unguarded** (non-marker-block) content only, find directives containing these keywords:
-- `executor`, `deep-executor` — conflicts with afc:implement
-- `code-reviewer`, `quality-reviewer`, `style-reviewer`, `api-reviewer`, `security-reviewer`, `performance-reviewer` — conflicts with afc:review
-- `debugger` (in agent routing context) — conflicts with afc:debug
-- `planner` (in agent routing context) — conflicts with afc:plan
-- `analyst`, `verifier` — conflicts with afc:validate
-- `test-engineer` — conflicts with afc:test
+Skip this step if `--force` is set — default to coexistence.
 
-**C. Skill Routing Conflict Detection**
-In the **unguarded** content only, find these patterns:
-- Another tool's skill trigger table (e.g., tables like `| situation | skill |`)
-- `delegate to`, `route to`, `always use` + agent name combinations
-- Directives related to `auto-trigger`, `intent detection`, `intent-based routing`
+### 4. Resolve Conflicts
 
-**D. Legacy Block Detection**
-Previous versions without markers or with old branding:
-- `## all-for-claudecode Auto-Trigger Rules`
-- `## all-for-claudecode Integration`
-- `<selfish-pipeline>` / `</selfish-pipeline>` XML tags
+**No conflicts** → proceed to Step 5.
 
-### 4. Report Conflicts and User Choice
-
-**No conflicts found** → proceed directly to Step 5
-
-**Conflicts found** (skip if `--force` flag present — default to coexistence):
+**Conflicts found** — show scan summary and ask:
 
 ```
 CLAUDE.md Scan Results
-├─ Tool blocks found: {block name list} (lines {range})
-├─ Agent routing conflicts: {conflict count}
-│   e.g., "executor" (line XX) ↔ afc:implement
-│   e.g., "code-reviewer" (line XX) ↔ afc:review
-└─ Skill routing conflicts: {conflict count}
+├─ Tool blocks found: {names} (lines {range})
+├─ Agent routing conflicts: {count} — e.g. "executor" (line XX) ↔ afc:implement
+└─ Skill routing conflicts: {count}
 ```
 
-Ask user:
-
-> "Directives overlapping with afc were found. How would you like to proceed?"
+> "Directives overlapping with afc were found. Choose resolution:"
 >
-> 1. **afc-exclusive mode** — Adds override rules in the AFC block to cover conflicting directives.
->    Does not modify other tools' marker block contents.
-> 2. **coexistence mode** — Adds only the AFC block without overrides.
->    Since it's at the end of the file, afc directives will likely take priority.
-> 3. **manual cleanup** — Shows the conflict list only and stops.
+> 1. **afc-exclusive** — add override rules inside the AFC block (does not touch other tools' blocks)
+> 2. **coexistence** — append AFC block as-is (end-of-file position gives it priority)
+> 3. **manual cleanup** — print conflict list and abort
 
-Based on choice:
-- **Option 1**: AFC block includes explicit override rules (see conflict-overrides section below)
-- **Option 2**: AFC block added without overrides (base template as-is)
-- **Option 3**: Print conflict list only and abort without modifying CLAUDE.md
+- Option 3: print list and abort without writing.
 
 ### 5. Inject AFC Block
 
-Add the following block at the **very end** of `~/.claude/CLAUDE.md` (later-positioned directives have higher priority).
-
-Replace existing AFC block if present, otherwise append.
-If legacy block (`## all-for-claudecode Auto-Trigger Rules` etc.) exists, remove it then append.
+Append the block below to the **end** of `~/.claude/CLAUDE.md` (or replace existing AFC block in place).
+Also remove any legacy unguarded block (`## all-for-claudecode Auto-Trigger Rules`, etc.) before appending.
 
 ```markdown
 <!-- AFC:START -->
@@ -187,14 +142,13 @@ When analyzing or making claims about external systems, APIs, SDKs, or third-par
 <!-- AFC:END -->
 ```
 
-**When Option 1 (afc-exclusive mode) is selected**, add the following directly below the Override Rules:
+**When afc-exclusive mode (Option 1)** is selected, append inside the block after Override Rules:
 
 ```markdown
 ## Detected Conflicts
 
-This environment has other agent routing tools that overlap with afc.
 The following rules were auto-generated to resolve conflicts:
-- The Skill Routing table above always takes priority over the agent routing directives of {detected tool blocks}
+- The Skill Routing table above always takes priority over agent routing directives of {detected tool blocks}
 - This block is at the end of the file and therefore has the highest priority
 ```
 
@@ -204,16 +158,13 @@ The following rules were auto-generated to resolve conflicts:
 all-for-claudecode setup complete
 ├─ CLAUDE.md: {injected|updated|already current|user aborted}
 ├─ Version: {PLUGIN_VERSION}
-│   {if conflicts found} └─ Conflict resolution: {afc-exclusive|coexistence|user cleanup}
+│   {if conflicts} └─ Conflict resolution: {afc-exclusive|coexistence|user cleanup}
 └─ Next step: /afc:init (project setup) or /afc:auto (start building)
 ```
 
 ## Notes
 
-- **Idempotent**: safe to run multiple times. If version matches, it's a no-op.
-- **Global only**: this skill only touches `~/.claude/CLAUDE.md`. For project config, use `/afc:init`.
-- **Global CLAUDE.md principles**:
-  - Never modify content outside the `<!-- AFC:START/END -->` markers
-  - Never modify content inside other tools' marker blocks (`<!-- *:START/END -->`)
-  - Always place the AFC block at the very end of the file (ensures priority)
-  - Conflict resolution is handled only via override rules (do not delete or modify other blocks)
+- **Idempotent**: version match → no-op.
+- Never modify content outside `<!-- AFC:START/END -->` markers.
+- Never modify content inside other tools' `<!-- *:START/END -->` blocks.
+- Always place the AFC block at the end of the file.

package/skills/setup/conflict-detection.md

@@ -0,0 +1,33 @@
+# Conflict Detection Reference
+
+## Marker Block Scanning
+
+**Goal:** identify content inside `<!-- *:START --> ... <!-- *:END -->` blocks and exclude it from conflict analysis. Other tools manage their own blocks — only scan *unguarded* (outside-marker) content.
+
+**Algorithm:**
+1. Match `<!-- ([A-Z0-9_-]+):START -->` to `<!-- \1:END -->` pairs
+2. Record each block name and its line range
+3. Remove those line ranges from the scan target
+
+## Agent Routing Conflicts (unguarded content only)
+
+| Keyword | Conflicts with |
+|---------|---------------|
+| `executor`, `deep-executor` | afc:implement |
+| `code-reviewer`, `quality-reviewer`, `style-reviewer`, `api-reviewer`, `security-reviewer`, `performance-reviewer` | afc:review |
+| `debugger` (agent routing context) | afc:debug |
+| `planner` (agent routing context) | afc:plan |
+| `analyst`, `verifier` | afc:validate |
+| `test-engineer` | afc:test |
+
+## Skill Routing Conflicts (unguarded content only)
+
+- Skill trigger tables (e.g. `| situation | skill |`)
+- `delegate to`, `route to`, `always use` + agent name combinations
+- Directives referencing `auto-trigger`, `intent detection`, `intent-based routing`
+
+## Legacy Block Patterns
+
+- `## all-for-claudecode Auto-Trigger Rules`
+- `## all-for-claudecode Integration`
+- `<selfish-pipeline>` / `</selfish-pipeline>` XML tags

package/skills/spec/SKILL.md

@@ -111,11 +111,7 @@ Run the critic loop until convergence. Safety cap: 5 passes.
 | **EDGE_CASES** | Are at least 2 edge cases identified? Any missing boundary conditions? |
 | **TESTABILITY** | Does every System Requirement follow one of the 5 EARS patterns (WHEN/WHILE/IF/WHERE/SHALL)? Does each EARS requirement have a mapped TC (`→ TC: should_...`)? If not → FAIL and auto-fix: rewrite to EARS + generate TC mapping. |
 
-**On FAIL**: auto-fix and continue to next pass.
-**On ESCALATE**: pause, present options to user, apply choice, resume.
-**On DEFER**: record reason, mark criterion clean, continue.
-**On CONVERGE**: `✓ Critic converged ({N} passes, {M} fixes, {E} escalations)`
-**On SAFETY CAP**: `⚠ Critic safety cap ({N} passes). Review recommended.`
+Follow verdict handling and output format per `docs/critic-loop-rules.md`.
 
 ### 5.5. Auto-Checkpoint (standalone only)
 

package/skills/tasks/SKILL.md

@@ -12,10 +12,10 @@ model: sonnet
 ---
 # /afc:tasks — Task Decomposition
 
-> Generates an executable task list (tasks.md) based on plan.md.
-> Validates coverage with convergence-based Critic Loop.
+> Generates an executable task list (tasks.md) from plan.md.
+> Validates coverage with a convergence-based Critic Loop.
 >
-> **Note**: In `/afc:auto` pipeline, task generation is handled automatically at implement start (no separate tasks phase). This command is for standalone use when manual task decomposition control is needed.
+> **Note**: In `/afc:auto`, task generation runs automatically at implement start. Use this command only for standalone manual control.
 
 ## Arguments
 
@@ -23,90 +23,73 @@ model: sonnet
 
 ## Config Load
 
-**Must** read `.claude/afc.config.md` first. If the config file is not present, print "`.claude/afc.config.md` not found. Run `/afc:init` first." then **abort**.
+Read `.claude/afc.config.md` first. If missing: print "`.claude/afc.config.md` not found. Run `/afc:init` first." then **abort**.
 
 ## Execution Steps
 
 ### 1. Load Context
 
-1. Load from `.claude/afc/specs/{feature}/`:
-   - **plan.md** (required) — stop if missing: "Run /afc:plan first."
-   - **spec.md** (required)
-   - **research.md** (if present)
-2. Extract from plan.md:
-   - Phase breakdown
-   - File Change Map
-   - Architecture decisions
+From `.claude/afc/specs/{feature}/`:
+- **plan.md** (required) — if missing: "Run /afc:plan first."
+- **spec.md** (required), **research.md** (if present)
 
-### 2. Decompose Tasks
+Extract from plan.md: phase breakdown, File Change Map, architecture decisions.
 
-Decompose tasks per Phase defined in plan.md.
+### 2. Decompose Tasks
 
-#### Task Format (required)
+#### Task Format
 
 ```markdown
-- [ ] T{NNN} {[P]} {[US*]} {description} `{file path}` {depends: [TXXX, TXXX]}
+- [ ] T{NNN} {[P]} {[US*]} {description} `{file path}` {depends: [TXXX, ...]}
 ```
 
 | Component | Required | Description |
 |-----------|----------|-------------|
-| `T{NNN}` | Yes | 3-digit sequential ID (T001, T002, ...) |
-| `[P]` | No | **Mandatory parallel execution** — task MUST run in parallel with other [P] tasks in the same phase. Requires: (1) no file overlap with other [P] tasks in the same phase, (2) different target files per task (enforced by `afc-parallel-validate.sh`). Sequential substitution of [P] tasks is prohibited. |
-| `[US*]` | No | User Story label (US1, US2, ... from spec.md) |
-| description | Yes | Clear task description (start with a verb) |
-| file path | Yes | Primary target file (wrapped in backticks) |
-| `depends:` | No | Explicit dependency list — task cannot start until all listed tasks complete |
+| `T{NNN}` | Yes | 3-digit sequential ID |
+| `[P]` | No | Mandatory parallel execution — no file overlap with other [P] tasks in same phase |
+| `[US*]` | No | User Story label from spec.md |
+| `description` | Yes | Verb-first clear description |
+| `` `file path` `` | Yes | Primary target file |
+| `depends:` | No | Blocking dependency list |
 
 #### Phase Structure
 
 ```markdown
 # Tasks: {feature name}
-
-## Phase 1: Setup
-{type definitions, configuration, directory structure}
-
-## Phase 2: Core
-{core business logic, store, API}
-
-## Phase 3: UI
-{components, interactions}
-
-## Phase 4: Integration & Polish
-{integration, error handling, optimization}
+## Phase 1: Setup    — type definitions, configuration
+## Phase 2: Core     — business logic, store, API
+## Phase 3: UI       — components, interactions
+## Phase 4: Integration & Polish — error handling, optimization
 ```
 
-#### Decomposition Principles
+#### Decomposition Rules
 
-1. **1 task = 1 file** principle (where possible)
-2. **Same file = sequential**, **different files = [P] candidate**
-3. **Explicit dependencies**: Use `depends: [T001, T002]` to declare blocking dependencies. Tasks without `depends:` and with [P] marker are immediately parallelizable.
-4. **[P] physical validation**: Before finalizing tasks.md, run `"${CLAUDE_SKILL_DIR}/../../scripts/afc-parallel-validate.sh" .claude/afc/specs/{feature}/tasks.md` to verify no file path overlaps exist among [P] tasks within the same phase. Fix any conflicts before proceeding.
-5. **Dependency graph must be a DAG**: no circular dependencies allowed. **Mandatory validation**: run `"${CLAUDE_SKILL_DIR}/../../scripts/afc-dag-validate.sh" .claude/afc/specs/{feature}/tasks.md` before output. Abort if cycle detected.
-6. **Test tasks**: Include a verification task for each testable unit
-7. **Phase gate**: Add a `{config.gate}` validation task at the end of each Phase
+1. **1 task = 1 file** (where possible)
+2. Same file → sequential; different files → `[P]` candidate
+3. **`[P]` is mandatory, not optional** — once marked, task MUST run in parallel
+4. Validate `[P]` file overlaps: run `"${CLAUDE_SKILL_DIR}/../../scripts/afc-parallel-validate.sh" .claude/afc/specs/{feature}/tasks.md`
+5. Validate DAG (no cycles): run `"${CLAUDE_SKILL_DIR}/../../scripts/afc-dag-validate.sh" .claude/afc/specs/{feature}/tasks.md` — abort if cycle detected
+6. Include a verification task per testable unit
+7. Add `{config.gate}` validation task at end of each Phase
+8. **No over-decomposition**: skip separate tasks for single-line changes
 
 ### 3. Retrospective Check
 
-If `.claude/afc/memory/retrospectives/` directory exists, load the **most recent 10 files** (sorted by filename descending) 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.
+If `.claude/afc/memory/retrospectives/` exists, load the 10 most recent files (sorted descending) and check for prior `[P]` conflict patterns or granularity issues.
 
 ### 4. Critic Loop
 
-> **Always** read `${CLAUDE_SKILL_DIR}/../../docs/critic-loop-rules.md` first and follow it.
-
-Run the critic loop until convergence. Safety cap: 5 passes.
+Read [`docs/critic-loop-rules.md`](../../docs/critic-loop-rules.md) first and follow all rules. Safety cap: 5 passes.
 
 | Criterion | Validation |
 |-----------|------------|
-| **COVERAGE** | Are all files in plan.md's File Change Map included in tasks? Are all FR-* in spec.md covered? |
-| **DEPENDENCIES** | Is the dependency graph a valid DAG? Do [P] tasks within the same phase have no file overlaps? Are all `depends:` targets valid task IDs? For physical validation of [P] file overlaps, reference the validation script: `"${CLAUDE_SKILL_DIR}/../../scripts/afc-parallel-validate.sh"` can be called with the tasks.md path to verify no conflicts exist. |
+| **COVERAGE** | All files in plan.md File Change Map included? All FR-* in spec.md covered? |
+| **DEPENDENCIES** | DAG valid? `[P]` tasks in same phase have no file overlaps? All `depends:` IDs exist? |
+
+**Verdicts**: PASS / FAIL (auto-fix, continue) / ESCALATE (pause for user) / DEFER (record, continue)
 
-**On FAIL**: auto-fix and continue to next pass.
-**On ESCALATE**: pause, present options to user, apply choice, resume.
-**On DEFER**: record reason, mark criterion clean, continue.
-**On CONVERGE**: `✓ Critic converged ({N} passes, {M} fixes, {E} escalations)`
-**On SAFETY CAP**: `⚠ Critic safety cap ({N} passes). Review recommended.`
+On convergence: `✓ Critic converged ({N} passes, {M} fixes, {E} escalations)`
+On safety cap: `⚠ Critic safety cap ({N} passes). Review recommended.`
 
 ### 5. Coverage Mapping
 
@@ -115,17 +98,15 @@ Run the critic loop until convergence. Safety cap: 5 passes.
 | Requirement | Tasks |
 |-------------|-------|
 | FR-001 | T003, T007 |
-| FR-002 | T005, T008 |
 | NFR-001 | T012 |
 ```
 
-Every FR-*/NFR-* must be mapped to at least one task.
+Every FR-*/NFR-* must map to at least one task.
 
 ### 5.5. Auto-Checkpoint (standalone only)
 
-When not running inside `/afc:auto`, save progress for `/afc:resume`:
-- Write/update `.claude/afc/memory/checkpoint.md` with: branch, last commit, feature name, current phase (tasks complete), task count ({total} tasks, {parallel} parallel), next step (`/afc:implement`)
-- Skip if running inside auto pipeline (auto manages its own checkpoints via phase transitions)
+When not inside `/afc:auto`, write `.claude/afc/memory/checkpoint.md`:
+- branch, last commit, feature name, phase (tasks complete), task count, next step (`/afc:implement`)
 
 ### 6. Final Output
 
@@ -134,19 +115,15 @@ Save to `.claude/afc/specs/{feature}/tasks.md`, then:
 ```
 Tasks generated
 ├─ .claude/afc/specs/{feature}/tasks.md
-├─ Tasks: {total count} ({[P] count} parallelizable)
-├─ Phases: {phase count}
-├─ Coverage: FR {coverage}%, NFR {coverage}%
+├─ Tasks: {total} ({[P] count} parallelizable)
+├─ Phases: {count}
+├─ Coverage: FR {N}%, NFR {N}%
 ├─ Critic: converged ({N} passes, {M} fixes, {E} escalations)
 └─ Next step: /afc:validate (optional) or /afc:implement
 ```
 
 ## Notes
 
-- **Do not write implementation code**: Write task descriptions only. Actual code is the responsibility of /afc:implement.
-- **No over-decomposition**: Do not create separate tasks for single-line changes.
-- **Accurate file paths**: Use paths based on the actual project structure (no guessing).
-- **Use [P] sparingly**: Mark [P] only for truly independent tasks. When in doubt, keep sequential.
-- **Dependencies unlock orchestration**: explicit `depends:` enables /afc:implement to use dependency-aware scheduling. Note: `addBlockedBy` auto-unblocking is only guaranteed in Agent Teams mode. In sub-agent mode, the orchestrator must poll TaskList and manually check blockedBy status after each task completion.
-- **Cross-phase dependencies prohibited**: `depends:` may only reference task IDs within the same phase or a previous phase. Phase N tasks are registered only when Phase N begins — this prevents workers from claiming future-phase tasks.
-- **[P] is mandatory, not optional**: once a [P] marker is assigned, the task MUST execute in parallel. Do not mark [P] unless you are certain the task has no file overlap and no implicit ordering requirement.
+- **Cross-phase `depends:` prohibited**: only reference tasks in same or previous phase
+- **`addBlockedBy` auto-unblocking** is guaranteed in Agent Teams only; in sub-agent mode the orchestrator must poll manually
+- **Accurate file paths**: use actual project structure — no guessing

package/skills/test/SKILL.md

@@ -24,19 +24,11 @@ model: sonnet
   - Feature name (e.g., `login flow`)
   - `coverage` — full coverage analysis and gap remediation
 
-## Config Load
+## Project Config (auto-loaded)
 
-**Always** read `.claude/afc.config.md` first.
+!`cat .claude/afc.config.md 2>/dev/null || echo "[CONFIG NOT FOUND] .claude/afc.config.md not found. Create it with /afc:init."`
 
-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**
-
-Values used from config:
-- `{config.gate}` — CI validation command (from `## CI Commands` YAML)
-- `{config.architecture}` — architecture pattern (from `## Architecture` section)
-- Test framework info — from `## Project Context` section
+Values used: `{config.gate}` (CI), `{config.architecture}` (layers), test framework from Project Context.
 
 ## Execution Steps
 
@@ -102,11 +94,7 @@ Run the critic loop until convergence. Safety cap: 5 passes.
 | **COVERAGE** | Are all core logic and branch points covered? |
 | **QUALITY** | Do tests validate behavior, not implementation details? Are there any brittle tests? |
 
-**On FAIL**: auto-fix and continue to next pass.
-**On ESCALATE**: pause, present options to user, apply choice, resume.
-**On DEFER**: record reason, mark criterion clean, continue.
-**On CONVERGE**: `✓ Critic converged ({N} passes, {M} fixes, {E} escalations)`
-**On SAFETY CAP**: `⚠ Critic safety cap ({N} passes). Review recommended.`
+Follow verdict handling and output format per `docs/critic-loop-rules.md`.
 
 ### 5. Run and Verify Tests