@curdx/flow 1.1.11 → 2.0.0-beta.10

package/commands/start.md

@@ -1,189 +1,166 @@
 ---
 name: start
-description: intelligent entry point — create a new spec or resume an existing one, entering the corresponding phase
-argument-hint: "<spec-name> \"<goal>\""
-allowed-tools: [Read, Write, Bash, AskUserQuestion]
+description: Smart entry point — create a new spec, resume an existing one, or switch between specs. Replaces v1's /start + /switch.
+argument-hint: "[<spec-name>] [\"<one-line goal>\"] [--resume] [--list] [--mode=<fast|standard|enterprise>]"
+allowed-tools: [Read, Write, Bash, AskUserQuestion, Task]
 ---
 
-# Start a Spec
+# Start or Resume a Feature Spec
 
-CurDX-Flow's main entry point. Based on context, automatically:
-- New spec → create directory + templates + enter research phase
-- Existing spec → resume from the last phase
+Entry point for every feature. Works in four modes depending on flags and existing state.
 
-## Step 1: Preflight Check
+## Invocation patterns
 
-```bash
-# Must be initialized
-if [ ! -d ".flow" ]; then
-    echo "❌ Current directory is not a CurDX-Flow project. Run /curdx-flow:init first"
-    exit 1
-fi
-```
+| Pattern | Behavior |
+|---------|----------|
+| `/curdx-flow:start my-feature "Add JWT auth to REST API"` | Create a fresh spec named `my-feature`, set it active, seed draft requirements. |
+| `/curdx-flow:start my-feature` (name exists) | Switch active spec to `my-feature` (same as v1 `/switch`). |
+| `/curdx-flow:start --resume` | Resume the last active spec from `.flow/.active-spec`. |
+| `/curdx-flow:start --list` | List all specs with their phase and last-updated time, prompt to pick. |
+| `/curdx-flow:start` (no args) | Interactive: ask the user whether to create new, resume recent, or list all. |
+| Add `--mode=<fast\|standard\|enterprise>` | Set the execution mode for this spec (stored in `.state.json`). |
 
-## Step 2: Parse Arguments
+## Preflight
 
 ```bash
-ARGS="$ARGUMENTS"
-
-# Extract spec-name and goal
-# Format: flow-start my-feature "Add JWT auth to API"
-#         or: flow-start my-feature  (resume existing spec)
-SPEC_NAME=$(echo "$ARGS" | awk '{print $1}')
-GOAL=$(echo "$ARGS" | sed -E "s/^[a-z0-9-]+\s*//" | sed 's/^["\x27]//;s/["\x27]$//')
-
-if [ -z "$SPEC_NAME" ]; then
-    echo "Usage: /curdx-flow:start <spec-name> \"<goal>\""
-    echo "Example: /curdx-flow:start auth-system \"Add JWT authentication to REST API\""
-    exit 1
-fi
-
-# Validate that spec-name is kebab-case
-if ! echo "$SPEC_NAME" | grep -Eq '^[a-z][a-z0-9-]*$'; then
-    echo "❌ spec-name must be kebab-case (start with lowercase letter, only letters, digits, hyphens)"
-    exit 1
-fi
+# Require a .flow project
+[ ! -d ".flow" ] && {
+  echo "✗ Not a CurDX-Flow project. Run /curdx-flow:init first.";
+  exit 1;
+}
 ```
 
-## Step 3: Determine New vs Resume
+## Flag parsing
 
-```bash
-SPEC_DIR=".flow/specs/$SPEC_NAME"
-
-if [ -d "$SPEC_DIR" ]; then
-    # Resume mode
-    MODE="resume"
-    echo "🔄 Resuming spec: $SPEC_NAME"
-else
-    # New mode
-    MODE="new"
-    echo "🆕 New spec: $SPEC_NAME"
-    
-    if [ -z "$GOAL" ]; then
-        # If no goal given, ask the user
-        echo "Please provide a one-sentence goal, then continue."
-        exit 0
-    fi
-fi
-```
+**Do not shell-split `$ARGUMENTS`.** It is a user-supplied string that may
+contain quoted substrings with spaces, `$`-signs, or embedded quotes.
+`xargs`, naive `awk`, and `sed`-based quote stripping all mis-parse at
+least one of those cases (e.g. `my-feature "Fix user's login bug"` breaks
+`xargs: unmatched quote`). Parse the string as a model task instead:
 
