@curdx/flow 1.1.11 → 2.0.0-beta.2

package/commands/help.md

@@ -1,119 +1,141 @@
 ---
 name: help
-description: CurDX-Flow help (command list, workflow overview, troubleshooting)
+description: Show CurDX-Flow command list, workflow overview, or troubleshooting guide. With a command name, show that command's detail.
 argument-hint: "[<command-name> | workflow | troubleshoot]"
-allowed-tools: [Read]
+allowed-tools: [Read, Bash]
 ---
 
 # CurDX-Flow Help
 
-## No Arguments — Quick Overview
+## No argument — quick overview
+
+Show the 9 core slash commands + 5 auto-invoked skills. Keep the table compact, use tabs for alignment.
 
 ```
-🚀 CurDX-Flow — AI Engineering Workflow Meta-Framework
-
-Current version: 0.1.0 (Phase 0 — Foundation)
-
-╔══════════════════════════════════════════════════════════════╗
-║ Command overview (Phase 0 implemented)                        ║
-╠══════════════════════════════════════════════════════════════╣
-║ /curdx-flow:init            Initialize .flow/ project structure     ║
-║ /curdx-flow:install-deps    One-shot install of recommended plugins ║
-║ /curdx-flow:doctor          Health check (deps + project config)    ║
-║ /curdx-flow:status          View spec and phase status              ║
-║ /curdx-flow:help            This help                               ║
-╚══════════════════════════════════════════════════════════════╝
-
-Coming soon (Phase 1+):
-  /curdx-flow:start / /curdx-flow:research / /curdx-flow:requirements / /curdx-flow:design
-  /curdx-flow:tasks / /curdx-flow:implement / /curdx-flow:verify / /curdx-flow:review
-  /curdx-flow:triage / /curdx-flow:party / /curdx-flow:debug / /curdx-flow:qa / /curdx-flow:sketch
-  /curdx-flow:ship / /curdx-flow:land / /curdx-flow:canary / /curdx-flow:retro ...
-
-Usage:
-  /curdx-flow:help <command>       View detailed usage for a command
-  /curdx-flow:help workflow        Introduce the full workflow
-  /curdx-flow:help troubleshoot    Common troubleshooting
+🚀 CurDX-Flow v2 — Claude Code Discipline Layer
+
+  9 slash commands (explicit control)
+  ────────────────────────────────────
+  /curdx-flow:init                  Initialize .flow/ in the current project
+  /curdx-flow:start                 Create / resume / switch a feature spec
+  /curdx-flow:spec                  Write or refresh the spec (--phase, --review, --regenerate)
+  /curdx-flow:implement             Execute the tasks (auto-routed strategy)
+  /curdx-flow:verify                Goal-backward verification — the differentiator
+  /curdx-flow:review                Two-stage code review (+ --adversarial, --edge-case)
+  /curdx-flow:fast                  Skip the spec — one-shot small task
+  /curdx-flow:debug                 Systematic 4-stage debugging
+  /curdx-flow:help                  This help
+
+  5 skills (auto-invoked by Claude based on context)
+  ────────────────────────────────────
+  epic                Decompose a large feature into vertical-slice sub-specs
+  browser-qa          Real-browser test via chrome-devtools MCP
+  ui-sketch           Generate UI design variants (via frontend-design skill)
+  security-audit      OWASP + STRIDE + CVE scan
+  brownfield-index    Map an unfamiliar / legacy codebase
+
+  3 MCP servers auto-installed
+  ────────────────────────────────────
+  context7                 Latest library docs
+  sequential-thinking      Structured reasoning
+  chrome-devtools          Browser automation
+
+  Usage:
+    /curdx-flow:help <command>    Detail for one command
+    /curdx-flow:help workflow     Standard workflow walkthrough
+    /curdx-flow:help troubleshoot Common problems
 ```
 
-## `<command-name>` — Command Details
+## `<command-name>` — command detail
 
