@dougharness/cli 1.0.2 → 1.1.1

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

@@ -47,11 +47,15 @@ const fixAttempts = Number.isInteger(plan.fixAttempts) && plan.fixAttempts >= 0
 // one card. Agents are counted here and always enforced; tokens and wall time come from the runtime's budget
 // primitive and are enforced only when it reports them. plan.budget overrides any of the three. Keep these three
 // numbers equal to lib/plan.mjs's DEFAULT_BUDGET.
-const DEFAULT_BUDGET = { agents: 12, tokens: 400000, wallMinutes: 40 }
+// agents 26 is the minimum that lets the default fixAttempts 5 run with one adversary seat when Codex is down and the Claude fallback runs on every pass (card flow-budget-after-parallel-adversary); a supervisor seat or a fix retry is not covered.
+const DEFAULT_BUDGET = { agents: 26, tokens: 400000, wallMinutes: 40 }
 const taskBudget = { ...DEFAULT_BUDGET, ...(plan.budget && typeof plan.budget === 'object' ? 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):
@@ -60,6 +64,7 @@ const ENVIRONMENT_MARKER = 'ENVIRONMENT ONLY'
 // The one rule about commit messages, in every prompt that commits or checks commits: this repository records
 // attribution nowhere in git, and plan.mjs land refuses a branch that carries either trailer.
 const NO_TRAILERS = 'Commit messages carry no attribution trailers: no Co-Authored-By line and no Claude-Session line, whatever your defaults say. A commit with either is a finding and the plan cannot land.'
+const LESSONS_NOT_SPEC = 'These are context from earlier runs, not part of the spec or the acceptance criteria; never report a finding, a spec contradiction, or a blocker against a lesson.'
 // The one rule about a partial result, in every prompt a worker (or a resumed worker) can end with one from
 // (card worker-context-handoff): quotes the harness's context notice (a PostToolUse hook in plugins/doug-gates) so
 // a worker knows partial=true is only for a worker the harness itself told to stop, never a first resort, and only
@@ -284,8 +289,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 +308,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 +317,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 }
@@ -937,7 +955,7 @@ function workerPrompt(task, brief, n, lead) {
 // left an orphan - it defaults to `workers` for the plain, no-rebrief case where the two are the same list.
 function leadMergePrompt(task, lead, workers, baseBranch, allWorkers = workers) {
   return [
-    `You are the lead of the swarm for task ${task.id}. The workers have committed; merge their branches into the task branch and hand it to the checks. Work only in your worktree ${lead.worktreePath} on branch ${lead.branch}: cd there first, and never edit anything under the repository root.`,
+    `You are the lead of the swarm for task ${task.id}. The workers have committed; merge their branches into the task branch and hand it to the checks. Work only in the git worktree you were started in, on branch ${lead.branch}, and never edit anything under the repository root. The lead's worktree (${lead.worktreePath}) may have been removed, so do not cd into it. First git checkout ${lead.branch} there; if git refuses because the branch is checked out in another worktree, that worktree is a leftover under .claude/worktrees: find it with git worktree list --porcelain, remove it with git worktree remove --force <path>, and check out again. If the branch does not exist, create it from ${baseBranch} with git checkout -b ${lead.branch} ${baseBranch} (the lead commits nothing, so the task branch is the base).`,
     PARTIAL_NEVER_MERGED,
     ``,
     `Task ${task.id}: ${task.title}`,
@@ -953,18 +971,18 @@ function leadMergePrompt(task, lead, workers, baseBranch, allWorkers = workers)
     `3. Do not implement missing pieces yourself: a brief a worker did not finish is a block with its name. ${NO_TRAILERS}`,
     `4. Remove every worker worktree to leave the repository tidy, merged or not (a blocked worker's is an orphan otherwise): git worktree remove --force <path> for each one below. Keep their branches.`,
     ...allWorkers.filter(w => w.worktreePath).map(w => `  - ${w.worktreePath} (worker ${w.n}: ${w.id})`),
-    `5. Return taskId="${task.id}", branch="${lead.branch}", worktreePath="${lead.worktreePath}", filesTouched from git diff --name-only ${baseBranch}...HEAD, commandsRun, commit from git rev-parse HEAD after the last merge, summary naming the briefs merged, blocked=false; blocked=true with the reason when a merge or the verification failed for a reason in the code.`,
+    `5. Return taskId="${task.id}", branch="${lead.branch}", worktreePath=the absolute path of the worktree you ran in (git rev-parse --show-toplevel), filesTouched from git diff --name-only ${baseBranch}...HEAD, commandsRun, commit from git rev-parse HEAD after the last merge, summary naming the briefs merged, blocked=false; blocked=true with the reason when a merge or the verification failed for a reason in the code.`,
   ].join('\n')
 }
 
 // Card swarm-topology (candidate 2): one worker blocked does not end the task - the lead gets one chance to
-// re-brief the unfinished pieces, in its existing worktree (no new worktree, no isolation key). `workers` is every
+// re-brief the unfinished pieces, reading from the repository root (no worktree, no isolation key). `workers` is every
 // round-one outcome (so the lead sees a finished sibling's commit, not just the blocked ones); `blockedWorkers` is
 // the subset that needs a revised brief.
 function leadRebriefPrompt(task, lead, workers, blockedWorkers) {
   const finished = workers.filter(w => !w.blocked)
   return [
-    `You are the lead of the swarm for task ${task.id}. One or more workers are blocked; you get one chance to re-brief the unfinished pieces. You implement nothing and edit no file. Work only in your existing worktree ${lead.worktreePath} on branch ${lead.branch}: cd there first, create no new branch, and never edit anything under the repository root.`,
+    `You are the lead of the swarm for task ${task.id}. One or more workers are blocked; you get one chance to re-brief the unfinished pieces. You implement nothing and edit no file. Work read-only from the repository root you were started in. Do not cd into the lead's worktree (it may have been removed), create no branch, and edit nothing. Read a finished worker's committed files with \`git show <commit>:<path>\` or \`git show <commit>\`.`,
     ``,
     `Plan: ${plan.title}`,
     `Goal: ${plan.goal}`,
@@ -1114,6 +1132,7 @@ function verifyPrompt(task, impl, baseBranch) {
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons).slice(0, 2000)] : []),
     ``,
     `Plan acceptance criteria (the spec must be consistent with these; a line starting with $ is the command that checks the criterion above it and exits 0 when it holds):`,
     ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
@@ -1146,6 +1165,7 @@ function checkPrompt(task, impl, prevCommit, baseBranch, ledger) {
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons).slice(0, 2000)] : []),
     ``,
     `Plan acceptance criteria (the spec must be consistent with these; a line starting with $ is the command that checks the criterion above it and exits 0 when it holds):`,
     ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