-## Step 4a: New Path
+1. **Flags** (order-independent, each is self-delimited):
+   - `--resume` / `--list` — boolean presence
+   - `--mode=<fast|standard|enterprise>` — value after `=`
+   Detect each with a single regex over the full `$ARGUMENTS` string and
+   remove the matched span from your working copy. Flags not in the list
+   above are errors — surface them to the user.
 
-If `MODE=new`:
+2. **Positional args** (after flags removed):
+   - First whitespace-separated token → `SPEC_NAME` (kebab-case `[a-z0-9-]+`).
+   - Remainder of the string, trimmed and with one layer of outer `"..."`
+     or `'...'` quotes stripped → `GOAL`. Preserve inner quotes as-is.
 
-```bash
-# Create directory
-mkdir -p "$SPEC_DIR"
+3. If `SPEC_NAME` does not match `^[a-z0-9][a-z0-9-]*$` (per
+   `schemas/spec-state.schema.json`), stop and ask the user to pick a
+   valid kebab-case name.
+
+Mode must be `fast`, `standard`, or `enterprise`. Invalid → default to
+`standard` with a warning.
 
-# Generate .state.json
-TODAY=$(date +%Y-%m-%d)
-CONFIG_MODE=$(python3 -c "import json; print(json.load(open('.flow/config.json')).get('mode','standard'))" 2>/dev/null || echo "standard")
+Example inputs and their parse:
 
-cat > "$SPEC_DIR/.state.json" <<EOF
+| `$ARGUMENTS`                                    | SPEC_NAME    | GOAL                          | flags         |
+|-------------------------------------------------|--------------|-------------------------------|---------------|
+| `my-feature "Add JWT auth"`                     | `my-feature` | `Add JWT auth`                | —             |
+| `my-feature --mode=fast "Add JWT auth"`         | `my-feature` | `Add JWT auth`                | mode=fast     |
+| `my-feature "Fix user's login bug"`             | `my-feature` | `Fix user's login bug`        | —             |
+| `--list`                                        | —            | —                             | list=true     |
+| `--resume`                                      | —            | —                             | resume=true   |
+
+## Branch logic
+
+### Branch A: `--list`
+Enumerate every directory under `.flow/specs/`, read each `.state.json` for `phase` and `updated` (per `schemas/spec-state.schema.json`), print a numbered list, then `AskUserQuestion` to pick one. Picking sets `.flow/.active-spec` and exits.
+
+### Branch B: `--resume` (no name)
+Read `.flow/.active-spec`. If it points to a valid spec dir, report its current phase and next suggested command (`/curdx-flow:spec` if incomplete, `/curdx-flow:implement` if tasks ready). If `.active-spec` is empty or stale, fall back to Branch A.
+
+### Branch C: `SPEC_NAME` provided, spec exists
+Switch `.flow/.active-spec` to `SPEC_NAME`. Confirm with the user if they intended to switch (not overwrite). Report current phase.
+
+### Branch D: `SPEC_NAME` provided, spec does NOT exist
+Create a new spec:
+
+```bash
+mkdir -p ".flow/specs/$SPEC_NAME"
+# NOTE: field names MUST match schemas/spec-state.schema.json:
+#   - spec_name (not "spec")
+#   - created (date, not "created_at")
+#   - updated (date-time, not "updated_at")
+#   - phase must be one of the enum values; the initial phase is "research"
+#     (there is no "created" phase — that was schema drift pre-beta.9)
+#   - version is required
+cat > ".flow/specs/$SPEC_NAME/.state.json" <<JSON
 {
   "version": "1.0",
   "spec_name": "$SPEC_NAME",
   "goal": "$GOAL",
-  "mode": "$CONFIG_MODE",
-  "strategy": "auto",
+  "mode": "$FLAG_MODE",
   "phase": "research",
-  "phase_status": {
-    "research": "not_started",
-    "requirements": "not_started",
-    "design": "not_started",
-    "tasks": "not_started"
-  },
-  "decisions": [],
-  "created": "$TODAY",
-  "updated": "$TODAY"
+  "phase_status": {},
+  "strategy": "auto",
+  "execute_state": {},
+  "created": "$(date -u +%Y-%m-%d)",
+  "updated": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 }
-EOF
-
-# Generate progress.md (from template)
-python3 <<PYEOF
-from pathlib import Path
-tmpl = Path("${CLAUDE_PLUGIN_ROOT}/templates/progress.md.tmpl").read_text()
-content = tmpl.replace("{{SPEC_NAME}}", "$SPEC_NAME").replace("{{CREATED_DATE}}", "$TODAY")
-Path("$SPEC_DIR/.progress.md").write_text(content)
-PYEOF
-
-# Set as active spec
-echo "$SPEC_NAME" > ".flow/.active-spec"
-
-echo "✓ Spec directory created: $SPEC_DIR"
-echo "  Goal: $GOAL"
-echo ""
-echo "Next step (automatically entering research):"
-echo "  /curdx-flow:research"
+JSON
+echo "$SPEC_NAME" > .flow/.active-spec
 ```
 
