@dougharness/cli 1.3.0 → 1.5.0

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

@@ -3,7 +3,7 @@ export const meta = {
   description: 'Implement an approved Doug plan: one implementer per task in its own worktree, then verify, review, and integrate',
   whenToUse: 'After /doug-plan produced .doug/plan.json and the user approved it with /doug-approve. Pass the plan JSON as args.',
   phases: [
-    { title: 'Implement', detail: 'one implementer per task, fresh context, own worktree (with swarm on, a lead splits a full-shape task into worker briefs, workers implement them in parallel, and the lead merges); a task marked reuse checks out its recorded branch instead; a task whose dependency did not integrate is never launched; a block the checks can describe is fixed in place until the task budget, the fix-attempt ceiling, a pass that made no new commit, or two consecutive passes raising a new blocker stops it' },
+    { title: 'Implement', detail: 'one implementer per task, fresh context, own worktree (with swarm on, a lead splits a full-shape task into worker briefs, workers implement them in parallel, and the lead merges); a task marked reuse rebuilds the own commits of its recorded branch on the current base instead; a task whose dependency did not integrate is never launched; a block the checks can describe is fixed in place until the task budget, the fix-attempt ceiling, a pass that made no new commit, or two consecutive passes raising a new blocker stops it' },
     { title: 'Verify', detail: 'a separate verifier runs the task command in the worktree on the first pass; a fix pass runs one focused check over the fix delta instead, and the full verifier again only when the verifier is the stage that blocked; a task whose crew names more testers gets extra verifiers in parallel' },
     { title: 'Review', detail: 'spec compliance, then quality, against the diff on the first pass; on a fix pass the focused check carries scope and regression risk unless the reviewer is the stage that blocked; a task whose crew names two reviewers gets a second one in parallel with a distinct brief' },
     { title: 'Adversary', detail: 'codex-review (a different model, read-only) explores freely on the first pass and confirms the open findings on later passes, under one material blocker gate; when it cannot run, a Claude adversary on plan.adversary.fallback stands in; blockers stop integration' },
@@ -64,6 +64,9 @@ 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.'
+// The one sentence about a relayed user message, in every stage prompt: Claude Code relays the user's mid-turn message to every
+// seat of a Workflow run, and a stage must not stop for a message about other work (card queen-seats-relayed-user-message).
+const RELAYED_MESSAGE = 'Your task is this plan task. A relayed user message about other work is outside this task: it is never a reason to stop or to return blocked; mention it in your summary if the result has one.'
 // The one rule about how a commit runs, in every implement prompt that commits: the pre-commit hook runs the full
 // unit suite, which outlives Bash's default timeout, and a background commit dies with the agent that started it.
 const FOREGROUND_COMMIT = 'Run git commit in the foreground with the Bash tool timeout set to 600000 ms (the pre-commit hook runs the full suite): never run_in_background, a Monitor, or a sleep loop. Take the sha only from git rev-parse HEAD after git commit has returned.'
@@ -114,7 +117,7 @@ const roleModels = (plan.models && plan.models.roles) || {}
 // The adversary row may name "codex": the review runs on Codex (plan.adversary.command) and the Claude agent
 // that launches it and relays the verdict is only a relay, so it runs on haiku. `relay` is that agent's model.
 const ADVERSARY_RELAY_MODEL = 'haiku'
-// Checking out a reused branch is mechanical, so it runs on the same small model as the adversary relay.
+// Rebuilding a reused branch is a scripted run of listed git commands, so it runs on the same small model as the adversary relay.
 const CHECKOUT_MODEL = ADVERSARY_RELAY_MODEL
 // The fix-loop supervisor (card fix-loop-supervisor) runs on the `cheap` tier of the Models table; a table without
 // one puts it on the relay model, since reading a task's passes and writing a brief is small work.
@@ -703,6 +706,10 @@ function droppedWhy(f, task) {
 // Applies one pass to the ledger, stage by stage in the order the stages ran, and returns the ids that opened,
 // were confirmed fixed, and came back. A stage confirms an open entry by running and not reporting it: its own
 // stage, the focused check, and the confirmation adversary all count, and only on a pass that made a new commit.
+function explicitMinor(f) {
+  return ['minor', 'nit', 'note'].includes(String(f.severity == null ? '' : f.severity).trim().toLowerCase())
+}
+
 function updateLedger(ledger, r, pass, newCommit) {
   const opened = []
   const fixed = []
@@ -731,7 +738,7 @@ function updateLedger(ledger, r, pass, newCommit) {
         if (e.status !== 'open' || e.openedPass === pass || touched.has(e.id)) continue
         const covers = e.stage === stage || stage === 'check' || (stage === 'adversary' && pass > 1)
         if (!covers) continue
-        if (reReports.some(f => matchFinding(ledger, f) === e)) continue
+        if (reReports.some(f => !explicitMinor(f) && matchFinding(ledger, f) === e)) continue
         e.status = 'fixed'
         e.fixedPass = pass
         e.fixedCommit = r.commit || null
@@ -742,6 +749,10 @@ function updateLedger(ledger, r, pass, newCommit) {
     for (const f of reReports) {
       const entry = matchFinding(ledger, f)
       if (entry) {
+        // Card stall-on-repeat-minor (2026-10-25 decision, run wf_d9199b24-d9e): a re-report whose severity is
+        // explicitly minor/nit/note neither reopens a fixed entry nor keeps an open one open. Free text and
+        // blocker/major re-reports (and severity-less ones) still do.
+        if (explicitMinor(f)) continue
         touched.add(entry.id)
         if (f.evidence) entry.evidence = f.evidence
         if (entry.status === 'fixed') {
@@ -837,7 +848,7 @@ function implementPrompt(task, baseBranch, opts) {
     ? `   Before that, if git rev-parse --verify --quiet refs/heads/doug/task-${task.id} succeeds, the branch doug/task-${task.id} was created by the previous agent for this task in this same run, which stopped without returning a result; it is yours, not stale. Find that agent's worktree with git worktree list --porcelain (the one with branch refs/heads/doug/task-${task.id}); if none is listed, go straight to the checkout. If it has uncommitted changes to owned files, commit them there first with a message starting "${task.id}: ". ${NO_TRAILERS} ${FOREGROUND_COMMIT} Then remove that worktree with git worktree remove --force <path>, then git checkout doug/task-${task.id} in your own worktree and continue the task from that branch's state (do not recreate the branch or reset it). Never return blocked for the branch existing.`
     : `   Before that, if git rev-parse --verify --quiet refs/heads/doug/task-${task.id} succeeds, the branch is a leftover of an earlier run: do not check it out or build on it; change nothing and return blocked=true with blockedReason "stale branch doug/task-${task.id} already exists; run plan.mjs replan, which renames it".`
   return [
-    `You are implementing exactly one task from an approved plan. Work only in your own git worktree.`,
+    `You are implementing exactly one task from an approved plan. Work only in your own git worktree. ${RELAYED_MESSAGE}`,
     ``,
     `Plan: ${plan.title}`,
     `Goal: ${plan.goal}`,
@@ -845,7 +856,7 @@ function implementPrompt(task, baseBranch, opts) {
     `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):`, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons)] : []),
     ...(typeof task.codeContext === 'string' && task.codeContext ? ['', `Code the semantic index found relevant to this task (path:lines; read these first, they are not the files you own):`, String(task.codeContext).slice(0, 2000)] : []),
     ``,
     `Files you own (you may create or edit ONLY these): ${task.files.join(', ')}`,
@@ -865,7 +876,7 @@ function implementPrompt(task, baseBranch, opts) {
 
 function reusePrompt(task, baseBranch) {
   return [
-    `You are starting a task from a branch that already passed verification, review, and the adversary on an earlier pass of this plan. Do not implement anything and do not edit any file; the checks run again on this branch after you.`,
+    `You are starting a task from a branch that already passed verification, review, and the adversary on an earlier pass of this plan. Do not implement anything and do not edit any file; the checks run again on this branch after you. ${RELAYED_MESSAGE}`,
     ``,
     `Plan: ${plan.title}`,
     `Task ${task.id}: ${task.title}`,
@@ -873,11 +884,17 @@ function reusePrompt(task, baseBranch) {
     `Files the task owns: ${task.files.join(', ')}`,
     ``,
     `Steps, all inside your own worktree:`,
-    `1. git checkout ${task.reuse}. If git refuses because the branch is checked out in another worktree, that worktree is a leftover of the earlier pass under .claude/worktrees: find it with git worktree list --porcelain, remove it with git worktree remove --force <path>, and check out again.`,
+    `1. Put ${task.reuse} on the current base ${baseBranch}, because the earlier pass may have been cut from an integration branch that no longer exists. If any git checkout below refuses because the branch is checked out in another worktree, that worktree is a leftover of the earlier pass under .claude/worktrees: find it with git worktree list --porcelain, remove it with git worktree remove --force <path>, and run the checkout again.`,
+    `   a. List the branch's own commits: git log --no-merges --reverse --format=%H ${baseBranch}..${task.reuse}`,
+    `   b. For each, read its files with git show --name-only --format= <sha>. A commit with no files is dropped. A commit touching only files the task does not own belongs to another task: drop it. A commit touching both files the task owns and files it does not own means the branch carries work the task does not own: change nothing and return blocked=true with a reason naming the commit and the file. A commit touching only owned files is kept.`,
+    `   Then run git merge-base --is-ancestor ${baseBranch} ${task.reuse}. If it fails with exit 128 (the branch or the base does not exist), return blocked=true naming the missing one. When it exits 0 and step b kept every listed commit, the branch already sits on the current base: just git checkout ${task.reuse} and go to step 2. Otherwise rebuild it:`,
+    `   c. git checkout --detach ${baseBranch}`,
+    `   d. git cherry-pick -x each kept commit, in order. When a pick is empty because the base already has the change, run git cherry-pick --skip. On a conflict, run git cherry-pick --abort and return blocked=true with a reason naming the commit and the conflicting files (the branch ref was never moved, so the reviewed work stays intact).`,
+    `   e. git checkout -B ${task.reuse} to point the branch at the rebuilt HEAD (no base argument).`,
     plan.install
       ? `2. Run the project's install command (${plan.install}) before the checks run. Installing is not a file change; do not commit anything it changes. Should you commit at all, ${NO_TRAILERS}`
       : `2. If the task's verification command needs dependencies, run the project's install command. Installing is not a file change; do not commit anything it changes. Should you commit at all, ${NO_TRAILERS}`,
-    `3. Return taskId="${task.id}", branch="${task.reuse}", worktreePath = the absolute path of your worktree (git rev-parse --show-toplevel), filesTouched = the output of git diff --name-only ${baseBranch}...HEAD, commandsRun with real exit statuses, commit = the output of git rev-parse HEAD, summary "reused ${task.reuse} at <commit>", blocked=false. Report blocked=true with the reason only if the branch does not exist or cannot be checked out.`,
+    `3. Return taskId="${task.id}", branch="${task.reuse}", worktreePath = the absolute path of your worktree (git rev-parse --show-toplevel), filesTouched = the output of git diff --name-only ${baseBranch}...HEAD, commandsRun with real exit statuses, commit = the output of git rev-parse HEAD, summary "reused ${task.reuse} at <commit>", blocked=false. Report blocked=true with the reason only if the branch does not exist, cannot be checked out, or step 1 told you to.`,
   ].join('\n')
 }
 
@@ -891,7 +908,7 @@ function leadPrompt(task, baseBranch, opts) {
     ? `   Before that, if git rev-parse --verify --quiet refs/heads/doug/task-${task.id} succeeds, the branch doug/task-${task.id} was created by the previous agent for this task in this same run, which stopped without returning a result; it is yours, not stale. Find that agent's worktree with git worktree list --porcelain (the one with branch refs/heads/doug/task-${task.id}); if none is listed, go straight to the checkout. If it has uncommitted changes to owned files, commit them there first with a message starting "${task.id}: ". ${NO_TRAILERS} ${FOREGROUND_COMMIT} Then remove that worktree with git worktree remove --force <path>, then git checkout doug/task-${task.id} in your own worktree and continue the task from that branch's state (do not recreate the branch or reset it). Never return blocked for the branch existing.`
     : `   Before that, if git rev-parse --verify --quiet refs/heads/doug/task-${task.id} succeeds, the branch is a leftover of an earlier run: do not check it out or build on it; change nothing and return blocked=true with blockedReason "stale branch doug/task-${task.id} already exists; run plan.mjs replan, which renames it".`
   return [
-    `You are the lead of a swarm for exactly one task of an approved plan. You split the task into worker briefs; you do not implement anything and you edit no file. Work only in your own git worktree.`,
+    `You are the lead of a swarm for exactly one task of an approved plan. You split the task into worker briefs; you do not implement anything and you edit no file. Work only in your own git worktree. ${RELAYED_MESSAGE}`,
     ``,
     `Plan: ${plan.title}`,
     `Goal: ${plan.goal}`,
@@ -899,7 +916,7 @@ function leadPrompt(task, baseBranch, opts) {
     `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):`, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons)] : []),
     ...(typeof task.codeContext === 'string' && task.codeContext ? ['', `Code the semantic index found relevant to this task (path:lines; read these first, they are not the files you own):`, String(task.codeContext).slice(0, 2000)] : []),
     ``,
     `Files the task owns: ${task.files.join(', ')}`,
@@ -923,7 +940,7 @@ function workerPrompt(task, brief, n, lead) {
   // to and what is not its business; the task it belongs to still owns only the files its own brief lists below.
   const siblings = (Array.isArray(lead.briefs) ? lead.briefs : []).filter(b => b.id !== brief.id)
   return [
-    `You are worker ${n} of a swarm implementing one part of task ${task.id} from an approved plan. You get one brief, the files it owns, and a verification command; the other parts are other workers' business. Work only in your own git worktree.`,
+    `You are worker ${n} of a swarm implementing one part of task ${task.id} from an approved plan. You get one brief, the files it owns, and a verification command; the other parts are other workers' business. Work only in your own git worktree. ${RELAYED_MESSAGE}`,
     ``,
     `Plan: ${plan.title}`,
     `Goal: ${plan.goal}`,
@@ -934,7 +951,7 @@ function workerPrompt(task, brief, n, lead) {
     `Brief ${brief.id}: ${brief.title}`,
     `Spec:`,
     brief.spec,
-    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons)] : []),
     ...(typeof task.codeContext === 'string' && task.codeContext ? ['', `Code the semantic index found relevant to this task (path:lines; read these first, they are not the files you own):`, String(task.codeContext).slice(0, 2000)] : []),
     ...(typeof lead.interfaces === 'string' && lead.interfaces ? ['', `Interfaces the briefs export or consume (the lead's design; conform to it, do not redesign it):`, lead.interfaces.slice(0, 2000)] : []),
     ...(siblings.length ? ['', `Sibling briefs of this task (their files are not yours to touch; conform to what they export):`, ...siblings.map(s => `  - ${s.id}: ${s.title} (${(Array.isArray(s.files) ? s.files : []).join(', ')})`)] : []),
@@ -958,7 +975,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 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).`,
+    `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). ${RELAYED_MESSAGE}`,
     PARTIAL_NEVER_MERGED,
     ``,
     `Task ${task.id}: ${task.title}`,
@@ -985,7 +1002,7 @@ function leadMergePrompt(task, lead, workers, baseBranch, allWorkers = workers)
 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 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>\`.`,
+    `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>\`. ${RELAYED_MESSAGE}`,
     ``,
     `Plan: ${plan.title}`,
     `Goal: ${plan.goal}`,
@@ -1020,13 +1037,13 @@ function fixPrompt(task, r, pass, baseBranch, ledger, brief) {
     ? `Work only in the git worktree you were started in, on branch ${r.impl.branch}: the task's earlier worktree (${r.impl.worktreePath}) was removed when its level integrated. First run git checkout ${r.impl.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. Create no branch, and never edit anything under the repository root.`
     : `Work only in the existing worktree ${r.impl.worktreePath} on branch ${r.impl.branch}: cd there first, create no worktree and no branch, and never edit anything under the repository root.`
   const lines = [
-    `You are fixing your own task after its checks blocked it. This is fix attempt ${pass - 1} of ${fixAttempts} for task ${task.id}. ${where}`,
+    `You are fixing your own task after its checks blocked it. This is fix attempt ${pass - 1} of ${fixAttempts} for task ${task.id}. ${where} ${RELAYED_MESSAGE}`,
     ``,
     `Plan: ${plan.title}`,
     `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):`, String(task.lessons).slice(0, 2000)] : []),
+    ...(typeof task.lessons === 'string' && task.lessons ? ['', `Lessons from earlier runs on this repository (memory; each cites where it was learned):`, String(task.lessons)] : []),
     ...(typeof task.codeContext === 'string' && task.codeContext ? ['', `Code the semantic index found relevant to this task (path:lines; read these first, they are not the files you own):`, String(task.codeContext).slice(0, 2000)] : []),
     ``,
     `Files you own (you may create or edit ONLY these): ${task.files.join(', ')}`,
@@ -1068,7 +1085,7 @@ function resumePrompt(task, prev, handoff, baseBranch, brief) {
   const completed = (Array.isArray(handoff.completed) ? handoff.completed : []).join('; ') || '(none)'
   const remaining = (Array.isArray(handoff.remaining) ? handoff.remaining : []).join('; ')
   return [
-    `You are resuming ${who} after the previous worker stopped partway through at the harness's context notice. Work only in the existing worktree ${prev.worktreePath} on branch ${prev.branch}: cd there first, create no worktree and no branch, and never edit anything under the repository root.`,
+    `You are resuming ${who} after the previous worker stopped partway through at the harness's context notice. Work only in the existing worktree ${prev.worktreePath} on branch ${prev.branch}: cd there first, create no worktree and no branch, and never edit anything under the repository root. ${RELAYED_MESSAGE}`,
     ``,
     `Plan: ${plan.title}`,
     brief ? `Brief ${brief.id}: ${brief.title}` : `Task ${task.id}: ${task.title}`,
@@ -1104,7 +1121,7 @@ function supervisePrompt(task, r, attempts, ledger, signals) {
     ].join('\n')
   })
   return [
-    `You are the supervisor of task ${task.id}'s fix loop. The loop is stalled: ${stalls.join('; ')}. Read the passes and the ledger below and write a brief for the next fix pass: what was tried, what failed each time, and two or three alternative directions drawn from this evidence, each different from what the passes tried.`,
+    `You are the supervisor of task ${task.id}'s fix loop. The loop is stalled: ${stalls.join('; ')}. Read the passes and the ledger below and write a brief for the next fix pass: what was tried, what failed each time, and two or three alternative directions drawn from this evidence, each different from what the passes tried. ${RELAYED_MESSAGE}`,
     ``,
     `Plan: ${plan.title}`,
     `Task ${task.id}: ${task.title}`,
@@ -1130,13 +1147,13 @@ function supervisePrompt(task, r, attempts, ledger, signals) {
 
 function verifyPrompt(task, impl, baseBranch, seat = 1) {
   return [
-    `You are a verifier. You did not write this code. Your job is to run it, not to read and approve it.`,
+    `You are a verifier. You did not write this code. Your job is to run it, not to read and approve it. ${RELAYED_MESSAGE}`,
     ...(seat > 1 ? [`You are crew seat ${seat} of ${crewOf(task).testers} on this task: another verifier runs the same checks at the same time. Run the verification and acceptance commands yourself, and beyond them probe the behavior the spec implies that those commands may not cover: edge cases (empty, missing, boundary, and repeated input) and error paths (invalid input, a failing dependency). A defect you find is a finding even when every command passes.`] : []),
     ``,
     `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)] : []),
+    ...(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)] : []),
     ``,
     `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}`]),
@@ -1164,12 +1181,12 @@ function verifyPrompt(task, impl, baseBranch, seat = 1) {
 function checkPrompt(task, impl, prevCommit, baseBranch, ledger) {
   const open = ledgerText(ledger, 'open')
   return [
-    `You are the single check on a fix pass for task ${task.id}. You did not write this code. The full verifier and reviewer already ran on an earlier pass, so your job is to run the commands again and to read only what the fix changed.`,
+    `You are the single check on a fix pass for task ${task.id}. You did not write this code. The full verifier and reviewer already ran on an earlier pass, so your job is to run the commands again and to read only what the fix changed. ${RELAYED_MESSAGE}`,
     ``,
     `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)] : []),
+    ...(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)] : []),
     ``,
     `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}`]),
@@ -1198,7 +1215,7 @@ function checkPrompt(task, impl, prevCommit, baseBranch, ledger) {
 // The one check of a size-S task: the verifier's job and the reviewer's job in one agent on the verify row.
 function sizeCheckPrompt(task, impl, baseBranch) {
   return [
-    `You are the one check on size-S task ${task.id}: the verifier's job and the reviewer's job in one pass. You did not write this code. Run it, then read the diff ${baseBranch}...${impl.branch}. No separate verifier, reviewer, or adversary runs for this task; the adversary reviews the level's S tasks together on the integration branch after the merge, so what you miss reaches it.`,
+    `You are the one check on size-S task ${task.id}: the verifier's job and the reviewer's job in one pass. You did not write this code. Run it, then read the diff ${baseBranch}...${impl.branch}. No separate verifier, reviewer, or adversary runs for this task; the adversary reviews the level's S tasks together on the integration branch after the merge, so what you miss reaches it. ${RELAYED_MESSAGE}`,
     ``,
     `Task ${task.id}: ${task.title}`,
     `Spec:`,
@@ -1249,7 +1266,7 @@ function levelAdversaryPrompt(li, sReady, levelBase, confirming) {
     `DOUG_SPEC_EOF`,
   ].join('\n')
   return [
-    `Run the adversarial reviewer for level ${li} of the plan (its size-S tasks, merged on ${integrationBranch}) and relay its verdict. Do not review the code yourself and do not edit anything.`,
+    `Run the adversarial reviewer for level ${li} of the plan (its size-S tasks, merged on ${integrationBranch}) and relay its verdict. Do not review the code yourself and do not edit anything. ${RELAYED_MESSAGE}`,
     ``,
     `Run exactly this command with the Bash tool from the repository root (it pipes the spec on stdin; the timeout is ${adversary.timeoutMs} ms, so set the tool timeout at least that high):`,
     '```',
@@ -1265,7 +1282,7 @@ function levelAdversaryPrompt(li, sReady, levelBase, confirming) {
 function levelFallbackAdversaryPrompt(li, sReady, levelBase, why, confirming) {
   // 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}.`,
+    `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}. ${RELAYED_MESSAGE}`,
     ``,
     ...levelSpecLines(sReady),
     `Plan acceptance criteria:`,
@@ -1288,7 +1305,7 @@ function levelFallbackAdversaryPrompt(li, sReady, levelBase, why, confirming) {
 // reviewer reading spec line by line is likely to miss, so two reviewers do not file the same finding twice.
 function reviewPrompt(task, impl, baseBranch, seat = 1) {
   return [
-    `You are a reviewer. Review the diff ${baseBranch}...${impl.branch} in worktree ${impl.worktreePath} against the task spec. Two passes: spec compliance first, then quality. ${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.`,
+    `You are a reviewer. Review the diff ${baseBranch}...${impl.branch} in worktree ${impl.worktreePath} against the task spec. Two passes: spec compliance first, then quality. ${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. ${RELAYED_MESSAGE}`,
     ...(seat > 1 ? [
       ``,
       `You are reviewer ${seat} of ${seat}: another reviewer is reading this diff at the same time with the standard brief and will check the spec sentence by sentence and the owned-file list. Do not repeat that work. Concentrate on what a first reviewer is likely to miss: behavior on inputs the spec does not name, a test that passes for the wrong reason or asserts less than its name says, error paths and partial failure, concurrency and ordering, a call site elsewhere in the repository that the change silently breaks, and anything the spec implies but does not state. File only what you have shown; your findings are merged with the other reviewer's, and a duplicate collapses to one entry.`,
@@ -1297,7 +1314,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)] : []),
+    ...(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)] : []),
     `Owned files: ${task.files.join(', ')}`,
     `Plan acceptance criteria:`,
     ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
@@ -1340,7 +1357,7 @@ function adversaryPrompt(task, impl, baseBranch, pass, ledger) {
     `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),
+    ...(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)] : []).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.`]),
     ``,
@@ -1350,7 +1367,7 @@ function adversaryPrompt(task, impl, baseBranch, pass, ledger) {
     `DOUG_SPEC_EOF`,
   ].join('\n')
   return [
-    `Run the adversarial reviewer for task ${task.id} and relay its verdict. Do not review the code yourself and do not edit anything.`,
+    `Run the adversarial reviewer for task ${task.id} and relay its verdict. Do not review the code yourself and do not edit anything. ${RELAYED_MESSAGE}`,
     ``,
     `Run exactly this command with the Bash tool (it pipes the spec on stdin; the timeout is ${adversary.timeoutMs} ms, so set the tool timeout at least that high):`,
     '```',
@@ -1398,12 +1415,12 @@ function fallbackAdversaryPrompt(task, impl, baseBranch, why, pass, ledger) {
   // 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.`,
+    `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. ${RELAYED_MESSAGE}`,
     ``,
     `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)] : []),
+    ...(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)] : []),
     `Owned files: ${task.files.join(', ')}`,
     `Plan acceptance criteria:`,
     ...acceptanceEntries(plan.acceptance || []).flatMap(a => a.command ? [`- ${a.text}`, `  $ ${a.command}`] : [`- ${a.text}`]),
@@ -1429,7 +1446,7 @@ function integratePrompt(levelIndex, results, baseBranch, isLastLevel, keepWorkt
   const branches = results.map(r => r.impl.branch)
   const worktrees = results.map(r => r.impl.worktreePath)
   return [
-    `You are the integration owner for level ${levelIndex} of plan "${plan.title}".`,
+    `You are the integration owner for level ${levelIndex} of plan "${plan.title}". ${RELAYED_MESSAGE}`,
     `Integration branch: ${integrationBranch}. Never check it out in the user's main working tree; use a dedicated worktree so the user's checkout is left exactly as it was.`,
     PARTIAL_NEVER_MERGED,
     `Merge these task branches into it, in this order: ${branches.join(', ')}.`,
@@ -1863,11 +1880,12 @@ function isReady(r) {
   if (r.impl && r.impl.partial) return false
   // A finding the ledger already recorded as fixed and that came back keeps the task out even when every stage
   // passed. This is deliberately unconditional: updateLedger reopens on any re-report matched by id or fingerprint,
-  // whatever that re-report's own `blocking` flag or severity says - a passing check's free-text "F1: still returns
-  // 1..." reopens F1 ("still reopens and keeps entries on a real re-report"), and so does a passing-verdict
-  // adversary's *minor*-severity issue naming the same id ("blocks the pass when a finding the ledger recorded as
-  // fixed comes back"). Gating this on the reporting finding's own blocking flag would silently let either of those
-  // real reappearances through. A 'waived' report only stays out of the re-report list (card d-waiver-structural-rule)
+  // whatever that re-report's own `blocking` flag says, except that an explicit minor/nit/note severity no longer
+  // reopens (card stall-on-repeat-minor, 2026-10-25) - a passing check's free-text "F1: still returns
+  // 1..." reopens F1 ("still reopens and keeps entries on a real re-report"), and so does an adversary's
+  // blocker-severity issue naming the same id ("blocks the pass when a finding the ledger recorded as fixed comes
+  // back"). Gating this on the reporting finding's own blocking flag would silently let those real reappearances
+  // through. A 'waived' report only stays out of the re-report list (card d-waiver-structural-rule)
   // when the ledger's own entry for that id is itself a self-declared non-blocking note (confirmsFinding above); a
   // disputed waiver against a blocking entry reaches here as an ordinary re-report and can reopen or keep an entry
   // open exactly the same way.

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

@@ -1,7 +1,7 @@
 {
   "name": "doug-gates",
   "displayName": "Doug Gates",
-  "version": "1.3.0",
+  "version": "1.5.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/lib/baseline.mjs

@@ -258,6 +258,15 @@ export function writeAgentStart(dir, cfg, sessionId, agentId) {
   try {
     const fp = treeFingerprint(dir, cfg, changedFiles(dir));
     if (!fp) return;
+    // card worktree-skip-origin-at-start: origin/HEAD's sha at start (null when unset), for the worktree skip.
+    let originHead = null;
+    try {
+      const o = execFileSync("git", ["rev-parse", "--verify", "-q", "refs/remotes/origin/HEAD^{commit}"], { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 }).trim();
+      if (/^[0-9a-f]{7,64}$/.test(o)) originHead = o;
+    } catch {
+      originHead = null;
+    }
+    fp.originHead = originHead;
     const file = agentStartFile(dir, sessionId, agentId);
     mkdirSync(join(file, ".."), { recursive: true });
     writeFileSync(file, JSON.stringify(fp));
@@ -323,3 +332,26 @@ export function turnTreeStatus(cfg, start, current) {
     return null;
   }
 }
+
+// card stop-gate-read-only-turn-commits: turnTreeStatus for a turn that moved HEAD. Applies only when every path
+// committed between the record's head and HEAD is on preCommit.noTestPaths (same match rule as turnTreeStatus),
+// and then compares the remaining code paths as if HEAD had not moved. Fails closed (null: the caller verifies)
+// on a missing, empty or malformed list, a record head that is not a plausible sha or not an ancestor of HEAD
+// (rewritten history), a git failure, an empty committed set, or any committed path off the list. Never throws.
+export function turnTreeStatusHeadMoved(dir, cfg, start, current) {
+  try {
+    if (!start || !current || typeof start !== "object" || typeof current !== "object") return null;
+    const list = cfg && cfg.preCommit && cfg.preCommit.noTestPaths;
+    if (!Array.isArray(list) || list.length === 0 || !list.every((e) => typeof e === "string" && e !== "")) return null;
+    if (typeof start.head !== "string" || !GIT_SHA_RE.test(start.head)) return null;
+    if (typeof current.head !== "string" || !GIT_SHA_RE.test(current.head) || start.head === current.head) return null;
+    execFileSync("git", ["merge-base", "--is-ancestor", start.head, current.head], { cwd: dir, stdio: "ignore", timeout: 5000 }); // throws on exit != 0
+    const committed = committedSince(dir, start.head);
+    if (!Array.isArray(committed) || committed.length === 0) return null;
+    if (!committed.every((p) => list.some((e) => (e.endsWith("/") ? p.startsWith(e) : p === e)))) return null;
+    const status = turnTreeStatus(cfg, start, { ...current, head: start.head });
+    return status ? { ...status, exact: false } : null;
+  } catch {
+    return null;
+  }
+}

package/node_modules/@dougharness/gates/lib/block-ledger.mjs

@@ -9,6 +9,7 @@
 import { appendFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { changedFiles } from "./baseline.mjs";
+import { scanText } from "./secret-rules.mjs";
 
 export const BLOCKS_RELPATH = ".doug/.state/blocks.jsonl";
 
@@ -109,19 +110,21 @@ export function failingTestFilesFrom(output, dir) {
 //    them is in the standing tests_red_by_design claim (`redByDesignClaimFiles`).
 // 2. 'load-timeout' — at least one command timed out or was dropped for budget, and no failed command's
 //    captured output names a failing test file.
-// 3. 'race' — the working tree (`changedFiles(dir)`, as a set) differs now from `changedAtStart`. Either
+// 3. 'test-count' — the test-count ratchet is the block's only problem (`countProblems > 0` and it equals
+//    `totalProblems`).
+// 4. 'race' — the working tree (`changedFiles(dir)`, as a set) differs now from `changedAtStart`. Either
 //    side being unknown (null: no git, or git unavailable) is never a race. Skipped entirely once
 //    `budgetDeadline` (the gate's own hook-timeout deadline, gateBudget() in stop-gate.mjs) has already
 //    passed (review pass 2, item 4): a second `git status` here is exactly the kind of extra work that
 //    could push a slow gate past the platform's own hook timeout, discarding its block message (F1) — a
 //    deadline already blown is not worth spending on a label, so this falls through to 'real' instead.
-// 4. 'real' — otherwise.
+// 5. 'real' — otherwise.
 //
 // Never throws (review pass 2, item 2 MAJOR): this call sits between the gate's decision to block and the
 // blockStop call that carries it out (stop-gate.mjs), so an unguarded throw here would fail the *whole gate*
 // open — the one outcome every hook reader must never risk (CLAUDE.md gotchas). Any failure classifies as
 // 'real', the least specific label, rather than ever propagating.
-export function classifyFinalBlock({ preVerificationProblems, evidenceProblemAdded, commandFailures, postCommandProblems, results, redByDesignClaimFiles, changedAtStart, dir, budgetDeadline }) {
+export function classifyFinalBlock({ countProblems, totalProblems, preVerificationProblems, evidenceProblemAdded, commandFailures, postCommandProblems, results, redByDesignClaimFiles, changedAtStart, dir, budgetDeadline }) {
   try {
     const failures = Array.isArray(commandFailures) ? commandFailures : [];
     const namedByCommand = failures.map((cf) => failingTestFilesFrom(cf.output, dir));
@@ -143,6 +146,9 @@ export function classifyFinalBlock({ preVerificationProblems, evidenceProblemAdd
     const timedOutOrDropped = (Array.isArray(results) ? results : []).some((r) => r.timedOut || r.skipped === "budget");
     if (timedOutOrDropped && allNamed.length === 0) return "load-timeout";
 
+    // card block-ledger-failing-output: the test-count ratchet is the block's only problem.
+    if (typeof countProblems === "number" && countProblems > 0 && totalProblems === countProblems) return "test-count";
+
     if (Array.isArray(changedAtStart) && !(typeof budgetDeadline === "number" && Date.now() >= budgetDeadline)) {
       const changedNow = changedFiles(dir);
       if (Array.isArray(changedNow)) {
@@ -159,14 +165,47 @@ export function classifyFinalBlock({ preVerificationProblems, evidenceProblemAdd
   }
 }
 
-// Appends one line to .doug/.state/blocks.jsonl: { hook, at, agent, reason, class, session }. `reason` is
+// card block-ledger-failing-output: the last 40 lines of a command's output, secret-scanned (a hit records
+// "[redacted: <rule>]", a scanner throw "[redacted: scan-error]"; skipped when secrets.enabled === false),
+// then capped at 4096 UTF-8 bytes keeping the end, never splitting a character. Never throws.
+export function redactText(text, secrets) {
+  try {
+    if (!(secrets && secrets.enabled === false)) {
+      const hit = scanText(text, secrets || {});
+      if (hit) return "[redacted: " + hit.rule + "]";
+    }
+    return text;
+  } catch {
+    return "[redacted: scan-error]";
+  }
+}
+
+export function outputTail(output, secrets) {
+  try {
+    let tail = String(output ?? "").trimEnd().split("\n").slice(-40).join("\n");
+    tail = redactText(tail, secrets);
+    const buf = Buffer.from(tail, "utf8");
+    if (buf.length > 4096) {
+      let start = buf.length - 4096;
+      while (start < buf.length && (buf[start] & 0xc0) === 0x80) start++;
+      tail = buf.subarray(start).toString("utf8");
+    }
+    return tail;
+  } catch {
+    return "";
+  }
+}
+
+// Appends one line to .doug/.state/blocks.jsonl: { hook, at, agent, reason, class, session }, plus the keys of
+// `record` ({ failures, cwd, tree }, card block-ledger-failing-output) when it is a plain object. `reason` is
 // reduced to its own first line here (message.split("\n")[0]) whatever the caller passes, so a multi-line
 // block message never leaks past its headline into the ledger. Call synchronously, right before each
 // blockStop/systemMessage in stop-gate.mjs — those each call process.exit(0) themselves, so anything queued
 // after them never runs. Never throws: an unwritable .doug/.state, or a blocks.jsonl path that is itself a
 // directory, just skips the line silently; the gate's own decision is unaffected either way.
-export function appendBlockLine(dir, { hook, agent, reason, class: cls, session }) {
+export function appendBlockLine(dir, { hook, agent, reason, class: cls, session, record }) {
   try {
+    const plain = record && typeof record === "object" && !Array.isArray(record) ? record : {};
     const line =
       JSON.stringify({
         hook,
@@ -175,6 +214,7 @@ export function appendBlockLine(dir, { hook, agent, reason, class: cls, session
         reason: String(reason).split("\n")[0],
         class: cls,
         session: session ?? null,
+        ...plain,
       }) + "\n";
     mkdirSync(join(dir, ".doug/.state"), { recursive: true });
     appendFileSync(join(dir, BLOCKS_RELPATH), line);

package/node_modules/@dougharness/gates/lib/docs-gate.mjs

@@ -2,7 +2,8 @@
 // (.githooks/pre-commit). A changed docs/**/*.md file does not by itself run the suite. When every changed path
 // is on preCommit.noTestPaths or is a docs .md (and at least one is a docs .md not on the list), the tracked
 // test files whose text names that doc (its repo-relative path, or its basename, which also covers a
-// join("docs", "decisions", "<basename>") spelling) decide: none -> { kind: "skip" }; some -> { kind:
+// join("docs", "decisions", "<basename>") spelling) decide; non-test code outside a tests/ directory counts a
+// doc as named only by its full repo-relative path (a basename in a comment is ignored): none -> { kind: "skip" }; some -> { kind:
 // "targeted", files } (repo-relative, sorted). Anything else, or any doubt, returns null: run the full gate.
 // Never throws (a throw would reach runHook, which fails open and would skip the gate).
 // CLI (used by .githooks/pre-commit): staged paths on stdin, the config JSON in DOUG_NO_TEST_CONFIG, cwd =
@@ -34,7 +35,8 @@ function validList(cfg) {
 // -> sorted test files naming any of `docs`, or null (unreadable tree, or a file that cannot be mapped to test
 // files names a doc).
 function namingTests(dir, docs, tracked) {
-  const needles = [...new Set(docs.flatMap((d) => [d, basename(d)]))];
+  const pathNeedles = [...new Set(docs)];
+  const wideNeedles = [...new Set(docs.flatMap((d) => [d, basename(d)]))];
   const found = [];
   for (const f of tracked) {
     const isTest = TEST_FILE.test(f);
@@ -43,6 +45,8 @@ function namingTests(dir, docs, tracked) {
     if (!isTest && !underTests && !code) continue;
     if (f.startsWith("docs/")) continue;
     const text = readFileSync(join(dir, f), "utf8");
+    // code outside tests/ names a doc only by its full repo-relative path; tests and test helpers also by basename
+    const needles = isTest || underTests ? wideNeedles : pathNeedles;
     if (!needles.some((n) => text.includes(n))) continue;
     if (!isTest) return null; // a helper or source file reads the doc: cannot be mapped to test files
     found.push(f);

package/node_modules/@dougharness/gates/lib/verified-tree.mjs

@@ -17,6 +17,7 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync, rename
 import { join, resolve } from "node:path";
 import { randomBytes } from "node:crypto";
 import { pathToFileURL } from "node:url";
+import { readSummaries } from "./test-totals.mjs";
 
 export const RECORD_RELPATH = ".doug/.state/verified-tree.json";
 export const EXCLUDED = [".doug/.state", ".claude/worktrees", ".doug/anchor.md"];
@@ -108,6 +109,37 @@ export function validRecord(r) {
   }
 }
 
+// Test totals depend on the environment (a worktree without a built dist skips tests), not only the tree. A record
+// stamps `ranIn` (realpath of the directory its commands ran in); its totals count as evidence only for that directory.
+// Never throws: any failure, or a record with no ranIn (legacy), is false (the commands run).
+export function totalsUsable(record, dir) {
+  try {
+    return !!record && typeof record.ranIn === "string" && realpathSync(record.ranIn) === realpathSync(dir);
+  } catch {
+    return false;
+  }
+}
+
+// A record from another checkout (or a legacy one with no ranIn) credits exit codes only when none of its recorded
+// totals reports skipped tests: a dist-less worktree skips tests that could fail here. Absent or unreadable entries
+// do not count. Never throws: any failure is false.
+export function exitCreditUsable(record, dir) {
+  try {
+    if (!record || typeof record !== "object") return false;
+    if (totalsUsable(record, dir)) return true;
+    const totals = record.totals;
+    if (!totals || typeof totals !== "object") return true;
+    for (const entry of Object.values(totals)) {
+      const sums = readSummaries(entry);
+      if (!sums) continue;
+      if (sums.reduce((n, s) => n + (s.skipped || 0), 0) > 0) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export function readRecord(dir) {
   try {
     const r = JSON.parse(readFileSync(join(dir, RECORD_RELPATH), "utf8"));
@@ -214,6 +246,7 @@ if (isMain()) {
           node: process.version,
           at: new Date().toISOString(),
           by: "pre-commit",
+          ranIn: realpathSync(dir),
           commands: commands.map((cm) => ({ name: cm.name, command: cm.command, exit: cm.exit, durationMs: cm.durationMs })),
           totals,
         });

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

@@ -1,6 +1,6 @@
 {
   "name": "@dougharness/gates",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "private": true,
   "description": "Deterministic Claude Code hooks: protected paths, bash guard, secret scan on edits and commands, format on edit, edit-loop detection, stop gate, re-anchor after compaction.",
   "type": "module",