-Based on the argument, read and display the corresponding command file (in a user-friendly format):
+When the argument matches one of the 9 commands, read the corresponding `commands/<name>.md` from the plugin cache and present it cleanly:
 
 ```bash
-cat "${CLAUDE_PLUGIN_ROOT}/commands/${COMMAND}.md"
+PLUGIN=$(ls -dt "$HOME/.claude/plugins/cache/curdx-flow-marketplace/curdx-flow/"*/ 2>/dev/null | head -1)
+CMD="$1"
+cat "$PLUGIN/commands/$CMD.md"
 ```
 
-## `workflow` — Workflow Overview
+If the argument isn't a known command, list the 9 candidates and the 5 skill names.
+
+## `workflow` — standard workflow
 
 ```
-📐 CurDX-Flow Standard Workflow
-
-1. Foundation (one-time)
-   └─ /curdx-flow:install-deps → /curdx-flow:init → /curdx-flow:doctor
-
-2. Per feature (Feature Workflow)
-   ├─ Research     /curdx-flow:research       (optional)
-   ├─ Requirements /curdx-flow:requirements   (required)
-   ├─ Design       /curdx-flow:design         (required)
-   ├─ Tasks        /curdx-flow:tasks          (required)
-   ├─ Execute      /curdx-flow:implement      (required)
-   ├─ Verify       /curdx-flow:verify         (required)
-   ├─ Review       /curdx-flow:review         (recommended)
-   └─ Ship         /curdx-flow:ship           (recommended)
-
-3. Large feature (Epic Workflow)
-   └─ /curdx-flow:triage → split into multiple specs advanced in parallel
-
-4. Ultra-fast path (Fast Path)
-   └─ /curdx-flow:fast "description"  — skip specs and execute directly
-
-5. Prototype exploration (Sketch Path)
-   └─ /curdx-flow:sketch "description" — UI design drafts
-
-Five modes (configured via .flow/config.json):
-  sketch      — Rapid prototyping
-  fast        — One-shot tasks
-  standard    — Regular features (default)
-  enterprise  — Full SDLC + multi-agent collaboration
-  autonomous  — Overnight automation
+📐 CurDX-Flow v2 Standard Workflow
+
+1. One-time setup (outside Claude Code)
+   └─ npx @curdx/flow install --all
+
+2. Per project (in Claude Code)
+   └─ /curdx-flow:init
+
+3. Per feature — the main loop
+   ├─ /curdx-flow:start my-feature "one-line goal"
+   ├─ /curdx-flow:spec                          ← research → requirements → design → tasks
+   ├─ (optional) /curdx-flow:spec --review      ← add multi-dim planning review
+   ├─ /curdx-flow:implement                     ← execute tasks
+   ├─ /curdx-flow:verify                        ← goal-backward check
+   └─ /curdx-flow:review                        ← code review
+
+4. Big feature (breaks into multiple specs)
+   └─ Say "this feature is too big, break it down" → epic skill auto-invokes
+
+5. One-off task (skip the spec)
+   └─ /curdx-flow:fast "rename foo to bar in src/"
+
+6. Stuck on a bug
+   └─ /curdx-flow:debug "tests fail intermittently after 3rd run"
+
+Modes (set via /curdx-flow:start --mode=...)
+  fast        One-off task paths
+  standard    Default — spec + gates + review
+  enterprise  Standard + adversarial + edge-case + security-audit
 ```
 