-## Step 4b: Resume Path
+If `GOAL` is empty, `AskUserQuestion` to gather it before writing `.state.json`.
 
-If `MODE=resume`:
+Then seed a minimal `.progress.md`:
 
 ```bash
-# Read current phase
-STATE_FILE="$SPEC_DIR/.state.json"
-if [ ! -f "$STATE_FILE" ]; then
-    echo "✗ Spec directory exists but .state.json is missing. State may be corrupted."
-    # Ask user
-    # AskUserQuestion: "Rebuild state file?" (yes/no)
-    exit 0
-fi
-
-# Set as active
-echo "$SPEC_NAME" > ".flow/.active-spec"
-
-# Show current progress
-python3 <<PYEOF
-import json
-s = json.load(open("$STATE_FILE"))
-print(f"✓ Spec activated: $SPEC_NAME")
-print(f"  Goal:        {s.get('goal','(undefined)')}")
-print(f"  Current phase: {s['phase']}")
-print(f"  Progress:")
-
-ph_emoji = {"completed": "✓", "in_progress": "●", "not_started": "○", "failed": "✗", "skipped": "—"}
-for phase, status in s.get('phase_status',{}).items():
-    emoji = ph_emoji.get(status, "?")
-    print(f"    {emoji} {phase:<15} {status}")
-
-print()
-
-# Recommend next step
-phase_order = ["research", "requirements", "design", "tasks", "execute", "verify", "ship"]
-for p in phase_order:
-    st = s.get('phase_status',{}).get(p, 'not_started')
-    if st in ("not_started", "in_progress"):
-        print(f"Next step: /curdx-flow:{p}")
-        break
-else:
-    print("All phases complete! Use /curdx-flow:status to see details.")
-PYEOF
+cat > ".flow/specs/$SPEC_NAME/.progress.md" <<MD
+# Progress Log — $SPEC_NAME
+
+**Goal**: $GOAL
+**Mode**: $FLAG_MODE
+**Created**: $(date -u +%Y-%m-%d)
+
+## Decisions
+(populated during /curdx-flow:spec)
+
+## Learnings
+(populated during /curdx-flow:implement)
+MD
 ```
 