@@ -1212,10 +1232,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.`]),
     ``,
@@ -1240,7 +1259,7 @@ function levelAdversaryPrompt(li, sReady, levelBase, confirming) {
 }
 
 function levelFallbackAdversaryPrompt(li, sReady, levelBase, why, confirming) {
-  const verify = (plan.verify || []).filter(Boolean)
+  // Same scope as levelAdversaryPrompt (card flow-fallback-verify-scope): no verify list, the suite already ran at integrate.
   return [
     `You are the adversarial reviewer for level ${li} of plan "${plan.title}", standing in for codex-review, which could not run (${why}). The size-S tasks below were merged into ${integrationBranch} with one focused check each and no adversary of their own. Your job is to refute them together, in worktree ${INTEGRATION_WORKTREE} (relative to the repository root); the diff is ${levelBase}...${integrationBranch}.`,
     ``,
@@ -1248,8 +1267,7 @@ function levelFallbackAdversaryPrompt(li, sReady, levelBase, why, confirming) {
     `Plan acceptance criteria:`,
     ...acceptanceEntries(plan.acceptance || []).map(a => `- ${a.text}`),
     ``,
-    `Run every one of these commands in the worktree and record each in commandsRun with its real exit code:`,
-    ...verify.map(v => `  $ ${v}`),
+    `Record every command you run, your own probe checks included, in commandsRun with its real exit code and outputTail (the last lines of its output); a blocker's evidence must cite one of them, and either that command failed or the evidence quotes a line of its outputTail, otherwise the loop records it as major.`,
     confirming
       ? `Then confirm the blockers you raised on this level are fixed, name each as fixed or still open, and check the fix for regressions rather than exploring afresh.`
       : `Then try to break the changes: inputs the tests do not cover, a spec sentence or acceptance criterion a diff does not meet, a test that was weakened, skipped, or deleted, and behavior outside the owned files. When a suspicion needs a check, write a throwaway one, run it, and remove it before you finish.`,
@@ -1275,6 +1293,7 @@ function reviewPrompt(task, impl, baseBranch, seat = 1) {
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons).slice(0, 2000)] : []),
     `Owned files: ${task.files.join(', ')}`,
     `Plan acceptance criteria:`,
     ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
