@dougharness/cli 1.3.0 → 1.4.0

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

@@ -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.'
@@ -837,7 +840,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}`,
@@ -865,7 +868,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}`,
@@ -891,7 +894,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}`,
@@ -923,7 +926,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}`,
@@ -958,7 +961,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 +988,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,7 +1023,7 @@ 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}`,
@@ -1068,7 +1071,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 +1107,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,7 +1133,7 @@ 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}`,
@@ -1164,7 +1167,7 @@ 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:`,
@@ -1198,7 +1201,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 +1252,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 +1268,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 +1291,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.`,
@@ -1350,7 +1353,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,7 +1401,7 @@ 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:`,
@@ -1429,7 +1432,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(', ')}.`,

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.4.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

@@ -323,3 +323,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";
 
@@ -121,7 +122,7 @@ export function failingTestFilesFrom(output, dir) {
 // 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));
@@ -140,9 +141,12 @@ export function classifyFinalBlock({ preVerificationProblems, evidenceProblemAdd
       if (allNamed.every((f) => claimSet.has(f))) return "expected-red";
     }
 
+    // card block-ledger-failing-output: the test-count ratchet is the block's only problem.
     const timedOutOrDropped = (Array.isArray(results) ? results : []).some((r) => r.timedOut || r.skipped === "budget");
     if (timedOutOrDropped && allNamed.length === 0) return "load-timeout";
 
+    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 +163,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 +212,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougharness/gates",
-  "version": "1.3.0",
+  "version": "1.4.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",

package/node_modules/@dougharness/gates/scripts/stop-gate.mjs

@@ -85,13 +85,13 @@ import { runCommand, failureSummary } from "../lib/run.mjs";
 import { loadScopePlan, scopeViolations, describeViolations, PLAN_RELPATH } from "../lib/scope.mjs";
 import { checkpoint, describeCheckpoint } from "../lib/checkpoint.mjs";
 import { verificationEvidence, describeMissingEvidence } from "../lib/evidence.mjs";
-import { changedFiles, captureBaseline, sinceBaseline, headAt, committedSince, walkProposalPathFiles, fileIdentity, treeFingerprint, sameTree, readAgentStart, readTurnStart, turnTreeStatus, onlyNoTestPathsChanged, movedSinceVerified } from "../lib/baseline.mjs";
+import { changedFiles, captureBaseline, sinceBaseline, headAt, committedSince, walkProposalPathFiles, fileIdentity, treeFingerprint, sameTree, readAgentStart, readTurnStart, turnTreeStatus, turnTreeStatusHeadMoved, onlyNoTestPathsChanged, movedSinceVerified } from "../lib/baseline.mjs";
 import { tracePath, readTrace, traceLine, appendTrace, agentLabel } from "../lib/trace.mjs";
 import { isAppliedContent } from "../lib/proposals.mjs";
 import { gitHead, mergeSnapshot, readDecisions, readPlanSummary, readPlanSummaries, snapshotSection } from "../lib/anchor.mjs";
 import { contextReading, recordAgentContext } from "../lib/agent-context.mjs";
 import { parseTotals, readSummaries, sumTotals, compareTotals, deltaTotals, waiverCovers } from "../lib/test-totals.mjs";
-import { failingTestFilesFrom, nonTestTscPathsFrom, classifyFinalBlock, appendBlockLine } from "../lib/block-ledger.mjs";
+import { failingTestFilesFrom, nonTestTscPathsFrom, classifyFinalBlock, appendBlockLine, outputTail, redactText } from "../lib/block-ledger.mjs";
 import { docsGateDecision } from "../lib/docs-gate.mjs";
 import { gateLockPath, readGateLock, pidIsLive, writeGateLock, takeOverGateLock, resolveHookTimeoutSec, lockStaleByAge, normalizedTimeoutMs, lockWaitBoundMs } from "../lib/gate-lock.mjs";
 import { resolveCommands, computeTree, readRecord, writeRecord as writeTreeRecord, removeRecord as removeTreeRecord, creditable } from "../lib/verified-tree.mjs";
@@ -468,6 +468,21 @@ function countingInFlight(dir, cfg, sessionId, inFlight) {
 // and whose ok is not exactly false (a null ok counts as success — conservative). No change found -> true.
 //
 // Without trace evidence, true only when subagent.type is in READ_ONLY_AGENT_TYPES.
+// card ratchet-stale-session-baseline: true only when the trace vouches for the agent's whole life (its
+// SubagentStart line is there) and shows no successful Edit-type PostToolUse of its own. Bash does not count.
+function agentMadeNoEditCalls(dir, cfg, sessionId, subagent) {
+  try {
+    if (!subagent || !cfg.trace || cfg.trace.enabled === false) return false;
+    const file = tracePath(dir, sessionId);
+    if (!existsSync(file)) return false;
+    const lines = readTrace(file);
+    if (!lines.some((l) => l.event === "SubagentStart" && l.agent === subagent.id)) return false;
+    return !lines.some((l) => l.agent === subagent.id && l.event === "PostToolUse" && CHANGE_TOOLS.has(l.tool) && l.ok !== false);
+  } catch {
+    return false;
+  }
+}
+
 function agentMadeNoChanges(dir, cfg, sessionId, subagent) {
   try {
     if (!subagent) return false;
@@ -819,7 +834,15 @@ function countCheck(dir, cfg, state, input, ran, vdir) {
   // card worktree-count-baseline: a worktree run compares against its own earlier green runs, never main's record
   // (a worktree can lack the dist build main has, so its skipped count differs). No record yet means no check.
   const inWorktree = typeof vdir === "string" && vdir !== dir;
-  const baseline = inWorktree ? readLastGreen(vdir) : state.testTotals;
+  // card ratchet-stale-session-baseline: a main-checkout run compares against the main tree's live last-green
+  // record too (per command), not the session-start copy; the copy is the fallback when the record has no
+  // readable entry for the command, so a deleted record does not remove the check.
+  const worktreeBaseline = inWorktree ? readLastGreen(vdir) : null;
+  const mainRecord = inWorktree ? null : readLastGreen(dir);
+  const baselineFor = (command) => {
+    if (inWorktree) return worktreeBaseline;
+    return mainRecord && readSummaries(mainRecord[command]) ? mainRecord : state.testTotals;
+  };
   const problems = [];
   const parsed = {};
   // The note carries its own event name, never the stop event's: a decision-less SubagentStop line would read to
@@ -843,6 +866,7 @@ function countCheck(dir, cfg, state, input, ran, vdir) {
         note(`count check did not run for \`${command}\`: no test summary in its output`);
         continue;
       }
+      const baseline = baselineFor(command);
       const all = baseline && typeof baseline === "object" ? baseline : null;
       const baseList = all ? readSummaries(all[command]) : null;
       if (!baseList) {
@@ -1209,8 +1233,8 @@ runHook("stop-gate", async (input) => {
     traceSubagentDecision("allow", traceReason, extra);
     return allow();
   };
-  const blockStopDecided = (reason) => {
-    traceSubagentDecision("block", null);
+  const blockStopDecided = (reason, extra) => {
+    traceSubagentDecision("block", null, extra);
     return blockStop(reason);
   };
   const systemMessageDecided = (message, traceReason, extra) => {
@@ -1220,8 +1244,19 @@ runHook("stop-gate", async (input) => {
   // Card stop-gate-block-ledger: one ledger line per block/stand-down below, written synchronously right
   // before the blockStop/systemMessage call it belongs to (those call process.exit(0) themselves, so
   // nothing queued after them ever runs). appendBlockLine never throws.
-  const logBlock = (reason, cls) =>
-    appendBlockLine(dir, { hook: subagent ? "subagent-stop" : "stop-gate", agent: subagent ? subagent.type : null, reason, class: cls, session: input.session_id });
+  const logBlock = (reason, cls, record) =>
+    appendBlockLine(dir, { hook: subagent ? "subagent-stop" : "stop-gate", agent: subagent ? subagent.type : null, reason, class: cls, session: input.session_id, record });
+  // card block-ledger-failing-output: a main Stop verification block has no decision trace line of its own;
+  // append one carrying the record. A SubagentStop's line comes from traceSubagentDecision. Never throws.
+  const traceMainBlock = (record) => {
+    if (subagent) return;
+    try {
+      if (!cfg.trace || cfg.trace.enabled === false) return;
+      appendTrace(dir, { ...traceLine(input, { now: new Date() }), event: "Stop", decision: "block", reason: null, ...record });
+    } catch {
+      // never block the real exit on a trace failure
+    }
+  };
   // Card block-ledger-stood-down-repeats: a stood-down line is written at most once per session per
   // cause, so a session standing down at its cap does not append a fresh identical line on every later
   // Stop/SubagentStop past it. Cause key: "turn-budget" (lead only), or "block-cap:<lead|agent id>" — the
@@ -1418,7 +1453,10 @@ runHook("stop-gate", async (input) => {
     let readOnly = null;
     try {
       const start = readTurnStart(dir, input.session_id);
-      const status = turnTreeStatus(cfg, start, treeFingerprint(dir, cfg, changed));
+      const currentFp = treeFingerprint(dir, cfg, changed);
+      let status = turnTreeStatus(cfg, start, currentFp);
+      // A turn that only committed noTestPaths files moved HEAD but changed no code (card stop-gate-read-only-turn-commits).
+      if (status && !status.same) status = turnTreeStatusHeadMoved(dir, cfg, start, currentFp) || status;
       if (status && status.same) {
         let editedThisTurn = false;
         if (cfg.trace && cfg.trace.enabled !== false) {
@@ -1723,8 +1761,14 @@ runHook("stop-gate", async (input) => {
         [...treeProblems, lastRed.summary].join("\n\n");
       const reuseClass = typeof lastRed.class === "string" ? lastRed.class : "real";
       const capped = deferralCapNote && !subagent ? `${deferralCapNote}\n\n${reason}` : reason;
-      logBlock(reason, reuseClass);
-      return blockStopDecided(capped);
+      const reuseRecord = {
+        failures: Array.isArray(lastRed.failures) ? lastRed.failures : [],
+        cwd: typeof lastRed.cwd === "string" ? lastRed.cwd : null,
+        tree: typeof lastRed.tree === "string" ? lastRed.tree : null,
+      };
+      logBlock(reason, reuseClass, reuseRecord);
+      traceMainBlock(reuseRecord);
+      return blockStopDecided(capped, reuseRecord);
     }
   }
 
@@ -1869,9 +1913,9 @@ runHook("stop-gate", async (input) => {
     if (deferralCapNote && !subagent) return systemMessageDecided(deferralCapNote, traceReason, extra);
     return allowDecided(traceReason, extra);
   };
-  const blockStopReleasing = (reason) => {
+  const blockStopReleasing = (reason, extra) => {
     releaseLock();
-    return blockStopDecided(deferralCapNote && !subagent ? `${deferralCapNote}\n\n${reason}` : reason);
+    return blockStopDecided(deferralCapNote && !subagent ? `${deferralCapNote}\n\n${reason}` : reason, extra);
   };
   const systemMessageReleasing = (message, traceReason, extra) => {
     releaseLock();
@@ -1906,6 +1950,19 @@ runHook("stop-gate", async (input) => {
   // One entry per failed command, `{ command, output }` (stderr + stdout, untruncated), for the
   // tests_red_by_design coverage check below (design point 2, card subagent-stop-gate-tester-red).
   const commandFailures = [];
+  // card block-ledger-failing-output: the failing commands, the directory and the tree this block verified.
+  const buildBlockRecord = () => {
+    try {
+      const failures = commandFailures.map((cf, i) => {
+        const r = failedRuns[i] || {};
+        return { command: redactText(cf.command, cfg.secrets), exit: typeof r.status === "number" ? r.status : null, timedOut: !!r.timedOut, tail: outputTail(cf.output, cfg.secrets) };
+      });
+      return { failures, cwd: vdir, tree: treeBefore ?? null };
+    } catch {
+      return { failures: [], cwd: vdir, tree: null }; // the line is written without the failures; the decision is unchanged
+    }
+  };
+  const failedRuns = []; // parallel to commandFailures: { status, timedOut } of each failed run (card block-ledger-failing-output)
   const ranGreen = []; // count check input: { command, stdout } of each command that really ran and exited 0, plus { command, result } of each credited pre-commit command whose recorded totals are readable
   // card stop-gate-credits-pre-commit: a passing pre-commit record for this exact tree and command set
   // stands in for actually running them — see preCommitCredit above. Every other check below (evidence,
@@ -1953,6 +2010,7 @@ runHook("stop-gate", async (input) => {
         // commandFailures below keeps the untruncated output for the tests_red_by_design coverage check.
         problems.push(`\`${command}\` failed (${why}):\n${failureSummary(output, 40)}`);
         commandFailures.push({ command, output });
+        failedRuns.push({ status: r.status, timedOut: r.timedOut });
       }
     }
   }
@@ -2006,8 +2064,17 @@ runHook("stop-gate", async (input) => {
 
   // 3c. Test-count ratchet (card test-count-ratchet): its own kind of problem, not a failed command.
   const counted = countCheck(dir, cfg, state, input, ranGreen, vdir);
-  problems.push(...counted.problems);
-  const countProblemAdded = counted.problems.length > 0;
+  // card ratchet-stale-session-baseline: a seat with no Edit-type call is never blocked by a count change it did
+  // not cause. Its count problems become one trace note, and that stop writes neither the record nor state.verified.
+  const countExempt = counted.problems.length > 0 && !!subagent && agentMadeNoEditCalls(dir, cfg, input.session_id, subagent);
+  if (countExempt) {
+    try {
+      if (cfg.trace && cfg.trace.enabled !== false) appendTrace(dir, { ...traceLine(input, { now: new Date() }), event: "CountCheck", reason: `count change not blocking a seat that made no Edit-type call: ${counted.problems[0].split("\n")[0].slice(0, 300)}` });
+    } catch {
+      // logging must never fail the gate
+    }
+  } else problems.push(...counted.problems);
+  const countProblemAdded = !countExempt && counted.problems.length > 0;
 
   // A main Stop's skip has no decision-tagged exit line like a SubagentStop's (allowReleasing folds the reason
   // into that); record the reason here so the trace carries it (card stop-gate-no-test-paths).
@@ -2025,8 +2092,8 @@ runHook("stop-gate", async (input) => {
   // (card stop-gate-read-only-subagent-skip): nothing was actually verified.
   // A read-only-turn skip verified nothing: it leaves lastRed (and stopBlocks, below) as they were.
   if (skipReason !== "read-only-turn") state.lastRed = null; // card stop-gate-no-change-restop: re-set at the final block below when it qualifies
-  if (problems.length === 0 && !skipVerification && !targeted) state.verified = verifiedCandidate;
-  if (problems.length === 0 && !skipVerification) writeLastGreen(vdir || dir, counted.parsed); // empty when nothing really ran
+  if (problems.length === 0 && !skipVerification && !targeted && !countExempt) state.verified = verifiedCandidate;
+  if (problems.length === 0 && !skipVerification && !countExempt) writeLastGreen(vdir || dir, counted.parsed); // empty when nothing really ran
   if (problems.length === 0 && subagent) {
     // A subagent's green gate: its counter resets; the checkpoint, if any, belongs to the session's own Stop.
     state.agentBlocks = { ...(state.agentBlocks || {}), [subagent.id]: 0 };
@@ -2126,6 +2193,7 @@ runHook("stop-gate", async (input) => {
                   summary: problems.slice(preVerificationProblems, postCommandProblems).join("\n\n"),
                   class: redClass,
                   who,
+                  ...buildBlockRecord(),
                 };
               }
             } catch {
@@ -2164,6 +2232,8 @@ runHook("stop-gate", async (input) => {
     let finalClass = "real";
     try {
       finalClass = classifyFinalBlock({
+        countProblems: countExempt ? 0 : counted.problems.length,
+        totalProblems: problems.length,
         preVerificationProblems,
         evidenceProblemAdded,
         commandFailures,
@@ -2177,6 +2247,7 @@ runHook("stop-gate", async (input) => {
     } catch {
       finalClass = "real";
     }
+    const blockRecord = buildBlockRecord();
     // card stop-gate-no-change-restop: record this red for reuse only when every configured command really
     // ran (not credited, none dropped for budget or timed out) and at least one failed, every failure by a
     // numeric non-zero exit outside 129..192 (a signal kill has status null, a shell-reported one 128+signal; both load-suspect). Stored with the block's ledger
@@ -2200,14 +2271,16 @@ runHook("stop-gate", async (input) => {
           summary: problems.slice(preVerificationProblems, postCommandProblems).join("\n\n"),
           class: finalClass,
           who,
+          ...blockRecord,
         };
         saveState(dir, input.session_id, state);
       }
     } catch {
       state.lastRed = null;
     }
-    logBlock(reason, finalClass);
-    return blockStopReleasing(reason);
+    logBlock(reason, finalClass, blockRecord);
+    traceMainBlock(blockRecord);
+    return blockStopReleasing(reason, blockRecord);
   };
 
   return runVerification();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougharness/cli",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "doug: tailored, approval-gated harness install for Claude Code.",
   "type": "module",
   "license": "MIT",
@@ -23,8 +23,8 @@
     "node": ">=22.16"
   },
   "dependencies": {
-    "@dougharness/flow": "1.3.0",
-    "@dougharness/gates": "1.3.0"
+    "@dougharness/flow": "1.4.0",
+    "@dougharness/gates": "1.4.0"
   },
   "bundleDependencies": [
     "@dougharness/flow",