-## Step 5: Summary Prompt
+### Branch E: no args, no flags
+```
+AskUserQuestion:
+  "No spec name given. What would you like to do?"
+  Options:
+    - Create a new spec (prompts for name + goal)
+    - Resume the last active spec
+    - List all specs
+```
+
+Route to the matching branch.
+
+## Mode semantics
+
+The `mode` field in `.state.json` drives behavior in later commands:
+
+| Mode | `/curdx-flow:spec` default | `/curdx-flow:implement` default | Gates applied |
+|------|---------------------------|--------------------------------|---------------|
+| `fast` | skipped (use `/curdx-flow:fast` instead) | linear strategy | karpathy + verification |
+| `standard` | full 4 phases | auto strategy | + tdd + coverage-audit |
+| `enterprise` | full 4 phases + `--review=all` | auto strategy + stricter gates | + adversarial + edge-case + security |
+
+## Post-create reporting
 
 ```
-═══════════════════════════════════════════════
-✓ Spec ready: $SPEC_NAME
-
-Workflow:
-  1. /curdx-flow:research       ← research (deep exploration)
-  2. /curdx-flow:requirements   ← requirements (user stories + acceptance criteria)
-  3. /curdx-flow:design         ← design (architectural decisions, freeze choices)
-  4. /curdx-flow:tasks          ← task decomposition (auto-verifiable tasks)
-  
-  One-shot version: /curdx-flow:spec    ← run research/req/design/tasks in sequence
-
-Fast modes:
-  /curdx-flow:fast              ← skip spec and implement directly
-  /curdx-flow:sketch            ← UI prototype exploration
-═══════════════════════════════════════════════
+✓ Spec ready: <name>
+  Goal:  <goal>
+  Mode:  <mode>
+  Path:  .flow/specs/<name>/
+
+Next: /curdx-flow:spec
 ```
 
-## Error Recovery
+## References
 
-- `.flow/` does not exist → prompt `/curdx-flow:init`
-- spec-name invalid → provide kebab-case example
-- Spec directory corrupted → ask user whether to delete-and-rebuild or repair
+- State schema: `@${CLAUDE_PLUGIN_ROOT}/schemas/spec-state.schema.json`
+- Mode semantics: `@${CLAUDE_PLUGIN_ROOT}/knowledge/execution-strategies.md`

package/commands/verify.md

@@ -1,124 +1,142 @@
 ---
 name: verify
-description: goal reverse verification — trace back from FR/AC/AD to check whether the code actually implements them, detect stubs / fake completion. Dispatches flow-verifier.
-argument-hint: "[spec-name]"
+description: Goal-backward verification — trace from every FR / AC / AD in the spec to the code and tests, detect stubs and fake completions. The differentiator command. Optionally adds multi-source coverage audit with --strict.
+argument-hint: "[--strict]"
 allowed-tools: [Read, Bash, Task, Grep, Glob]
 ---
 
-# Flow Verify — Goal Reverse Verification
+# Goal-Backward Verification
 
-Dispatch the `flow-verifier` agent to confirm, starting from the spec, that the code truly implements the requirements; do not trust any "done" claim.
+This is the **differentiator command**: it scans the implementation against the spec's own requirements and catches the most common Claude failure mode — claiming "done" while actual code is a stub or fake completion.
 
-## When to Use
+## Flags
 
-- After `/curdx-flow:implement` completes
-- Final gate before a PR
-- When you suspect a feature is a fake implementation (stub/TODO)
+| Flag | Default | Purpose |
+|------|---------|---------|
+| `--strict` | off | Also run multi-source coverage audit (FR / AC / AD / Research conclusions / D-NN decisions) — replaces v1's `/audit` command. |
 
-## Step 1: Parse + Preflight Check
+## Preflight
 
 ```bash
-SPEC_NAME="${ARGUMENTS:-$(cat .flow/.active-spec 2>/dev/null)}"
-[ -z "$SPEC_NAME" ] && { echo "❌ No active spec. Run /curdx-flow:switch or /curdx-flow:start first"; exit 1; }
+[ ! -d ".flow" ] && { echo "✗ Not a CurDX-Flow project."; exit 1; }
 
-DIR=".flow/specs/$SPEC_NAME"
-for f in requirements.md design.md; do
-    [ ! -f "$DIR/$f" ] && { echo "❌ Missing $f. Complete /curdx-flow:requirements /curdx-flow:design first"; exit 1; }
+SPEC_NAME=$(cat .flow/.active-spec 2>/dev/null)
+[ -z "$SPEC_NAME" ] && { echo "✗ No active spec. Run /curdx-flow:start first."; exit 1; }
+
+SPEC_DIR=".flow/specs/$SPEC_NAME"
+for f in requirements.md design.md tasks.md; do
+  [ ! -f "$SPEC_DIR/$f" ] && {
+    echo "✗ $SPEC_DIR/$f missing. Run /curdx-flow:spec first.";
+    exit 1;
+  }
 done
+
+FLAG_STRICT=$(echo "$ARGUMENTS" | grep -q -- '--strict' && echo 1 || echo 0)
 ```
 
