@dougharness/cli 1.0.2 → 1.1.0

package/node_modules/@dougharness/flow/skills/doug-swarm/SKILL.md

@@ -15,7 +15,7 @@ The swarm pays on a task with independent deliverables that share no new symbol;
 
 Start from a clean working tree on the base branch (`git status --porcelain` empty apart from `.doug/` and `.claude/worktrees/`).
 
-- A card id: `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" card <id>`. A card with `"track": "hand"` is harness work built in the checkout (decision 0005), not a swarm; say so and end. Move the card to In flow exactly as `/doug-next` step 1 does (`board.mjs move <id> flow`), leaving the move uncommitted working state that the served page (`doug board serve`) shows live.
+- A card id: `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" card <id>`. A card with `"track": "hand"` is a by-hand card, not a swarm; say so, name `/doug-next <id>` as the command that takes it, and end. Move the card to In flow exactly as `/doug-next` step 1 does (`board.mjs move <id> flow`), leaving the move uncommitted working state that the served page (`doug board serve`) shows live.
 - A goal: no board record changes; the plan carries no `card`.
 
 Put the card's title and goal (or the goal text) in the chat verbatim, in a fenced code block. If it depends on a fact outside the repository, invoke the `research` skill first.
@@ -40,13 +40,13 @@ Invoke the `swarm-launch` skill: it checks the plan is approved with swarm on an
 
 ## 6. Follow-up cards
 
-`/doug-next` step 6 verbatim: gather the run's follow-up candidates, ask once with `AskUserQuestion` when there are any, and add accepted ones with `doug board add`, then one commit.
+`/doug-next` step 6 verbatim: gather the run's follow-up candidates and file each straight to Backlog with `doug board add`, placed by priority, then one commit.
 