-## `troubleshoot` — Common Issues
+## `troubleshoot` — common issues
 
 ```
-🛠️ Common Troubleshooting
+🛠️  Common issues
+
+Q: After install, /curdx-flow:* commands are not found.
+A: Restart Claude Code. The plugin needs a fresh session to register.
+
+Q: MCP servers not starting?
+A: Check Node >= 18: node --version
+   Check MCPs:      claude mcp list
+   Health overall:  npx @curdx/flow doctor
+
+Q: GitHub slow / blocked during install?
+A: v1.1.5+ defaults to offline install (bundled plugin body).
+   Force-offline:  npx @curdx/flow install --no-deps
+   Force-online:   npx @curdx/flow install --online
 
-Q: 3 MCPs did not start?
-A: Check Node.js >= 18: `node --version`
-   View MCP status: `claude mcp list`
-   Restart Claude Code
+Q: claude-mem MCP keeps failing?
+A: It needs bun. Run: npx @curdx/flow doctor — it auto-symlinks bun if installed.
 
-Q: Recommended-plugins prompt keeps appearing?
-A: Run /curdx-flow:install-deps to install, or create the marker file manually:
-   touch "${CLAUDE_PLUGIN_DATA}/.deps-checked"
+Q: /curdx-flow:init says .flow/ already exists?
+A: Use --force, or run /curdx-flow:start directly to begin a new spec in the existing .flow/.
 
-Q: /curdx-flow:init reports "directory already exists"?
-A: An existing .flow/ is already initialized. Run /curdx-flow:status to view, or use --force to overwrite.
+Q: Skills don't auto-invoke reliably?
+A: Invoke explicitly — every skill also has a /skill-name slash. E.g., /curdx-flow:security-audit.
 
-Q: Agents do not call context7 / sequential-thinking?
-A: Make sure preamble.md is loaded (InstructionsLoaded hook).
-   Run /curdx-flow:doctor to check MCP status.
+Q: I want the old v1 commands (research, plan-ceo, party…).
+A: They're removed in v2. See MIGRATION.md for mappings, or stay on 1.x:
+   npm i -g @curdx/flow@^1.1
 
-Q: Do claude-mem and .flow/STATE.md conflict?
-A: No. claude-mem lives at ~/.claude-mem/ (SQLite), curdx-flow lives at .flow/ (JSON+MD).
-   Division of duties: claude-mem for automatic implicit memory, STATE.md for explicit decisions.
+Q: Too many gates blocking progress?
+A: Your spec mode decides gate strictness. Lower via:
+   /curdx-flow:start <name> "<goal>" --mode=fast
 
-Q: pua is too aggressive, can it be turned off?
-A: pua is an independent plugin, you can /plugin disable pua.
-   Enabling pua does not affect curdx-flow's core features (the three red lines are built into preamble).
+Q: Where are decisions logged?
+A: .flow/STATE.md (D-NN entries). Edit directly — no slash command needed.
 
-Q: Want to contribute / report a bug?
-A: https://github.com/wdx/curdx-flow/issues
+Q: File a bug / request feature
+A: https://github.com/curdx/curdx-flow/issues
 ```
 
-## Output Principles
+## Output principles
 
-- Stay concise; use tables and lists instead of long prose
-- Every answer points to a specific command; avoid filler like "please consult the docs"
-- Prioritize showing the user's next actionable step
+- Keep it compact. Use tables and lists, not prose.
+- Always point at a concrete next action, not "see the docs".
+- Version number should come from `cli/utils.js` dynamic read, not hard-coded.

package/commands/implement.md

@@ -38,7 +38,7 @@ done
 [ -z "$SPEC_NAME" ] && { echo "❌ No active spec. Run /curdx-flow:start first"; exit 1; }
 
 DIR=".flow/specs/$SPEC_NAME"