-## Step 2: Determine Scope
+## Workflow
 
-```bash
-# Read the commit range for the execute phase
-# From .state.json or git reflog
-
-LAST_EXEC_START=$(python3 -c "
-import json
-s = json.load(open('$DIR/.state.json'))
-# Custom field or inferred from git
-print(s.get('execute_state', {}).get('start_commit', ''))
-")
-
-# If unavailable, use main..HEAD
-RANGE="${LAST_EXEC_START:-main}..HEAD"
-echo "Verification scope: $RANGE"
-```
+### Step 1: Dispatch `flow-verifier`
 
-## Step 3: Dispatch flow-verifier
+Delegate to the `flow-verifier` agent with:
+- `requirements.md` (source of FR-NN, AC-N.N, US-NN)
+- `design.md` (source of AD-NN)
+- `tasks.md` (source of T-N.M and their Verify commands)
+- Repository root (to scan code + tests)
 
-```
-Task:
-  subagent_type: general-purpose
-  description: "verify $SPEC_NAME"
-  prompt: |
-    You are the flow-verifier agent. Full definition:
-    ${CLAUDE_PLUGIN_ROOT}/agents/flow-verifier.md
-    
-    Must 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/STATE.md
-    
-    Verification scope: commits $RANGE
-    
-    Tasks:
-    1. Extract every FR / AC / AD / Component / error-path assertion
-    2. Find evidence for each assertion (code + test + actual run)
-    3. Scan for stub patterns (TODO / Not implemented / return {})
-    4. Generate verification-report.md
-    5. Update phase_status.verify in .state.json
-    
-    Output file:
-    .flow/specs/$SPEC_NAME/verification-report.md
-    
-    Return a brief:
-    - Fully verified / partially verified / not verified counts
-    - Number of fake implementations
-    - List of blockers
-    - Suggested next step
-```
+The agent performs goal-backward tracing:
+1. For each **FR-NN**: search for code that implements it. Classify as `IMPLEMENTED` / `STUB` / `MISSING` / `UNCERTAIN`.
+2. For each **AC-N.N**: search for a test that exercises it. Classify as `TESTED` / `UNTESTED`.
+3. For each **AD-NN**: check that the design decision is reflected in code structure / interfaces.
+4. Detect suspicious patterns:
+   - `throw new Error("not implemented")` / `TODO` / `NotImplementedError`
+   - `return null` / `return {}` in places that should produce real output
+   - test files with only `it.skip(...)` or no assertions
+   - code that returns mocked fixtures instead of calling real collaborators
+
+### Step 2: Run the Verify commands from `tasks.md`
+
+For every task listed in `tasks.md`, run its declared `Verify:` command and record pass/fail. This is the most objective check — if the task said `npm test -- auth.spec.ts`, run exactly that.
+
+### Step 3: (Strict only) Multi-source coverage audit
+
+If `--strict`:
+- Cross-check every FR / AC / AD / decision against the implementation
+- Cross-check every research conclusion: was the recommended library / approach actually used?
+- Cross-check every D-NN decision in `.flow/STATE.md` that references this spec
+
+### Step 4: Produce `verification-report.md`
 
-## Step 4: Read Report + Decide
+**Landing check**: sub-agent responses can be truncated by the model's output-length limit. After dispatching `flow-verifier`, verify the report actually landed:
 
 ```bash
-REPORT="$DIR/verification-report.md"
-[ ! -f "$REPORT" ] && { echo "❌ verifier did not produce a report"; exit 1; }
-
-# Parse the verdict from the report
-VERIFIED=$(grep -c "^\- ✓" "$REPORT" || echo 0)
-PARTIAL=$(grep -c "^\- ⚠" "$REPORT" || echo 0)
-MISSING=$(grep -c "^\- ✗" "$REPORT" || echo 0)
-STUBS=$(grep -c "^\- 🚨" "$REPORT" || echo 0)
+REPORT=".flow/specs/$SPEC_NAME/verification-report.md"
+if [ ! -f "$REPORT" ] || [ "$(wc -c < "$REPORT" 2>/dev/null | tr -d ' ')" -lt 300 ]; then
+  echo "⚠ Report missing or truncated. Re-dispatching flow-verifier with a terse 'write the report now' prompt."
+  # Re-dispatch pattern:
+  #   "Your only job right now is to Write the verification-report.md using the
+  #    findings you already gathered. Do not re-scan. Do not narrate. Write
+  #    the file and stop."
+fi
 ```
 