@@ -1310,13 +1329,14 @@ 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('')}`,
     `Task ${task.id}: ${task.title}`,
     ``,
     guard(task.spec),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons).slice(0, 2000)] : []).map(guard),
     ``,
     ...(pass > 1 ? confirmationLines(pass, ledger, impl).map(guard) : [`This is the first pass of this task: explore freely and try to refute the change however you can.`]),
     ``,
@@ -1371,21 +1391,27 @@ function adversaryUnavailable(adv) {
 }
 
 function fallbackAdversaryPrompt(task, impl, baseBranch, why, pass, ledger) {
-  const verify = [task.verify, ...(plan.verify || [])].filter(Boolean)
+  // Same scope as adversaryPrompt's Codex seat (card flow-fallback-verify-scope): the task's own verify only, not plan.verify.
+  const verify = [task.verify].filter(Boolean)
   return [
     `You are the adversarial reviewer for task ${task.id}, standing in for codex-review, which could not run (${why}). Your job is to refute the change on branch ${impl.branch} in worktree ${impl.worktreePath}; the diff is ${baseBranch}...${impl.branch}. ${baseBranch} is this branch's base (an integration branch when the task follows an earlier level); files that already exist there are not this task's changes. Do not edit any file.`,
     ``,
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
     task.spec,
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, LESSONS_NOT_SPEC, String(task.lessons).slice(0, 2000)] : []),
     `Owned files: ${task.files.join(', ')}`,
     `Plan acceptance criteria:`,
     ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
     ...(pass > 1 ? confirmationLines(pass, ledger, impl) : []),
     ``,
-    `Run every one of these commands in the worktree and record each in commandsRun with its real exit code and outputTail (the last lines of its output):`,
-    ...verify.map(v => `  $ ${v}`),
-    `A blocker's evidence must name one of those commands, and either that command failed or the evidence quotes a line of its outputTail; otherwise the loop records it as major.`,
+    ...(verify.length
+      ? [
+          `Run every one of these commands in the worktree and record each in commandsRun with its real exit code and outputTail (the last lines of its output):`,
+          ...verify.map(v => `  $ ${v}`),
+        ]
+      : [`Record every command you run, your own probe checks included, in commandsRun with its real exit code and outputTail (the last lines of its output).`]),
+    `A blocker's evidence must name one of ${verify.length ? 'those commands' : 'the commands in commandsRun'}, and either that command failed or the evidence quotes a line of its outputTail; otherwise the loop records it as major.`,
     pass > 1
       ? `Then confirm the open findings above and check the fix delta for regressions rather than exploring afresh.`
       : `Then try to break the change: inputs the tests do not cover, a spec sentence or acceptance criterion the diff does not meet, a test that was weakened, skipped, or deleted, and behavior outside the owned files. When a suspicion needs a check, write a throwaway one, run it, and remove it before you finish.`,
@@ -1417,14 +1443,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 +1479,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)
@@ -1649,7 +1687,7 @@ async function runSwarm(task, baseBranch, launch) {
     const reason = `worker${round1Blocked.length === 1 ? '' : 's'} blocked: ${round1Blocked.map(w => `${w.n} (${w.id}): ${w.blockedReason}`).join('; ')}`
     // Rule 4: a worker still partial after its resume blocks the task exactly as before - no re-brief attempt.
     if (round1Blocked.some(w => w.partial)) return blocked(reason, { worktreePath: lead.worktreePath, branch: lead.branch })
-    // Rule 2: one re-brief, in the lead's existing worktree (no isolation key, no new worktree), same schema as the
+    // Rule 2: one re-brief, reading from the repository root (no isolation key, no new worktree), same schema as the
     // first split.
     stages.push('lead-rebrief')
     const revised = await launch(leadRebriefPrompt(task, lead, round1, round1Blocked), agentOpts('lead', null, { label: `lead-rebrief:${task.id}`, phase: 'Implement', agentType: 'doug-flow:lead', schema: LEAD_SCHEMA }))
@@ -1700,7 +1738,8 @@ async function runSwarm(task, baseBranch, launch) {
   // workers, in the order they were pushed. `workers` itself (review minor 5) still goes to leadMergePrompt as the
   // worktree-removal list, blocked ones included, so a blocked worker's worktree is not left an orphan.
   const finished = workers.filter(w => !w.blocked)
-  const merged = await launch(leadMergePrompt(task, lead, finished, baseBranch, workers), agentOpts('lead', null, { label: `lead-merge:${task.id}`, phase: 'Implement', agentType: 'doug-flow:lead', schema: IMPLEMENT_SCHEMA }))
+  // Card swarm-lead-worktree-missing: the lead's own worktree is gone by now (rehearsal swarm-2026-10-09T15-20-40-679Z), so the merge gets a fresh one.
+  const merged = await launch(leadMergePrompt(task, lead, finished, baseBranch, workers), agentOpts('lead', null, { label: `lead-merge:${task.id}`, phase: 'Implement', isolation: 'worktree', agentType: 'doug-flow:lead', schema: IMPLEMENT_SCHEMA }))
   if (!merged) return blocked('lead merge returned nothing (spawn failure or no structured output)', { worktreePath: lead.worktreePath, branch: lead.branch })
   return { ...merged, branch: merged.branch || lead.branch, worktreePath: merged.worktreePath || lead.worktreePath, swarmStages: stages, workers, splitReason: lead.splitReason, rebrief, checkFailed: workers.filter(w => w.checkFailed).map(w => w.id) }
 }
@@ -1790,27 +1829,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 +2133,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 +2156,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 +2388,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 +2412,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 +2441,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 +2497,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 +2557,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 +2573,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 +2587,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 +2598,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 +2625,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 +2700,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.1",
   "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",