-[ ! -f "$DIR/tasks.md" ] && { echo "❌ Missing tasks.md. Run /curdx-flow:tasks first"; exit 1; }
+[ ! -f "$DIR/tasks.md" ] && { echo "❌ Missing tasks.md. Run /curdx-flow:spec first (or /curdx-flow:spec --phase=tasks to rebuild just the tasks phase)"; exit 1; }
 ```
 
 ## Step 2: Parse Task Characteristics from tasks.md
@@ -275,7 +275,7 @@ len(failed) == 1:
 
 len(failed) >= 2:
   → likely environment issue (missing deps/tsc error/permissions)
-  → stop immediately, suggest /curdx-flow:doctor
+  → stop immediately, suggest npx @curdx/flow doctor
   
 failed_attempts >= 3 (cumulative):
   → stop, user intervention required
@@ -357,10 +357,10 @@ if all tasks done:
 
 ## Error Recovery
 
-- Verify field in tasks.md is "manual" → stop, suggest re-running /curdx-flow:tasks to fix
+- Verify field in tasks.md is "manual" → stop, suggest re-running `/curdx-flow:spec --phase=tasks --regenerate` to fix
 - 3 consecutive TASK_FAILED → stop, prompt for user intervention
 - git operation failure → stop immediately, do not continue (avoid state corruption)
-- Test framework not found (npm test not found) → stop, suggest running /curdx-flow:doctor
+- Test framework not found (npm test not found) → stop, suggest running npx @curdx/flow doctor
 
 ## Output to User
 

package/commands/init.md

@@ -22,7 +22,7 @@ ls -la
 - If the current directory is a dangerous location such as the home directory or a system directory, stop and ask the user to switch
 - If `.flow/` already exists:
   - With `--force` → continue but warn about overwriting
-  - Without `--force` → stop and prompt the user to run `/curdx-flow:status` to inspect the existing state
+  - Without `--force` → stop and prompt the user to inspect `.flow/` directly, or run `/curdx-flow:start --list` to see existing specs
 
 ### Step 2: Create Directory Skeleton
 
@@ -71,7 +71,7 @@ Append (if not already present):
 
 ### Step 5: Health Check
 
-Run `/curdx-flow:doctor` (or inline its checks) to verify:
+Run `npx @curdx/flow doctor` (or inline its checks) to verify:
 - 3 MCPs started (context7 / sequential-thinking / chrome-devtools)
 - Recommended plugins status (pua / claude-mem / frontend-design)
 
@@ -90,9 +90,9 @@ Output:
 
 Next steps (in order):
   1. Edit .flow/PROJECT.md to add the project goal
-  2. /curdx-flow:install-deps   — install recommended plugins (if not installed)
-  3. /curdx-flow:doctor         — verify health
-  4. /curdx-flow:status         — view project status
+  2. (already handled) — recommended plugins installed via `npx @curdx/flow install --all`
+  3. npx @curdx/flow doctor      — verify health
+  4. /curdx-flow:start <name> "<goal>"  — begin your first feature spec
   
   Start development (after Phase 1 ships):
   5. /curdx-flow:start <name> "<goal>"  — kick off the first spec

package/commands/review.md

@@ -1,168 +1,152 @@
 ---
 name: review
-description: Two-Stage Review — Stage 1 spec compliance + Stage 2 code quality. Applies enabled Gates. Dispatches flow-reviewer.
-argument-hint: "[spec-name] [--adversarial | --edge-case | --both]"
+description: Two-stage code review — Stage 1 spec compliance, Stage 2 code quality. Optional flags add adversarial review or edge-case hunting.
+argument-hint: "[--stage=<1|2|both>] [--adversarial] [--edge-case]"
 allowed-tools: [Read, Bash, Task, Grep, Glob]
 ---
 
-# Flow Review — Two-Stage Code Review
+# Two-Stage Code Review
 
-@${CLAUDE_PLUGIN_ROOT}/knowledge/two-stage-review.md
+Distinct from `/curdx-flow:verify`:
+- **verify** checks that the spec's stated goals actually work (goal-backward).
+- **review** checks that the code is good (spec compliance + craftsmanship).
 
-Dispatches the `flow-reviewer` agent to perform a Two-Stage Review: Stage 1 compliance + Stage 2 quality.
-Optionally layer on deep reviews from `flow-adversary` and `flow-edge-hunter`.
+## Flags
 
-## When to use
+| Flag | Default | Purpose |
+|------|---------|---------|
+| `--stage=<1\|2\|both>` | `both` | Stage 1 = spec compliance only. Stage 2 = code quality only. `both` = sequential. |
+| `--adversarial` | off | Add an adversarial review pass (6 dimensions × 2 sequential-thinking rounds). Zero-findings forbidden. |
+| `--edge-case` | off | Add edge-case hunting across the 7 categories. Produces a test-gap checklist. |
 
-- After `/curdx-flow:verify` passes
-- Before PR
-- When the user explicitly requests a deep review (add --adversarial / --edge-case / --both)
-
-## Step 1: Parse arguments
+## Preflight
 
 ```bash