-## Step 5: Output to User
+Write to `.flow/specs/$SPEC_NAME/verification-report.md`:
 
+```markdown
+# Verification Report — <spec-name>
+
+**Generated**: <ISO8601>
+**Mode**: strict | normal
+
+## Summary
+- FR coverage:  N/M implemented (K stubs, L missing)
+- AC coverage:  N/M tested
+- AD coverage:  N/M reflected
+- Verify commands: N/M passing
+
+## Findings
+
+### Missing implementations
+- FR-02: <description>. No matching code found in <paths searched>.
+
+### Stubs / fake completions
+- FR-05: Implemented in `src/auth.ts:42` but body is `throw new Error("not implemented")`.
+
+### Untested acceptance criteria
+- AC-1.3: No test asserts token refresh after 15 min expiry.
+
+### Failing Verify commands
+- T-2.1: `npm test auth.spec.ts` → 3 failed
+
+## Verdict
+- [ ] PASS — all items covered and passing
+- [X] PARTIAL — <n> findings must be addressed before shipping
+- [ ] MISSING — substantive implementation gaps
 ```
-✓ Verify complete: $SPEC_NAME
 
-Stats:
-  ✓ Fully verified:     $VERIFIED
-  ⚠ Partially verified: $PARTIAL
-  ✗ Not verified:       $MISSING
-  🚨 Fake implementations: $STUBS
+### Step 5: Apply `verification-gate`
+
+Hard rule from `@${CLAUDE_PLUGIN_ROOT}/gates/verification-gate.md`:
+- Any `STUB` or `MISSING` finding on a non-deferred FR blocks completion.
+- Any failing Verify command blocks completion.
+- Waive only with an explicit user D-NN decision logged to `.flow/STATE.md`.
 
-Report: .flow/specs/$SPEC_NAME/verification-report.md
+## Reporting
+
+```
+✓ Verification complete
+  FR coverage: 8/10 implemented (1 stub, 1 missing)
+  AC coverage: 9/12 tested
+  Verify commands: 14/15 passing
+  Verdict: PARTIAL
 
-Verdict:
-  $([ $MISSING -gt 0 ] && echo '❌ BLOCKED — unimplemented FR/AC/AD exist, return to /curdx-flow:implement to fill in')
-  $([ $STUBS -gt 0 ] && echo '❌ BLOCKED — fake implementations found')
-  $([ $MISSING -eq 0 ] && [ $STUBS -eq 0 ] && echo '✓ PASS — can proceed to /curdx-flow:review')
+Findings written to: .flow/specs/<name>/verification-report.md
 
-Next step:
-  $([ $MISSING -gt 0 ] && echo 'fix blockers → /curdx-flow:implement --task=<new task>')
-  $([ $MISSING -eq 0 ] && echo '/curdx-flow:review — enter code quality review')
+Next: address findings, then re-run /curdx-flow:verify, or run /curdx-flow:review.
 ```
 
-## Error Recovery
+## References
 
-- verifier times out → reduce spec scope (verify only specific FRs), then rerun
-- Some Verify commands are unavailable (e.g. require a DB connection) → mark "needs manual verification" in the report
-- verifier output is vague → prompt to look at specific sections of the report
+- `flow-verifier` agent: `@${CLAUDE_PLUGIN_ROOT}/agents/flow-verifier.md`
+- `verification-gate`: `@${CLAUDE_PLUGIN_ROOT}/gates/verification-gate.md`
+- `coverage-audit-gate` (used in strict mode): `@${CLAUDE_PLUGIN_ROOT}/gates/coverage-audit-gate.md`

package/gates/adversarial-review-gate.md