-Before the continue gate, gather the follow-up candidates this landing produced: the report's review issues, the adversary blocks classified marginal or false whose reason names a hole, the integrate stage's conflicts and failed verify tails, and the landing summary. Suggestions come only from what the run actually reported, never invented; each carries the one-line reason and cites the pass that found it. A reviewer's out-of-scope finding is offered only when it is realistic drift (a form a model or a person would plausibly write) or when one card would close the whole class; otherwise it goes in the landing note and the lead recommends none. The suggestion's goal text carries both: the goal names the pass that found it (the reviewer's finding, the implementer's blockedReason or handoff, the verifier's findings, the adversary block id) and the landed commit.
+Before the continue gate, gather the follow-up candidates this landing produced: the report's review issues, the adversary blocks classified marginal or false whose reason names a hole, the integrate stage's conflicts and failed verify tails, and the landing summary. Suggestions come only from what the run actually reported, never invented; each carries the one-line reason and cites the pass that found it. A reviewer's out-of-scope finding is filed only when it is realistic drift (a form a model or a person would plausibly write) or when one card would close the whole class; otherwise it goes in the landing note and is not filed. The card's goal text carries both: the goal names the pass that found it (the reviewer's finding, the implementer's blockedReason or handoff, the verifier's findings, the adversary block id) and the landed commit.
 
-A landing with no candidates skips the question. Otherwise ask once with `AskUserQuestion`, `multiSelect: true`, one option per suggestion with a proposed id, title, column, size, class, track, and deps on the landed card, plus a "none" option.
+Follow-ups are filed without a question. A landing with no candidates files nothing. Each realistic candidate goes straight to Backlog with `doug board add` (never a script that edits the record): `doug board add <id> --title "<title>" --goal "<goal>" --component <c> --size <S|M|L> --class <tests-only|prose|gate-script|code|docs|eval|decision> --track <hand|flow> --deps <landed-id> --column backlog`. Then the lead places it in Backlog by priority with `doug board reorder`: `--top` for a defect that blocks a commit, a gate, or a user; `--after <id>` of the last such card for drift a user would hit; `--bottom` otherwise. Only the user promotes a card to Ready; the lead never files a follow-up to Ready or Decide.
 
-Each accepted suggestion is added with `doug board add` (never a script that edits the record): `doug board add <id> --title "<title>" --goal "<goal>" --component <c> --size <S|M|L> --class <tests-only|prose|gate-script|code|docs|eval|decision> --track <hand|flow> --deps <landed-id> --column <ready|decide>` (or `node packages/doug-cli/dist/bin.js board add ...` when `doug` is not on PATH; build the CLI first if `dist/` is missing). An S hand card goes to the top of Ready (`doug board reorder <id> --top`) when it is mechanical and to Decide when it needs a decision. Then one commit `"Board: <id> follow-ups added: <new-id>, <new-id>"`, whatever the count; the served page (`doug board serve`) shows the new cards without a republish. Batch: each suggestion's deps name the card of the batch it came from; still one question and one commit for the whole batch.
+The lead says in the chat what it filed and where: each new card's id, title, and its Backlog position with the reason. Then one commit `"Board: <id> follow-ups added: <new-id>, <new-id>"`, whatever the count; the served page (`doug board serve`) shows the new cards without a republish. Batch: each card's deps name the card of the batch it came from; still one commit for the whole batch.
 
 A goal without a card (section 1's second bullet) skips this step, the way section 5 says such a run skips the board steps.
 

package/node_modules/@dougharness/flow/skills/research/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: research
-description: The research step before a plan, for a card whose goal depends on facts outside the repository (a Claude Code hook contract, a CLI's output format, a third-party API). One researcher, or several in parallel with distinct questions, write one cited note the planner and the builder work from; uncertainty is stated, never guessed. Invoked by /core-next, /doug-plan, and /doug-next before planning, or on its own.
+description: The research step before a plan, for a card whose goal depends on facts outside the repository (a Claude Code hook contract, a CLI's output format, a third-party API). One researcher, or several in parallel with distinct questions, write one cited note the planner and the builder work from; uncertainty is stated, never guessed. Invoked by /doug-next, doug-hand, and /doug-plan before planning, or on its own.
 allowed-tools: Agent, Read, Write, Bash(mkdir *), Bash(cat *), Bash(node *plan.mjs *)
 ---
 
@@ -31,11 +31,13 @@ Write the findings to `.doug/.state/research/<card-id>.md` (session state, ignor
 - the sources: a URL, a file path with a line, or a command and its output, one per fact;
 - what stayed unverified, marked `unverified`, with what was tried. Never guess a fact into the note; an unverified line is what keeps the planner from building on it.
 
+A fact the design depends on is marked verified only when it is quoted verbatim from the raw source with its line number, fetched and searched (for example `curl -sL <url>` then `grep -n`) by the plugin's researcher agent or by a claude-code-guide asked for exact quotes; a guide answer that paraphrases, or cannot give the line, stays `unverified` in the note. The confirming fetch counts against the same research.maxFetches budget. On 2026-10-01 a guide answer quoted a sentence the raw sub-agents page does not contain, and only the grep caught it.
+
 The note is written under the card's id, not the question's, because the id is also the promotion key: a note for a card that lands is promoted to `docs/research/<card-id>.md`, `board.mjs record` copying it there when it records the landing so a commit that cites the note has something to read afterward. A note for a card that never lands (dropped, replanned under another id) stays in state and is eventually swept with the rest of `.doug/.state/`.
 
 Then hand it on:
 
 - Flow track (`/doug-plan`, `/doug-next`): give the planner the note's path in its prompt. The planner writes the facts it relied on into the plan's goal with their sources and marks any unverified one.
-- Hand track (`/core-next`): the builder reads the note before the test, cites the sources in the commit message where a fact decided the design, and names the note in the landing's `--note`.
+- Hand track (doug-hand): the builder reads the note before the test, cites the sources in the commit message where a fact decided the design, and names the note in the landing's `--note`.
 
 The step spends agents only when invoked and publishes nothing.

package/node_modules/@dougharness/flow/skills/run-report/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: run-report
-description: End a card's run with one command: append the docs/live-runs.md entry for a workflow report (or a hand-track landing), and print the three-line summary that goes in the chat. Called by /doug-next after land and by /core-next after the commit; usable on any saved report.
+description: End a card's run with one command: append the docs/live-runs.md entry for a workflow report (or a hand-track landing), and print the three-line summary that goes in the chat. Called by /doug-next after land and by doug-hand after the commit; usable on any saved report.
 allowed-tools: Agent, Read, Bash
 ---
 
@@ -14,11 +14,11 @@ With the card id, the report (`.doug/.state/last-report.json` unless another pat
 
 1. `node "${CLAUDE_PLUGIN_ROOT}/scripts/cost.mjs" <run-id>`: the run's real cost, summed from the local Claude Code transcripts of every agent in the run and priced from the dated table in the script (no network). Its last lines are the run total and any agent it could not price. The number after `Run total:` is the cost; when the run cannot be found or every agent is unpriced, there is no cost. The workflow itself does not report cost; never estimate one. The Codex line after it, when present, is the Codex adversary's cost: pass its USD as --codex-cost <usd> to record and summary; it is never added to --cost.
 2. Classify every adversary block in the report. A block is a finding the adversary raised as a blocker (its ledger id, `F1`; for a report from before the ledger, `pass-<n>`); `board.mjs record` refuses an id the report does not have and lists the ones it has. This is judgment work and runs on the `review` row: read it with the `plan.mjs models` command, `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" models` (`roles.review.model`, `roles.review.effort`), and spawn `Agent({ subagent_type: "doug-flow:reviewer", model: "<review row model>", prompt: "There is no worktree and no diff for this job: read the report at <report path> (repository root, read-only) and classify every adversary block in it as real (a defect a user would hit), marginal (true to the spec, no user impact), or false (wrong), each with a one-line reason drawn from the fix passes and the checks in the report, not from the adversary's summary. Return exactly one line per block, nothing else: F1=<real|marginal|false>: <one-line reason> (pass-<n>=... for a pre-ledger report). Edit nothing." })`. The lead passes each returned line into `--adversary` verbatim and never reclassifies.
-3. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" record <id> <report.json> --wall "<m> min" --commit <sha> --cost <usd> [--codex-cost <usd>] --adversary "F1=<class>: <reason>"` with `--adversary` repeated once per block, leaving `--cost` out when step 1 gave no number and `--codex-cost` out when step 1 showed no Codex line. This appends the entry to `docs/live-runs.md`: the measures table with the precision line (n real / n marginal / n false), the per-level, per-task table, and one line per classified block. It also promotes `.doug/.state/research/<id>.md` to `docs/research/<id>.md` when that note exists, printing one line saying so; add that path to the landing commit alongside `docs/live-runs.md`.
+3. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" record <id> <report.json> --run <run-id> --wall "<m> min" --commit <sha> --cost <usd> [--codex-cost <usd>] --adversary "F1=<class>: <reason>"` with `--adversary` repeated once per block, leaving `--cost` out when step 1 gave no number and `--codex-cost` out when step 1 showed no Codex line. This appends the entry to `docs/live-runs.md`: the measures table with the precision line (n real / n marginal / n false), the per-level, per-task table, and one line per classified block. It also promotes `.doug/.state/research/<id>.md` to `docs/research/<id>.md` when that note exists, printing one line saying so; add that path to the landing commit alongside `docs/live-runs.md`.
 4. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" import`: rolls any auto-memory file written since the last import into the lessons store — it is idempotent, a rewritten file supersedes its old row, and it never writes under the auto-memory directory. Its one-line output goes in the chat; an exit 1 naming Node is said in the chat and the landing goes on, the same as record below.
 5. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" record <report.json> --run <run-id> --card <id> --commit <sha> --adversary "F1=<class>: <reason>"` with `--adversary` repeated once per block, the same values step 3 used, and `--commit` left out for a run that stopped. It appends one row per task of the report to the local outcome log `.doug/.state/memory/memory.db` (uncommitted; run id, card, spec hash, owned files from the plan, size, shape, models, verify and review results, the classified adversary blocks, fix passes, budget, tokens and USD measured from the same transcripts `cost.mjs` read, or null where nothing was measured). It needs Node >=22.16 (node:sqlite). When it exits 1 naming Node, say so in the chat and go on, since the record is a log, not a gate.
 6. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect <report.json> --run <run-id> --card <id> --commit <sha> --adversary "F1=<class>: <reason>"` with `--adversary` repeated once per block, the same values step 5 used. It applies deterministic helpful/harmful counters to any lesson a task's `memoryUsed` names, then runs a cheap-row `claude -p --json-schema` pass that proposes and appends at most three lessons from the report, filtered in code. Its one-line summary (with the measured cost) goes in the chat. An exit 1 naming the LLM pass is said in the chat and the landing goes on regardless — reflect is a log, not a gate, the same as record.
-7. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" summary <report.json> --wall "<m> min" --commit <sha> [--codex-cost <usd>]` (same `--cost` rule) and put its three lines in the chat verbatim, in a fenced code block: the outcome, the tasks, and what stopped or was not met.
+7. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" summary <report.json> --run <run-id> --wall "<m> min" --commit <sha> [--codex-cost <usd>]` (same `--cost` rule) and put its three lines in the chat verbatim, in a fenced code block: the outcome, the tasks, and what stopped or was not met.
 
 A run that stopped is recorded the same way, without `--commit`; the summary's third line quotes each task's stop reason.
 
@@ -28,24 +28,23 @@ When `.doug/plan.json` carries `cards` (made by `plan.mjs merge`), the run is re
 
 1. `node "${CLAUDE_PLUGIN_ROOT}/scripts/cost.mjs" <run-id> --by-card`: after the usual tables, a per-card table with each card's tasks' agents summed for that card and one row for the shared integration agents (the integrate and level-adversary agents, task `level-<n>`). The card rows are each card's `--cost`; the shared row is `--shared-cost`, the same number for every card. Pass the Codex line's USD as --codex-cost to the first card's record only.
 2. Classify the adversary blocks per card: `board.mjs record` lists only that card's tasks' blocks and refuses the others' ids.
-3. For each card, in the plan's `cards` order: `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" record <id> <report.json> --wall "<m> min" --commit <sha> --cost <that card's usd> --shared-cost <shared usd> [--codex-cost <usd>, first card only] --adversary ...`. Record reads the batch from the plan file: the entry names the other cards, shows only that card's tasks and the integration rows of their levels, and counts the shared cost once, under the first card.
+3. For each card, in the plan's `cards` order: `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" record <id> <report.json> --run <run-id> --wall "<m> min" --commit <sha> --cost <that card's usd> --shared-cost <shared usd> [--codex-cost <usd>, first card only] --adversary ...`. Record reads the batch from the plan file: the entry names the other cards, shows only that card's tasks and the integration rows of their levels, and counts the shared cost once, under the first card.
 4. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" import` once for the whole report, the same as the workflow-run form's step 4: its one-line output goes in the chat, an exit 1 naming Node is said in the chat and the landing goes on, and it is idempotent, a rewritten file supersedes its old row, and it never writes under the auto-memory directory.
 5. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" record <report.json> --run <run-id> --commit <sha> --adversary ...` once for the whole report, with every card's block classes (each task carries its card in a batch report; no `--card`).
 6. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect <report.json> --run <run-id> --commit <sha> --adversary ...` once for the whole report, no `--card` (each appended lesson's card comes from its own task).
-7. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" summary <report.json> --card <id> --wall "<m> min" --commit <sha>` per card (same `--cost` rule), and put each card's three lines in the chat. Its "Acceptance not met" line reads only that card's own tasks by their `[<card>] ` tag (or the final integration level's acceptance, when the report carries it), so another card's failing command, or a command that depends on a level not yet run, never shows as this card's; the line names which source it used.
+7. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" summary <report.json> --card <id> --run <run-id> --wall "<m> min" --commit <sha>` per card (same `--cost` rule), and put each card's three lines in the chat. Its "Acceptance not met" line reads only that card's own tasks by their `[<card>] ` tag (or the final integration level's acceptance, when the report carries it), so another card's failing command, or a command that depends on a level not yet run, never shows as this card's; the line names which source it used.
 
 ## A hand-track landing
 
-With the card id, the landing commit, the wall clock, and the gate line — one `<command> <exit>` clause per entry of `.doug/config.json` `stopGate.commands`, in that order, joined by `; ` (a test command may add its pass count in parentheses; Doug's own is `typecheck 0; test:unit 0 (<n> passed)`; a pytest project's might be `pytest 0`):
+With the card id, the landing commit, the wall clock, and the gate line — one `<command> <exit>` clause per entry of `.doug/config.json` `stopGate.commands`, in that order, joined by `; ` (a test command may add its pass count in parentheses; Doug's own is `typecheck 0; test:unit 0 (<n> passed)`; a pytest project's might be `pytest 0`). Step 4 alone also takes the coder rounds (how many until the reviewer passed) and the lead's classed reviewer blockers:
 
 1. `node "${CLAUDE_PLUGIN_ROOT}/scripts/board.mjs" record <id> --hand --commit <sha> --wall "<m> min" --gate "<gate line>"`, with `--note "<one line>"` when something about the build is worth keeping. This appends the hand-track entry to `docs/live-runs.md`; its table is the summary. It also promotes `.doug/.state/research/<id>.md` to `docs/research/<id>.md` when that note exists, printing one line saying so; add that path to the landing commit alongside `docs/live-runs.md`.
 2. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" import`, the same as above: its one-line output goes in the chat, an exit 1 naming Node is said in the chat and the landing goes on, and it is idempotent, supersedes a rewritten file, and never writes under the auto-memory directory.
 3. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" record <id> --hand --commit <sha> --wall "<m> min" --gate "<gate line>" [--note "<one line>"]`, the same values step 1 used. It records one row in the local outcome log `.doug/.state/memory/memory.db` (uncommitted), keyed `hand:<sha>` so re-recording the same commit updates that row and track `hand`; a card that lands twice, in two commits, gets two rows. Its workflow-only columns (verified, review counts, adversary verdict, blocks, fix passes, budget, tokens, USD, the report itself) are null because they do not exist on this track, never because they measured zero: no independent verifier ran, and the gate's own text is the `gate` column instead. It needs Node >=22.16 (node:sqlite). When it exits 1 naming Node, say so in the chat and go on, since the record is a log, not a gate.
-
-`memory.mjs reflect` does not run on a hand-track landing: there is no report for the cheap-row pass to read.
+4. `node "${CLAUDE_PLUGIN_ROOT}/scripts/memory.mjs" reflect --hand <id> --commit <sha> --rounds <n> [--review "R1=<class>: <reason>"]... [--note "<one line>"]`. It reads the briefs, reviewer reports and lessons.json doug-hand saved, applies helpful/harmful counters to the card's memoryUsed, proposes at most three lessons on the cheap row, filtered in code. Its one-line summary (with the measured cost) goes in the chat. An exit 1 naming the LLM pass is said in the chat and the landing goes on regardless — reflect is a log, not a gate, the same as record.
 
 Say the commit, the wall clock, and the gate line in the chat.
 
 ## Then
 
-Moving the card and committing the record and the log belong to the calling skill (`/doug-next` step 5, `/core-next` step 4); a record change shows on the served page (`doug board serve`).
+Moving the card and committing the record and the log belong to the calling skill (`/doug-next` step 5, doug-hand step 4); a record change shows on the served page (`doug board serve`).

package/node_modules/@dougharness/flow/skills/swarm-launch/SKILL.md

@@ -12,7 +12,7 @@ The swarm lives inside a plan task (decision 0001 as amended 2026-09-06): the pl
 
 1. `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" validate`: the plan must be `approved`. Nothing runs on a draft; approval is the user's act (`/doug-approve`), never this skill's.
 2. `node "${CLAUDE_PLUGIN_ROOT}/scripts/plan.mjs" show` prints `Swarm: on` when the plan opted in with `plan.mjs set swarm on`. Without it the same workflow runs the fixed pipeline; do not set it here on your own, because the opt-in is the user's (each swarm task spends a lead, N workers, and a merge instead of one implementer). The swarm pays on a task with independent deliverables that share no new symbol; a plan of small coupled tasks runs as the pipeline (`docs/decisions/0001-hierarchical-swarms.md`, Amendment 2026-09-20: one brief per task at +2.67 USD and +6.1 min against the pipeline on 2026-09-11; five briefs, 8/8 hidden tests, 8.31 USD, 8.5 min on 2026-09-19).
-3. The caller is a user-invoked skill or command (`/doug-implement`, `/doug-next`, `/doug-swarm`, `/core-next` for a size M or L hand-track card the user chose to swarm): that invocation is the opt-in the Workflow tool requires. No swarm runs in the background or on a schedule.
+3. The caller is a user-invoked skill or command (`/doug-implement`, `/doug-next`, `/doug-swarm`, doug-hand for a size M or L hand-track card the user chose to swarm): that invocation is the opt-in the Workflow tool requires. No swarm runs in the background or on a schedule.
 
 ## Launch
 

package/node_modules/@dougharness/flow/workflows/doug-implement.js

@@ -52,6 +52,9 @@ const taskBudget = { ...DEFAULT_BUDGET, ...(plan.budget && typeof plan.budget ==
 // The phrase the verifier and reviewer put at the start of a finding when the spec cannot satisfy the plan's
 // acceptance criteria. Such a block goes back to the planner and is never retried.
 const CONTRADICTION_MARKER = 'SPEC CONTRADICTS ACCEPTANCE'
+// Why a task stopped: every halt site sets one of these as stopClass beside its prose stopReason. Kept equal to
+// STOP_CLASSES in lib/board.mjs by a template test (this file may not import).
+const STOP_CLASSES = ['implementer-blocked', 'partial', 'stage-missing', 'spec-contradiction', 'environment', 'adversary-not-run', 'outside-owned', 'new-blockers-twice', 'fix-attempts-exhausted', 'stalled', 'budget', 'no-new-commit', 'dependency-skipped', 'stage-threw', 'level-adversary']
 // The phrase a verifier, checker, or size-check puts at the start of a finding when a command could not run for
 // an environment reason (a tool missing from the worktree even after the install step, a sandbox denial) rather
 // than a defect in the diff. The fix loop never retries such a finding (card reused-s-task-worktree-install):
@@ -284,8 +287,11 @@ const INTEGRATE_SCHEMA = {
     branch: { type: 'string' },
     merged: { type: 'array', items: { type: 'string' } },
     conflicts: { type: 'array', items: { type: 'string' } },
-    verify: { type: 'array', items: { type: 'object', required: ['command', 'ok'], properties: { command: { type: 'string' }, ok: { type: 'boolean' }, outputTail: { type: 'string' } } } },
+    verify: { type: 'array', items: { type: 'object', required: ['command', 'ok'], properties: { command: { type: 'string' }, ok: { type: 'boolean' }, outputTail: { type: 'string' }, credited: { type: 'string' } } } },
     ok: { type: 'boolean' },
+    // Card level-adversary-empty-diff: the integration branch's HEAD sha before this stage's merges; the level
+    // adversary diffs from it. Optional: a missing or malformed value falls back to the level's base branch.
+    baseCommit: { type: 'string' },
     // Card integration-acceptance-recorded: only the last level's integrate stage fills this in (step 3b of
     // integratePrompt); not required, since an earlier level has not built the whole plan yet.
     acceptance: { type: 'array', description: 'one entry per acceptance command listed in the prompt, [] when none', items: { type: 'object', required: ['text', 'command', 'ok', 'exitCode'], properties: { text: { type: 'string' }, command: { type: 'string' }, ok: { type: 'boolean' }, exitCode: { type: ['integer', 'null'] } } } },
@@ -300,7 +306,7 @@ const INTEGRATE_SCHEMA = {
 // (empty, prose, or unrecognised) is dropped rather than trusted or blamed. A plan command with no matching
 // report is appended as { ..., reported: false } - unreported and failed are different causes and get different
 // reason clauses. Pure: never mutates its argument, never throws on odd shapes.
-function enforceIntegrationAcceptance(integration, isLastLevel, entries) {
+function enforceIntegrationAcceptance(integration, isLastLevel, entries, verifyCommands = []) {
   if (!integration || typeof integration !== 'object') return integration
   if (!isLastLevel) {
     const rest = { ...integration }
@@ -309,10 +315,20 @@ function enforceIntegrationAcceptance(integration, isLastLevel, entries) {
   }
   const reported = Array.isArray(integration.acceptance) ? integration.acceptance.filter(a => a && typeof a === 'object') : []
   const acceptance = []
+  const verifyList = Array.isArray(integration.verify) ? integration.verify.filter(v => v && typeof v === 'object') : []
+  const repeated = new Set((Array.isArray(verifyCommands) ? verifyCommands : []).map(c => String(c).trim()))
   for (const e of entries) {
     if (!e.command) continue
     const wantCommand = String(e.command).trim()
     if (!wantCommand) continue
+    // Card flow-suite-dedupe: a command that repeats a plan.verify command takes its result from the verify item.
+    if (repeated.has(wantCommand)) {
+      const v = verifyList.find(x => typeof x.command === 'string' && String(x.command).trim() === wantCommand)
+      acceptance.push(v
+        ? { text: e.text, command: e.command, ok: v.ok === true, exitCode: v.ok === true ? 0 : null, from: 'verify' }
+        : { text: e.text, command: e.command, ok: false, exitCode: null, reported: false })
+      continue
+    }
     const match = reported.find(a => typeof a.command === 'string' && String(a.command).trim() === wantCommand)
     acceptance.push(match
       ? { text: match.text, command: e.command, ok: match.ok, exitCode: match.exitCode }
@@ -1212,10 +1228,9 @@ function levelSpecLines(sReady) {
 // codex-review over a level's size-S tasks on the integration branch, once, after the merge (and once more to confirm
 // a fix pass). Every blocker must name a file, because that is how it finds the task it goes back to.
 function levelAdversaryPrompt(li, sReady, levelBase, confirming) {
-  const verify = (plan.verify || []).filter(Boolean)
   const guard = t => String(t).replace(/^DOUG_SPEC_EOF$/gm, 'DOUG_SPEC_EOF ')
   const command = [
-    `cat <<'DOUG_SPEC_EOF' | ${adversary.command} --base ${shellQuote(levelBase)} --head ${shellQuote(integrationBranch)} --dir ${shellQuote(INTEGRATION_WORKTREE)} --spec - --timeout-ms ${adversary.timeoutMs}${typeof adversary.effort === 'string' && adversary.effort ? ` --effort ${adversary.effort}` : ''}${verify.map(v => ` --verify ${shellQuote(v)}`).join('')}`,
+    `cat <<'DOUG_SPEC_EOF' | ${adversary.command} --base ${shellQuote(levelBase)} --head ${shellQuote(integrationBranch)} --dir ${shellQuote(INTEGRATION_WORKTREE)} --spec - --timeout-ms ${adversary.timeoutMs}${typeof adversary.effort === 'string' && adversary.effort ? ` --effort ${adversary.effort}` : ''}`,
     `Level ${li} of plan "${guard(plan.title)}": the size-S tasks below were merged into ${integrationBranch} with one focused check each and no adversary of their own. Review them together against their specs. Every blocker must name the file it is about, so it can go back to the task that owns that file.`,
     ...(confirming ? [`A fix pass answered the blockers you raised on this level; confirm each one is fixed, name it as fixed or still open, and check the fix for regressions rather than exploring afresh.`] : [`This is the first review of this level: explore freely and try to refute the changes however you can.`]),
     ``,
@@ -1310,7 +1325,7 @@ function confirmationLines(pass, ledger, impl) {
 }
 
 function adversaryPrompt(task, impl, baseBranch, pass, ledger) {
-  const verify = [task.verify, ...(plan.verify || [])].filter(Boolean)
+  const verify = [task.verify].filter(Boolean)
   const guard = s => String(s).replace(/^DOUG_SPEC_EOF$/gm, 'DOUG_SPEC_EOF ')
   const command = [
     `cat <<'DOUG_SPEC_EOF' | ${adversary.command} --base ${shellQuote(baseBranch)} --head ${shellQuote(impl.branch)} --dir ${shellQuote(impl.worktreePath)} --spec - --timeout-ms ${adversary.timeoutMs}${typeof adversary.effort === 'string' && adversary.effort ? ` --effort ${adversary.effort}` : ''}${verify.map(v => ` --verify ${shellQuote(v)}`).join('')}`,
@@ -1417,14 +1432,26 @@ function integratePrompt(levelIndex, results, baseBranch, isLastLevel, keepWorkt
         `   if it exists (a previous level made it): use it as is; it already has ${integrationBranch} checked out.`,
       ]),
     `   Do every following git and verify command inside that worktree (git -C or cd into it).`,
+    `   Before any merge of this stage, run git rev-parse HEAD in that worktree and report the full 40-character sha as baseCommit.`,
     `2. Merge each branch with a merge commit (git merge --no-ff <branch>). If a merge conflicts, resolve it only if the resolution is mechanical and obviously correct; otherwise git merge --abort and list the branch in conflicts. ${NO_TRAILERS} That includes the merge commits you make here.`,
     `3. Install dependencies there if the verify commands need them and they are missing${plan.install ? ` (${plan.install})` : ''}. Then run every command in: ${plan.verify.length ? plan.verify.map(v => `"${v}"`).join(', ') : 'the project test command'} and record real exit statuses.`,
+    ...(plan.verify.length
+      ? [
+        `   When .doug/hooks/scripts/verify.mjs exists, run them from the repository root (not inside the worktree) as one command, so a tree already verified is credited instead of re-run:`,
+        `   node .doug/hooks/scripts/verify.mjs --json --by integrate --cwd .claude/worktrees/doug-integration --record-dir . ${worktrees.map(w => `--credit-dir ${shellQuote(w)}`).join(' ')} ${plan.verify.map(v => `--command ${shellQuote(v)}`).join(' ')}`,
+        `   Copy each entry of its JSON results[] into verify as { command, ok, outputTail }, and add credited: "verified-tree" to each when the JSON's credited is not null. When verify.mjs does not exist, run the commands one by one as above.`,
+      ]
+      : []),
     // Card integration-acceptance-recorded: only the last level runs the plan's acceptance commands, and only
     // after the merges above - the plan is not complete at an earlier level, so its prompt never mentions this.
     ...(isLastLevel
       ? [
         `3b. Plan acceptance criteria (a line starting with $ is the command that checks the criterion above it and exits 0 when it holds; the plan is complete at this level, so run every one now):`,
-        ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
+        ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command
+          ? ((plan.verify || []).some(v => String(v).trim() === String(a.command).trim())
+            ? [`- ${a.text} is checked by step 3's \`${a.command}\`; do not run it again and do not report it in acceptance; the workflow takes its result from verify.`]
+            : [`- ${a.text}`, `  $ ${a.command}`])
+          : [`- ${a.text}`]),
         `Run every $ command above inside this integration worktree, exactly as written, after the merges, and report each one in \`acceptance\` as { text, command, ok, exitCode } with its real exit code (ok means exit code 0; exitCode null only if the command could not start). Never report one you did not run; return acceptance: [] when the plan lists no commands.`,
         `Report each command string exactly as it is written above, character for character, even when you ran it behind a cd or git -C prefix: the workflow matches your report to the plan by that string, and a command it cannot match counts as not run and fails the integration.`,
         `A criterion with no $ line is not yours to judge here: do not report it.`,
@@ -1441,8 +1468,8 @@ function integratePrompt(levelIndex, results, baseBranch, isLastLevel, keepWorkt
 // ---- Task loop -------------------------------------------------------------------
 // One task from start to a verdict: implement (or check out a reused branch), then verify, review and the
 // adversary. While the block is one the checks described inside the task's own files, relaunch the implementer in
-// the same worktree; a fix pass reruns the stage that blocked, then one focused check, then the adversary, and the
-// loop stops as soon as it stops converging (no new commit, two consecutive novel blockers, or the task budget).
+// the same worktree; a fix pass reruns the verifier or reviewer that blocked, then one focused check and the
+// adversary together, and the loop stops as soon as it stops converging (no new commit, two consecutive novel blockers, or the task budget).
 async function startTask(task, baseBranch, launch = agent) {
   if (task.reuse) return launch(reusePrompt(task, baseBranch), { label: `reuse:${task.id}`, phase: 'Implement', isolation: 'worktree', schema: IMPLEMENT_SCHEMA, model: CHECKOUT_MODEL })
   if (swarmApplies(task)) return runSwarm(task, baseBranch, launch)
@@ -1790,27 +1817,27 @@ function ownedBySibling(task, p) {
 
 // Can this block be fixed by the same implementer, or must a human see it?
 function retriable(task, r) {
-  if (!r.impl) return { ok: false, reason: 'implementer returned nothing' }
+  if (!r.impl) return { ok: false, reason: 'implementer returned nothing', stopClass: 'stage-missing' }
   // A fix pass that returned no structured result changed nothing the loop knows of: the branch and worktree it
   // had are still there, so the same implementer is asked again.
   if (r.noResult) return { ok: true, reason: r.noResult }
-  if (r.impl.blocked) return { ok: false, reason: `implementer blocked: ${r.impl.blockedReason || 'no reason given'}` }
+  if (r.impl.blocked) return { ok: false, reason: `implementer blocked: ${r.impl.blockedReason || 'no reason given'}`, stopClass: 'implementer-blocked' }
   // A partial result is not a check failure, whether it came from the initial worker's one resume or from a fix
   // pass: the fix loop never retries it (card worker-context-handoff).
-  if (r.impl.partial) return { ok: false, reason: 'a partial result is not retried by the fix loop' }
+  if (r.impl.partial) return { ok: false, reason: 'a partial result is not retried by the fix loop', stopClass: 'partial' }
   // Only a stage that actually ran can be missing; a fix pass deliberately skips the stages that did not block.
   const ran = r.stages || []
-  if (ran.includes('verify') && !r.ver) return { ok: false, reason: 'verifier returned nothing' }
-  if (ran.includes('review') && !r.rev) return { ok: false, reason: 'reviewer returned nothing' }
-  if (ran.includes('check') && !r.check) return { ok: false, reason: 'check returned nothing' }
+  if (ran.includes('verify') && !r.ver) return { ok: false, reason: 'verifier returned nothing', stopClass: 'stage-missing' }
+  if (ran.includes('review') && !r.rev) return { ok: false, reason: 'reviewer returned nothing', stopClass: 'stage-missing' }
+  if (ran.includes('check') && !r.check) return { ok: false, reason: 'check returned nothing', stopClass: 'stage-missing' }
   const texts = [...((r.ver && r.ver.findings) || []), ...(((r.rev && r.rev.issues) || []).map(i => i.description))]
   const contradiction = texts.find(t => typeof t === 'string' && t.includes(CONTRADICTION_MARKER))
-  if (contradiction) return { ok: false, reason: `spec contradicts acceptance: ${contradiction}` }
+  if (contradiction) return { ok: false, reason: `spec contradicts acceptance: ${contradiction}`, stopClass: 'spec-contradiction' }
   const environmentOnly = texts.find(t => typeof t === 'string' && t.includes(ENVIRONMENT_MARKER))
-  if (environmentOnly) return { ok: false, reason: `environment, not the code: ${environmentOnly}` }
-  if (adversary && r.adv && !r.adv.ran) return { ok: false, reason: `adversary did not run: ${r.adv.error || 'no reason given'}` }
+  if (environmentOnly) return { ok: false, reason: `environment, not the code: ${environmentOnly}`, stopClass: 'environment' }
+  if (adversary && r.adv && !r.adv.ran && !r.blockingStage) return { ok: false, reason: `adversary did not run: ${r.adv.error || 'no reason given'}`, stopClass: 'adversary-not-run' }
   const outside = [...new Set(findingPaths(r).filter(p => !ownsPath(task, p) && !ownedBySibling(task, p)))]
-  if (outside.length) return { ok: false, reason: `findings name files outside the owned set: ${outside.join(', ')}` }
+  if (outside.length) return { ok: false, reason: `findings name files outside the owned set: ${outside.join(', ')}`, stopClass: 'outside-owned' }
   return { ok: true, reason: 'every finding is within the owned files' }
 }
 
@@ -2094,9 +2121,9 @@ function stageHead(ver, check) {
 }
 
 // baseBranch is a parameter, not the outer binding, so this block can be built and exercised on its own.
-// ctx: { ledger, launch, lead, prevCommit, blocking }. On pass 1 the verifier and the reviewer both run and the
-// adversary follows when both passed. On a fix pass only the stage that blocked reruns, then the focused check,
-// then the adversary; the first stage that blocks ends the pass.
+// ctx: { ledger, launch, lead, prevCommit, blocking }. On pass 1 the verifier, the reviewer, and the adversary run
+// together. On a fix pass the verifier or the reviewer reruns first when it is the stage that blocked, and ends the
+// pass if it blocks again; then the focused check and the adversary run together.
 async function runChecks(task, impl, pass, baseBranch, ctx) {
   const c = ctx || {}
   const ledger = c.ledger || []
@@ -2117,57 +2144,68 @@ async function runChecks(task, impl, pass, baseBranch, ctx) {
     if (check) ({ ver, rev } = readCheck(check))
     blockingStage = !(check && check.passed && rev && rev.approve) ? 'check' : null
   } else if (pass === 1) {
-    // The verifier and the reviewer are both read-only and neither reads the other's result, so a first pass
-    // launches them together; a null from either (skipped, or dead after retries) is that stage returning nothing.
+    // The verifier, the reviewer, and the adversary are read-only and none reads another's result, so a first pass
+    // launches them together; a null from any (skipped, or dead after retries) is that stage returning nothing.
     stages.push('verify')
     stages.push('review')
     const crew = crewOf(task)
     for (let seat = 2; seat <= crew.reviewers; seat++) stages.push(`review-${seat}`)
+    const withAdversary = adversaryRequired(task)
+    const advStages = []
     const pair = await parallel([
       () => launch(verifyPrompt(task, impl, baseBranch), agentOpts('verify', task, { label: `verify:${task.id}`, phase: 'Verify', agentType: 'doug-flow:verifier', schema: VERIFY_SCHEMA })),
       () => launch(reviewPrompt(task, impl, baseBranch), agentOpts('review', task, { label: `review:${task.id}`, phase: 'Review', agentType: 'doug-flow:reviewer', schema: REVIEW_SCHEMA })),
       ...Array.from({ length: crew.reviewers - 1 }, (_, i) => () => launch(reviewPrompt(task, impl, baseBranch, i + 2), agentOpts('review', task, { label: `review-${i + 2}:${task.id}`, phase: 'Review', agentType: 'doug-flow:reviewer', schema: REVIEW_SCHEMA }))),
+      ...(withAdversary ? [() => runAdversaryCrew(task, impl, pass, baseBranch, ledger, launch, advStages)] : []),
     ])
     ver = (pair && pair[0]) || null
-    rev = pair ? mergeReviews(pair.slice(1)) : null
+    rev = pair ? mergeReviews(pair.slice(1, 1 + crew.reviewers)) : null
     stageResults.verify = ver
     stageResults.review = rev
-    // Only changes that already passed verification and review are worth a second model's time.
-    if (adversary && ver && ver.passed && rev && rev.approve) {
-      adv = await runAdversaryCrew(task, impl, pass, baseBranch, ledger, launch, stages)
+    // The adversary no longer waits for verify and review (card flow-adversary-parallel, 2026-10-07): waiting
+    // added about five minutes to every full task. The cost is a Codex review of trees verify or review rejects;
+    // integration still needs all three verdicts (isReady), and the ledger reads each stage's findings.
+    if (withAdversary) {
+      stages.push(...advStages)
+      adv = (pair && pair[1 + crew.reviewers]) || null
       stageResults.adversary = adv
     }
     blockingStage = !(ver && ver.passed) ? 'verify' : !(rev && rev.approve) ? 'review' : adversaryBlocked(adv) ? 'adversary' : null
   } else {
     const first = c.blocking || 'verify'
-    const order = [first, ...['check', 'adversary'].filter(s => s !== first)]
-    for (const stage of order) {
-      if (stage === 'adversary' && !adversaryRequired(task)) continue
-      if (stage === 'verify') {
-        stages.push('verify')
-        ver = await launch(verifyPrompt(task, impl, baseBranch), agentOpts('verify', task, { label: `verify:${task.id}${suffix}`, phase: 'Verify', agentType: 'doug-flow:verifier', schema: VERIFY_SCHEMA }))
-        stageResults.verify = ver
-        if (!(ver && ver.passed)) { blockingStage = 'verify'; break }
-      } else if (stage === 'review') {
-        stages.push('review')
-        const crew = crewOf(task)
-        for (let seat = 2; seat <= crew.reviewers; seat++) stages.push(`review-${seat}`)
-        const seats = await parallel(Array.from({ length: crew.reviewers }, (_, i) => () => launch(reviewPrompt(task, impl, baseBranch, i + 1), agentOpts('review', task, { label: `review${i ? `-${i + 1}` : ''}:${task.id}${suffix}`, phase: 'Review', agentType: 'doug-flow:reviewer', schema: REVIEW_SCHEMA }))))
-        rev = mergeReviews(seats || [])
-        stageResults.review = rev
-        if (!(rev && rev.approve)) { blockingStage = 'review'; break }
-      } else if (stage === 'check') {
-        stages.push('check')
-        check = await launch(checkPrompt(task, impl, c.prevCommit || null, baseBranch, ledger), agentOpts('verify', task, { label: `check:${task.id}:${pass}`, phase: 'Verify', agentType: 'doug-flow:verifier', schema: CHECK_SCHEMA }))
-        stageResults.check = check
-        // The one check stands in for both stages, so the rest of the loop and the report read it as they read them.
-        if (check) ({ ver, rev } = readCheck(check))
-        if (!(check && check.passed && rev && rev.approve)) { blockingStage = 'check'; break }
-      } else {
-        adv = await runAdversaryCrew(task, impl, pass, baseBranch, ledger, launch, stages)
-        stageResults.adversary = adv
-        if (!adversaryOk(adv, !!adversary)) { if (adversaryBlocked(adv)) blockingStage = 'adversary'; break }
-      }
+    if (first === 'verify') {
+      stages.push('verify')
+      ver = await launch(verifyPrompt(task, impl, baseBranch), agentOpts('verify', task, { label: `verify:${task.id}${suffix}`, phase: 'Verify', agentType: 'doug-flow:verifier', schema: VERIFY_SCHEMA }))
+      stageResults.verify = ver
+      if (!(ver && ver.passed)) blockingStage = 'verify'
+    } else if (first === 'review') {
+      stages.push('review')
+      const crew = crewOf(task)
+      for (let seat = 2; seat <= crew.reviewers; seat++) stages.push(`review-${seat}`)
+      const seats = await parallel(Array.from({ length: crew.reviewers }, (_, i) => () => launch(reviewPrompt(task, impl, baseBranch, i + 1), agentOpts('review', task, { label: `review${i ? `-${i + 1}` : ''}:${task.id}${suffix}`, phase: 'Review', agentType: 'doug-flow:reviewer', schema: REVIEW_SCHEMA }))))
+      rev = mergeReviews(seats || [])
+      stageResults.review = rev
+      if (!(rev && rev.approve)) blockingStage = 'review'
+    }
+    if (!blockingStage) {
+      // The focused check and the adversary are both read-only, so they run together (card flow-adversary-parallel).
+      // The stages are recorded in the order the serial loop ran them (the adversary first when it blocked the last
+      // pass), since updateLedger reads them in order to tell a stage confirming a fix from one re-reporting it.
+      const withAdversary = adversaryRequired(task)
+      const adversaryFirst = withAdversary && first === 'adversary'
+      const advStages = []
+      const runCheck = () => launch(checkPrompt(task, impl, c.prevCommit || null, baseBranch, ledger), agentOpts('verify', task, { label: `check:${task.id}:${pass}`, phase: 'Verify', agentType: 'doug-flow:verifier', schema: CHECK_SCHEMA }))
+      const runAdv = () => runAdversaryCrew(task, impl, pass, baseBranch, ledger, launch, advStages)
+      const both = !withAdversary ? [await runCheck()] : await parallel(adversaryFirst ? [runAdv, runCheck] : [runCheck, runAdv])
+      check = (both && both[adversaryFirst ? 1 : 0]) || null
+      stageResults.check = check
+      // The one check stands in for both stages, so the rest of the loop and the report read it as they read them.
+      if (check) ({ ver, rev } = readCheck(check))
+      if (withAdversary) { adv = (both && both[adversaryFirst ? 0 : 1]) || null; stageResults.adversary = adv }
+      stages.push(...(adversaryFirst ? [...advStages, 'check'] : ['check', ...advStages]))
+      const checkBlocked = !(check && check.passed && rev && rev.approve)
+      const advBlocked = withAdversary && adversaryBlocked(adv)
+      blockingStage = adversaryFirst && advBlocked ? 'adversary' : checkBlocked ? 'check' : advBlocked ? 'adversary' : null
     }
   }
   const head = stageHead(ver, check)
@@ -2338,20 +2376,20 @@ async function runTask(task, baseBranch, resume) {
     })
     // The last supervisor that ran on this task, for the report; null when none did.
     const lastSupervisor = () => { for (let i = attempts.length - 1; i >= 0; i--) if (attempts[i].supervisor) return attempts[i].supervisor; return null }
-    if (ready) return { ...r, attempts, ledger, budget: budgetOf(), stopReason: null, supervisor: lastSupervisor() }
+    if (ready) return { ...r, attempts, ledger, budget: budgetOf(), stopReason: null, stopClass: null, supervisor: lastSupervisor() }
     const why = notReadyWhy(r)
-    const halt = reason => {
+    const halt = (stopClass, reason) => {
       for (const e of ledger) if (e.status === 'open') log(`${task.id} open finding ${e.id} [${e.stage}] ${e.file || '(no file)'}: ${String(e.description).slice(0, 120)}`)
-      return { ...r, attempts, ledger, budget: budgetOf(), stopReason: reason, supervisor: lastSupervisor() }
+      return { ...r, attempts, ledger, budget: budgetOf(), stopReason: reason, stopClass, supervisor: lastSupervisor() }
     }
-    if (!decision.ok) return halt(`${why}; not retried: ${decision.reason}`)
+    if (!decision.ok) return halt(decision.stopClass, `${why}; not retried: ${decision.reason}`)
     // Two passes in a row that each raise a blocker nobody had seen means the checks are exploring, not converging.
     const last = attempts[attempts.length - 1]
     const prior = attempts[attempts.length - 2]
     if (prior && last.newFindings.length && prior.newFindings.length) {
-      return halt(`${why}; stopped: two consecutive passes raised new blockers (${prior.newFindings.join(', ')}; ${last.newFindings.join(', ')})`)
+      return halt('new-blockers-twice', `${why}; stopped: two consecutive passes raised new blockers (${prior.newFindings.join(', ')}; ${last.newFindings.join(', ')})`)
     }
-    if (attempts.length > fixAttempts) return halt(`${why}; fix attempts exhausted (${fixAttempts} of ${fixAttempts})`)
+    if (attempts.length > fixAttempts) return halt('fix-attempts-exhausted', `${why}; fix attempts exhausted (${fixAttempts} of ${fixAttempts})`)
     // The supervisor (card fix-loop-supervisor): before a fix pass after the first, when the stall signals fire. A
     // pass that returned no result attacked nothing, so it is not a stall. A task stalled a second time stops here
     // instead of spending the remaining fix budget; otherwise the supervisor runs after the budget check below, on
@@ -2362,7 +2400,7 @@ async function runTask(task, baseBranch, resume) {
     if (signals.length && attempts.some(a => a.supervisor && a.supervisor.stalled)) {
       const findings = [...new Set(signals.filter(x => x.kind === 'repeat').map(x => x.finding))]
       lastAttempt.supervisor = { ran: false, stalled: true, brief: null, signals, stop: { kind: 'stalled', attempts: attempts.length, findings } }
-      return halt(`${why}; stopped: stalled twice (${describeStall(signals)})`)
+      return halt('stalled', `${why}; stopped: stalled twice (${describeStall(signals)})`)
     }
     const blocking = r.blockingStage || 'verify'
     // What the next pass would cost: the fix agent plus the stages rule 3 would run. The adversary stage spends two
@@ -2391,7 +2429,7 @@ async function runTask(task, baseBranch, resume) {
       const projected = spent.elapsedMs + spent.elapsedMs / passesDone
       if (projected > limit) over = `elapsedMs ${show(projected)} > ${limit}`
     }
-    if (over) return halt(`${why}; stopped: next attempt would exceed the task budget (${over})`)
+    if (over) return halt('budget', `${why}; stopped: next attempt would exceed the task budget (${over})`)
     const pass = r.pass + 1
     let brief = null
     if (signals.length) {
@@ -2447,7 +2485,7 @@ async function runTask(task, baseBranch, resume) {
       r = record({ task, impl, ver: null, rev: null, adv: null, check: null, pass, stages: ['fix'], stageResults: {}, blockingStage: null, commit: fix.commit || null }, prevCommit)
       const decided = fixBlocked ? retriable(task, r) : null
       attempts.push({ pass, stages: ['fix'], commit: r.commit, blockingStage: null, verified: false, reviewed: false, adversary: null, newFindings: r.newFindings || [], fixedFindings: r.fixedFindings || [], notes: r.droppedFindings || [], ready: false, retriable: decided, spent: measure(), commands: passCommands(r) })
-      return halt(fixBlocked ? `${notReadyWhy(r)}; not retried: ${decided.reason}` : `${why}; stopped: fix pass ${pass} made no new commit on ${impl.branch}`)
+      return fixBlocked ? halt(decided.stopClass, `${notReadyWhy(r)}; not retried: ${decided.reason}`) : halt('no-new-commit', `${why}; stopped: fix pass ${pass} made no new commit on ${impl.branch}`)
     }
     const next = { ...fix, branch: r.impl.branch, worktreePath, prevCommit, ...(r.impl.workers ? { workers: r.impl.workers, swarmStages: r.impl.swarmStages, splitReason: r.impl.splitReason, rebrief: r.impl.rebrief, checkFailed: r.impl.checkFailed } : {}) }
     r = record(await runChecks(task, next, pass, baseBranch, { ledger, launch, lead: 'fix', prevCommit, blocking }), prevCommit)
@@ -2507,7 +2545,7 @@ for (let li = 0; li < levels.length; li++) {
     }
     const reason = missing.length > 1 ? `dependencies ${missing.join(', ')} were not integrated` : `dependency ${missing[0]} was not integrated`
     log(`${t.id} not launched: ${reason}`)
-    skipped.set(t, { task: t, impl: null, ver: null, rev: null, adv: null, check: null, attempts: [], ledger: [], budget: null, stages: [], stopReason: reason, skippedReason: reason })
+    skipped.set(t, { task: t, impl: null, ver: null, rev: null, adv: null, check: null, attempts: [], ledger: [], budget: null, stages: [], stopReason: reason, stopClass: 'dependency-skipped', skippedReason: reason })
   }
 
   // Implement (or reuse) -> verify -> review -> adversary -> fix, per task, no barrier between tasks.
@@ -2523,7 +2561,7 @@ for (let li = 0; li < levels.length; li++) {
   // was ever made; blocked:true keeps `implemented` false so reusePlan still refuses to reuse it.
   const threwFallback = task => {
     const reason = 'task stage threw (agent error, unknown agent type, or user skip)'
-    return { task, impl: { taskId: task.id, branch: task.reuse || `doug/task-${task.id}`, worktreePath: '', filesTouched: [], commandsRun: [], summary: reason, blocked: true, blockedReason: reason, commit: null }, ver: null, rev: null, adv: null, check: null, attempts: [], ledger: [], budget: null, stopReason: reason }
+    return { task, impl: { taskId: task.id, branch: task.reuse || `doug/task-${task.id}`, worktreePath: '', filesTouched: [], commandsRun: [], summary: reason, blocked: true, blockedReason: reason, commit: null }, ver: null, rev: null, adv: null, check: null, attempts: [], ledger: [], budget: null, stopReason: reason, stopClass: 'stage-threw' }
   }
   const byTask = new Map(runnable.map((task, i) => [task, results[i] || threwFallback(task)]))
   const ready = level.map(task => byTask.get(task) || skipped.get(task)).filter(isReady)
@@ -2537,7 +2575,7 @@ for (let li = 0; li < levels.length; li++) {
   const levelBase = baseBranch
   const sReady = adversary ? ready.filter(r => taskShape(r.task) === 'S') : []
   if (ready.length) {
-    integration = enforceIntegrationAcceptance(await retryOnce(integratePrompt(li, ready, baseBranch, li === levels.length - 1, sReady.length > 0, !integratedOnce), agentOpts('integrate', null, { label: `integrate:level-${li}`, phase: 'Integrate', schema: INTEGRATE_SCHEMA }), `level-${li}`), li === levels.length - 1, acceptanceEntries(plan.acceptance || []))
+    integration = enforceIntegrationAcceptance(await retryOnce(integratePrompt(li, ready, baseBranch, li === levels.length - 1, sReady.length > 0, !integratedOnce), agentOpts('integrate', null, { label: `integrate:level-${li}`, phase: 'Integrate', schema: INTEGRATE_SCHEMA }), `level-${li}`), li === levels.length - 1, acceptanceEntries(plan.acceptance || []), plan.verify || [])
     integratedOnce = true
     if (integration && integration.ok) {
       baseBranch = integrationBranch
@@ -2548,7 +2586,12 @@ for (let li = 0; li < levels.length; li++) {
   // branch, after the merge. A blocker goes back to the task that owns its file as a fix pass, the fixed branches are
   // merged again, and the adversary confirms once; a level still blocked after that stops the run.
   if (integration && integration.ok && sReady.length) {
-    levelAdversary = await runLevelAdversary(li, sReady, levelBase, false)
+    // Card level-adversary-empty-diff: the sha the integrator read before the level's first merge is the diff base;
+    // the branch name would equal --head on every level >= 1. The re-integration never replaces it.
+    const reportedBase = integration && integration.baseCommit
+    const adversaryBase = typeof reportedBase === 'string' && /^[0-9a-f]{40}$/.test(reportedBase) ? reportedBase : levelBase
+    if (adversaryBase === levelBase) log(`level ${li} level adversary falls back to ${levelBase} because the integrator reported no base commit`)
+    levelAdversary = await runLevelAdversary(li, sReady, adversaryBase, false)
     if (levelAdversary.blocked) {
       const blockers = levelAdversary.issues.filter(i => i.severity === 'blocker')
       const items = blockers.length ? blockers : [{ severity: 'blocker', file: '', description: levelAdversary.summary || 'the level adversary blocked without an issue', evidence: null }]
@@ -2570,25 +2613,28 @@ for (let li = 0; li < levels.length; li++) {
           const adv = { ran: true, verdict: 'fail', summary: levelAdversary.summary, issues, commandsRun: levelAdversary.commandsRun, error: null }
           const again = await runTask(r.task, levelBase, { impl: r.impl, ver: r.ver, rev: r.rev, adv, commit: r.commit, pass: r.pass, attempts: r.attempts, ledger: r.ledger })
           byTask.set(r.task, again)
-          levelAdversary.fixed.push({ task: r.task.id, ready: isReady(again), stopReason: again.stopReason })
+          levelAdversary.fixed.push({ task: r.task.id, ready: isReady(again), stopReason: again.stopReason, stopClass: again.stopClass || null })
         }
         const fixedReady = [...perTask.keys()].map(r => byTask.get(r.task)).filter(isReady)
         if (fixedReady.length === perTask.size) {
-          const again = enforceIntegrationAcceptance(await retryOnce(integratePrompt(li, fixedReady, levelBase, li === levels.length - 1, true, false), agentOpts('integrate', null, { label: `integrate:level-${li}:2`, phase: 'Integrate', schema: INTEGRATE_SCHEMA }), `level-${li}`), li === levels.length - 1, acceptanceEntries(plan.acceptance || []))
+          const again = enforceIntegrationAcceptance(await retryOnce(integratePrompt(li, fixedReady, levelBase, li === levels.length - 1, true, false), agentOpts('integrate', null, { label: `integrate:level-${li}:2`, phase: 'Integrate', schema: INTEGRATE_SCHEMA }), `level-${li}`), li === levels.length - 1, acceptanceEntries(plan.acceptance || []), plan.verify || [])
           levelAdversary.reintegration = again
           // The re-integration is the final state of the branch, so its acceptance (not the first integration's)
           // is what the level report carries (card integration-acceptance-recorded, behaviour 4). Only
           // `acceptance` is copied onto the level's `integration`; a failed re-integration's own `ok` and
           // `reason` stay on `levelAdversary.reintegration`, not on the level report.
           if (integration && li === levels.length - 1 && again && typeof again === 'object') integration.acceptance = again.acceptance
-          if (again && again.ok) levelAdversary.confirm = await runLevelAdversary(li, sReady.map(r => byTask.get(r.task) || r), levelBase, true)
+          if (again && again.ok) levelAdversary.confirm = await runLevelAdversary(li, sReady.map(r => byTask.get(r.task) || r), adversaryBase, true)
         }
       }
       const cleared = !!(levelAdversary.confirm && !levelAdversary.confirm.blocked)
       if (!cleared) {
         for (const r of new Set([...sReady, ...perTask.keys()])) {
           const cur = byTask.get(r.task) || r
-          if (!cur.stopReason) cur.stopReason = levelAdversary.unowned ? `level adversary blocked on ${levelAdversary.unowned.join(', ')}: ${levelAdversary.summary}` : levelAdversary.confirm ? `level adversary still blocked after a fix pass: ${levelAdversary.confirm.summary}` : levelAdversary.reintegration ? 'the fixed branches did not integrate again' : `level adversary blocked: ${levelAdversary.summary}`
+          if (!cur.stopReason) {
+            cur.stopReason = levelAdversary.unowned ? `level adversary blocked on ${levelAdversary.unowned.join(', ')}: ${levelAdversary.summary}` : levelAdversary.confirm ? `level adversary still blocked after a fix pass: ${levelAdversary.confirm.summary}` : levelAdversary.reintegration ? 'the fixed branches did not integrate again' : `level adversary blocked: ${levelAdversary.summary}`
+            cur.stopClass = 'level-adversary'
+          }
           byTask.set(r.task, cur)
         }
         for (const r of ready) integrated.delete(r.task.id)
@@ -2642,6 +2688,7 @@ for (let li = 0; li < levels.length; li++) {
       attempts: r.attempts,
       passes: r.attempts.length,
       stopReason: r.stopReason,
+      stopClass: r.stopClass || null,
       // The fix-loop supervisor's last word on the task: ran, stalled, the brief it injected, and the stop when the
       // task stalled twice ({ kind: 'stalled', attempts, findings }); null when the loop never stalled.
       supervisor: r.supervisor || null,

package/node_modules/@dougharness/gates/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "doug-gates",
   "displayName": "Doug Gates",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Deterministic guardrails for Claude Code: protected paths, bash guard, secret scan on edits and commands, format on edit, edit-loop detection, a verification gate on Stop and on SubagentStop, a snapshot of the plan and session into the anchor before compaction and re-anchoring after it, and a run trace of subagents and tool calls. Configured by .doug/config.json.",
   "author": {
     "name": "Doug contributors"

package/node_modules/@dougharness/gates/hooks/hooks.json

@@ -110,6 +110,17 @@
         ]
       }
     ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/turn-start.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
     "SessionStart": [
       {
         "matcher": "compact|resume",