-ARGS="$ARGUMENTS"
-ADV=0; EDGE=0
-case "$ARGS" in
-    *--both*)        ADV=1; EDGE=1 ;;
-    *--adversarial*) ADV=1 ;;
-    *--edge-case*)   EDGE=1 ;;
-esac
-
-SPEC_NAME=$(echo "$ARGS" | sed 's/--[a-z-]*//g' | xargs)
-[ -z "$SPEC_NAME" ] && SPEC_NAME=$(cat .flow/.active-spec 2>/dev/null)
-[ -z "$SPEC_NAME" ] && { echo "❌ No active spec"; exit 1; }
+[ ! -d ".flow" ] && { echo "✗ Not a CurDX-Flow project."; exit 1; }
+
+SPEC_NAME=$(cat .flow/.active-spec 2>/dev/null)
+[ -z "$SPEC_NAME" ] && { echo "✗ No active spec."; exit 1; }
+
+# Review needs a design.md + implementation to compare against
+for f in design.md; do
+  [ ! -f ".flow/specs/$SPEC_NAME/$f" ] && {
+    echo "✗ Missing $f. Run /curdx-flow:spec first.";
+    exit 1;
+  }
+done
+
+FLAG_STAGE=$(echo "$ARGUMENTS" | grep -oP -- '--stage=\K[^\s]+' || echo "both")
+FLAG_ADV=$(echo "$ARGUMENTS" | grep -q -- '--adversarial' && echo 1 || echo 0)
+FLAG_EDGE=$(echo "$ARGUMENTS" | grep -q -- '--edge-case' && echo 1 || echo 0)
 ```
 
-## Step 2: Preflight checks
+## Stage 1 — Spec compliance
 
-```bash
-DIR=".flow/specs/$SPEC_NAME"
+Dispatch `flow-reviewer` in Stage 1 mode. It checks:
+- Implementation actually addresses every US / AC / FR / NFR in `requirements.md`
+- Code structure reflects AD-NN decisions from `design.md`
+- Task checklist in `tasks.md` is genuinely complete (all tasks marked `[x]` have real code)
+- Conventional-commit log (`git log`) matches the tasks declared completed
 