@@ -33,19 +33,19 @@ A reviewer agent's output of "everything looks fine, no issues found" is an **in
 - "Looks good" is usually confirmation bias (the agent only checked the obvious)
 - AI tends to please the user ("great job!") — fight this tendency
 
-**Forced actions**:
-1. If the agent outputs "no issues", automatically trigger a second round
-2. The second round requires the agent to perform deeper analysis via sequential-thinking
-3. If both rounds yield no findings, the agent must **prove** it checked:
-   - List the dimensions examined (at least 5)
-   - For each dimension, give the specific code/file locations inspected
-   - Provide counterfactual hypotheses of "what it would look like if there were a problem"
+**Forced actions when the agent reports "no issues"**:
+1. Automatically trigger a second round framed as "what would a senior skeptic reject in this PR?"
+2. If both rounds still honestly yield no findings, the agent must emit a **proof-of-checking report**:
+   - Every category it examined (with "N/A" for categories that don't apply)
+   - For each examined category, the specific code/file locations inspected
+   - Counterfactual hypotheses of "what this would look like if there were a problem" and why that signature is absent
+3. Fabricating findings to avoid the proof-of-checking step is a violation of L3 red line #2 (fact-driven). Better to emit "clean verdict with proof" than invent issues.
 
 ---
 
-### Rule 2: Findings in at Least 3 Categories
+### Rule 2: Coverage proportional to feature scope
 
-A complete adversarial review must cover (find issues in at least 3 of these categories):
+A complete adversarial review covers every category that applies to the feature, marks the rest as N/A with reason. Number of findings per category is proportional to real issues, not a quota:
 
 1. **Architecture layer**: Are decisions sound? Future-extensible? Lock-in risks?
 2. **Implementation layer**: Code quality? Error handling? Performance?
@@ -86,22 +86,22 @@ Not allowed:
 Input: object under review (code range / spec / PR diff)
   ↓
 Round 1 (agent self-analysis):
-  - Use sequential-thinking ≥ 6 rounds
-  - Scan all 6 categories
+  - Use sequential-thinking proportional to the surface being probed
+  - Scan each applicable category; mark N/A ones with reason
   - Output findings list
   ↓
 Decision:
-  - Findings ≥ 3? → output report
-  - Findings < 3? → force Round 2
+  - Any real findings? → output report with findings
+  - Zero findings after honest Round 1? → force Round 2 framed as skeptic
   ↓
 Round 2 (deep analysis):
-  - sequential-thinking for another 6 rounds
+  - sequential-thinking proportional to residual uncertainty
   - Focus on "seemingly no issues" parts (trust but verify)
-  - May introduce external perspectives (read issues from similar projects)
+  - Optionally introduce external perspectives (read issues from similar projects)
   ↓
 Decision:
-  - Still < 3? → agent must explicitly prove it checked
-  - Otherwise → output report
+  - Still zero findings? → agent must emit proof-of-checking report (NOT invent findings)
+  - Findings exist? → output report
   ↓
 Output: review-report.md
 ```
@@ -190,10 +190,10 @@ Fix loop:
 
 ## Failure Recovery
 
-If after 2 rounds there are still < 3 findings:
+If after Round 2 the honest verdict is still zero findings, emit a proof-of-checking report (do NOT fabricate to hit a quota — there is no quota):
 
 ```markdown
-## Adversarial Review — Insufficient Findings
+## Adversarial Review — Proof of Checking (zero findings)
 
 I have examined the following dimensions across 2 rounds of analysis:
 
@@ -210,7 +210,7 @@ I have examined the following dimensions across 2 rounds of analysis:
 
 Recommendations:
 - Human review (at least walk through the diff once)
-- Consider /curdx-flow:qa for real browser/integration testing (Phase 5+)
+- Consider the `browser-qa` skill for real browser/integration testing (Phase 5+)
 - Wait until deployment to staging to observe
 ```
 

package/gates/coverage-audit-gate.md

@@ -17,7 +17,7 @@ depends_on: []
 
 - End of the tasks phase (last step of flow-planner)
 - Before the execution phase completes (when /curdx-flow:verify runs)
-- Explicitly requested by /curdx-flow:audit
+- Explicitly requested by /curdx-flow:verify --strict
 
 ---