-# If /curdx-flow:verify hasn't been run, prompt to run it first
-if [ ! -f "$DIR/verification-report.md" ]; then
-    echo "⚠ /curdx-flow:verify not run. Recommend running goal-reverse verification first."
-    echo "Continue? (y/N)"
-    # AskUserQuestion
-fi
-```
+Output: Stage-1 section of the report with any compliance gaps.
 
-## Step 3: Dispatch flow-reviewer (core)
+## Stage 2 — Code quality
 
-```
-Task:
-  subagent_type: general-purpose
-  description: "Review $SPEC_NAME"
-  prompt: |
-    You are the flow-reviewer agent. Full definition:
-    ${CLAUDE_PLUGIN_ROOT}/agents/flow-reviewer.md
-    
-    Spec files to read:
-    - .flow/specs/$SPEC_NAME/requirements.md
-    - .flow/specs/$SPEC_NAME/design.md
-    - .flow/specs/$SPEC_NAME/tasks.md
-    - .flow/specs/$SPEC_NAME/.state.json
-    - .flow/specs/$SPEC_NAME/verification-report.md (if exists)
-    
-    Enabled Gates (from .flow/config.json):
-    - karpathy-gate (always)
-    - verification-gate (always)
-    - tdd-gate (standard+)
-    - coverage-audit-gate (standard+)
-    
-    Tasks:
-    Stage 1: Spec compliance review
-      - Judge each FR / AC / AD / error path as ✓/⚠/✗
-      - Check Out of Scope adherence
-    
-    Stage 2: Code quality review
-      - Apply all enabled Gates
-      - Emit per-Gate check results
-    
-    Combined verdict:
-      - APPROVED / APPROVED_WITH_WARNINGS / NEEDS_FIXES / BLOCKED
-    
-    Output:
-    .flow/specs/$SPEC_NAME/review-report.md
-    
-    Return a brief to me: Stage 1/2 verdicts, blocking/warning counts, and the top 3 fix suggestions
-```
+Dispatch `flow-reviewer` in Stage 2 mode. It checks:
+- Naming, comments, structure
+- Error handling completeness
+- Test coverage and test quality
+- Performance / resource usage concerns
+- Security smells (not a full security audit — that's `security-audit` skill)
+- Karpathy 4 principles applied
 
-## Step 4 (optional): Dispatch flow-adversary
+Output: Stage-2 section of the report.
+
+## Optional: adversarial review
 
 If `--adversarial`:
+Dispatch `flow-adversary`. It runs 6 dimensions × 2 rounds of `sequential-thinking`:
+1. What's missing?
+2. What's overengineered?
+3. What would break first in production?
+4. What's undocumented that a new maintainer would misunderstand?
+5. What decision locks us out of a future option?
+6. What would a skeptical reviewer reject?
 
-```
-Task:
-  subagent_type: general-purpose
-  description: "Adversarial review $SPEC_NAME"
-  prompt: |
-    You are the flow-adversary agent. Full definition:
-    ${CLAUDE_PLUGIN_ROOT}/agents/flow-adversary.md
-    
-    Core rule: zero findings are forbidden — must find ≥ 3 categories of issues
-    
-    Scan:
-    - .flow/specs/$SPEC_NAME/*.md
-    - Related code (git diff)
-    - Recent commits
-    
-    Use sequential-thinking ≥ 12 rounds (2 rounds × 6 dimensions)
-    
-    Output: .flow/specs/$SPEC_NAME/adversarial-review.md
-```
+**Zero findings are forbidden** — if the agent reports "all good", re-dispatch with stronger skepticism. Per `@${CLAUDE_PLUGIN_ROOT}/gates/adversarial-review-gate.md`.
 
-## Step 5 (optional): Dispatch flow-edge-hunter
+## Optional: edge-case hunting
 
 If `--edge-case`:
+Dispatch `flow-edge-hunter` across the 7 categories:
+1. Boundary values (0, MAX, empty, one-over-limit)
+2. Concurrency / race conditions
+3. Network failure / partial failure
+4. Malformed input
+5. Permission / auth failure
+6. Resource exhaustion
+7. Time / locale / timezone
 
-```
-Task:
-  subagent_type: general-purpose
-  description: "Edge-case scan $SPEC_NAME"
-  prompt: |
-    You are the flow-edge-hunter agent. Full definition:
-    ${CLAUDE_PLUGIN_ROOT}/agents/flow-edge-hunter.md
-    
-    Scan the subject's coverage across 7 categories:
-    - Boundary values / nulls / concurrency / error recovery / security / i18n / performance
-    
-    Use sequential-thinking ≥ 3 rounds per category
-    
-    Output: .flow/specs/$SPEC_NAME/edge-cases.md
-```
+Output: test-gap checklist with suggested test cases.
 
-## Step 6: Read reports + aggregate verdict
+## Report
 
-```bash
-MAIN_REPORT="$DIR/review-report.md"
-ADV_REPORT="$DIR/adversarial-review.md"
-EDGE_REPORT="$DIR/edge-cases.md"
+**Landing check**: sub-agent responses can be truncated. After dispatching review agents, verify the report actually landed on disk:
 
-# Parse the verdict from review-report.md
-VERDICT=$(grep -E "^## Verdict:" "$MAIN_REPORT" | head -1 | sed 's/## Verdict: //')
+```bash
+REPORT=".flow/specs/$SPEC_NAME/review-report.md"
+if [ ! -f "$REPORT" ] || [ "$(wc -c < "$REPORT" 2>/dev/null | tr -d ' ')" -lt 300 ]; then
+  echo "⚠ Report missing or truncated. Re-dispatching flow-reviewer with a terse 'Write the report now, no narration' prompt."
+fi
 ```
 
-## Step 7: Output to user
+Consolidated output: `.flow/specs/$SPEC_NAME/review-report.md`:
+
+```markdown
+# Review Report — <spec-name>
+
+## Stage 1 — Spec Compliance
+- ✓ FR-01: implemented in src/auth.ts
+- ✗ FR-04: missing — add handler for token refresh
+- ⚠ AC-2.1: no integration test asserting 403 on expired token
 
+## Stage 2 — Code Quality
+- Blocker: duplicated error-handling pattern in 3 files — extract helper
+- Warning: function foo() in src/a.ts: 90 lines, split
+- Nit: inconsistent naming (getUserId vs fetchUser)
+
+## Adversarial (if run)
+...
+
+## Edge Cases (if run)
+...
+
+## Verdict
+- [ ] APPROVED
+- [X] CHANGES REQUIRED — <n> blockers
+- [ ] REJECTED
 ```
-✓ Review complete: $SPEC_NAME
 
-Main report: .flow/specs/$SPEC_NAME/review-report.md
-  Verdict: $VERDICT
+## Reporting
+
+```
+✓ Review complete
+  Stage 1 findings: <n>
+  Stage 2 findings: <n>
+  Adversarial findings: <n>   (if --adversarial)
+  Edge-case gaps: <n>         (if --edge-case)
+  Verdict: CHANGES REQUIRED
 
-$([ "$ADV" = "1" ] && echo "Adversarial review: $ADV_REPORT")
-$([ "$EDGE" = "1" ] && echo "Edge-case scan: $EDGE_REPORT")
+Report: .flow/specs/<name>/review-report.md
 
-Next steps:
-$([ "$VERDICT" = "APPROVED" ] && echo "  ✓ Proceed to /curdx-flow:ship (Phase 6+)")
-$([ "$VERDICT" = "APPROVED_WITH_WARNINGS" ] && echo "  ⚠ Recommend fixing warnings first, then /curdx-flow:ship")
-$([ "$VERDICT" = "NEEDS_FIXES" ] && echo "  ❌ Fix blockers → /curdx-flow:implement --task=... → /curdx-flow:review re-review")
-$([ "$VERDICT" = "BLOCKED_BY_SPEC" ] && echo "  ❌ Back to /curdx-flow:implement to fill missing FR/AD")
+Next: address blockers, then re-run /curdx-flow:review.
 ```
 
-## Error recovery
+## References
 
-- review-report.md generation fails → check agent turn limit, reduce spec scope
-- Agent returns no findings (violates adversarial zero-tolerance) → agent auto-triggers Round 2
-- Multiple concurrent agents produce conflicting files → run sequentially, not in parallel
+- `flow-reviewer` agent: `@${CLAUDE_PLUGIN_ROOT}/agents/flow-reviewer.md`
+- `flow-adversary` agent: `@${CLAUDE_PLUGIN_ROOT}/agents/flow-adversary.md`
+- `flow-edge-hunter` agent: `@${CLAUDE_PLUGIN_ROOT}/agents/flow-edge-hunter.md`
+- `adversarial-review-gate`: `@${CLAUDE_PLUGIN_ROOT}/gates/adversarial-review-gate.md`
+- `edge-case-gate`: `@${CLAUDE_PLUGIN_ROOT}/gates/edge-case-gate.md`
+- Knowledge: `@${CLAUDE_PLUGIN_ROOT}/knowledge/two-stage-review.md`