@dougharness/cli 1.2.0 → 1.4.0

package/node_modules/@dougharness/gates/scripts/research-cap.mjs

@@ -27,9 +27,11 @@
 // Loopback exemption (card research-cap-localhost, whole-command grammar, fix pass 5): a local model probe is not
 // web research, so it is neither counted nor denied. The exemption applies only when the entire raw command
 // string, before any splitting, is ONE simple fetch (isLoopbackFetch):
-//   1. Trimmed, it tokenizes into words. Single quotes are literal; double quotes may not hold $, a backtick, a
-//      backslash or !; an unterminated quote is not exempt. Outside quotes only space, tab, [A-Za-z0-9._:/=@%+,-]
-//      and a redirect's > are allowed, so & | ; ( ) { } [ ] * ? ~ # $ ` \ ! < and a newline are never exempt.
+//   1. Trimmed, it tokenizes into words. Single quotes are literal; double quotes may not hold $, a backtick or !,
+//      and a backslash only as \" or \\ (a literal char; any other backslash is not exempt); an unterminated quote
+//      is not exempt. Outside quotes only space, tab, [A-Za-z0-9._:/=@%+,-], a redirect's >, the exact word 2>&1
+//      and a backslash-newline continuation (removed, no word break) are allowed, so & | ; ( ) { } [ ] * ? ~ # $
+//      ` \ ! < and a bare newline are otherwise never exempt (2>&1>x, a&b, 2>&1; are not the exact word).
 //   2. The first word is exactly curl or wget: no path, wrapper, assignment or other case.
 //   3. Every other word is an allowlisted option (value-less -s -S -f -L -i -v -g or --silent and similar,
 //      combinable in one short token; value-taking -o -H -d -X -w -m for curl, -O -T and --header for wget,
@@ -41,11 +43,18 @@
 //      exactly /dev/null or does not start with /dev/ (bash opens /dev/tcp and /dev/udp as sockets).
 // A command outside the grammar is not an error: it is counted by bashFetchVerbs exactly as at HEAD, one count
 // per split command whose first resolved fetch form is curl or wget. Only Bash curl/wget is affected; WebFetch
-// and WebSearch always count. Anything doubtful counts: a compound line, a pipe, a wrapper, a mixed local and
-// remote command, no URL such as curl --version, other 127.x addresses, 0.0.0.0, host.docker.internal.
+// and WebSearch always count.
 // Accepted limits of the exemption: an env proxy (https_proxy=http://evil.com in the environment, not on the
 // command) routes the request out; -L, and wget by default, follow a redirect a local server can point at a
 // remote host; a ~/.curlrc or ~/.wgetrc can add a URL or a proxy.
+// Anything doubtful counts: a compound line, a pipe that is not a safe pipe consumer (below), a wrapper, a mixed
+// local and remote command, no URL such as curl --version, other 127.x addresses, 0.0.0.0, host.docker.internal.
+//
+// Pipe consumers (card research-cap-loopback-post): the same exemption holds for a pipeline of unquoted single "|"
+// (never ||, |& or an empty segment) whose first segment is a loopback fetch unchanged and whose every later
+// segment is, with no redirect, head/tail with only a count (-c N, -n N, -cN, -nN, -N) or exactly
+// python3|python -m json.tool. Anything else (jq, sh, curl, python -c) counts as at HEAD. Each counted Bash
+// counter line also carries hosts, the URL hosts of that split command, so a miss is diagnosable.
 //
 // Known limit: several calls issued in one message can each read the same count before any of them appends, so
 // a single burst can push an agent's count past the cap by the number of calls it issues at once.
@@ -305,14 +314,29 @@ function tokenize(text) {
     gt = false;
     open = false;
   };
-  for (const ch of text) {
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
     if (quote) {
+      if (quote === '"' && ch === "\\") {
+        // Only \" and \\ are escapes inside double quotes; both give a literal char. Any other backslash
+        // (\$, \`, \!, backslash-newline) leaves the grammar.
+        const next = text[i + 1];
+        if (next !== '"' && next !== "\\") return null;
+        raw += ch + next;
+        val += next;
+        i += 1;
+        continue;
+      }
       raw += ch;
       if (ch === quote) quote = "";
-      else if (quote === '"' && "$`\\!".includes(ch)) return null;
+      else if (quote === '"' && "$`!".includes(ch)) return null;
       else val += ch;
     } else if (ch === " " || ch === "\t") end();
-    else {
+    else if (ch === "\\" && text[i + 1] === "\n") i += 1; // a line continuation: removed, no word break
+    else if (!open && text.startsWith("2>&1", i) && (i + 4 === text.length || " \t".includes(text[i + 4]))) {
+      words.push({ raw: "2>&1", val: "2>&1", gt: false, dup: true }); // the exact word only, never a prefix
+      i += 3;
+    } else {
       open = true;
       raw += ch;
       if (ch === "'" || ch === '"') quote = ch;
@@ -337,7 +361,8 @@ function isLoopbackFetch(command) {
   let urls = 0;
   let wantValue = false;
   for (let k = 1; k < words.length; k += 1) {
-    const { raw, val, gt } = words[k];
+    const { raw, val, gt, dup } = words[k];
+    if (dup) continue;
     if (gt) {
       const m = REDIRECT.exec(raw);
       if (!m) return false;
@@ -368,19 +393,98 @@ function isLoopbackFetch(command) {
   return urls > 0;
 }
 
-// Returns one verb ("curl" or "wget") per split command of a Bash command line that resolves to a fetch;
-// non-fetch split commands contribute nothing. A non-string command (missing, or e.g. a number) is zero
+// Splits a raw command on unquoted single "|" (card research-cap-loopback-post). Null when the text has a "||", a
+// "|&", an empty segment, or no pipe at all, so only a plain pipeline is ever split.
+function splitPipeline(command) {
+  const text = String(command);
+  const segs = [];
+  let quote = "";
+  let cur = "";
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (quote) {
+      if (quote === '"' && ch === "\\" && i + 1 < text.length) {
+        cur += ch + text[i + 1];
+        i += 1;
+        continue;
+      }
+      if (ch === quote) quote = "";
+      cur += ch;
+    } else if (ch === "'" || ch === '"') {
+      quote = ch;
+      cur += ch;
+    } else if (ch === "|") {
+      if (text[i + 1] === "|" || text[i + 1] === "&" || cur.trim() === "") return null;
+      segs.push(cur);
+      cur = "";
+    } else cur += ch;
+  }
+  if (quote || cur.trim() === "" || segs.length === 0) return null;
+  segs.push(cur);
+  return segs;
+}
+
+// One pipe consumer that cannot fetch: head or tail with only a count, or python[3] -m json.tool. No redirect.
+function isSafeConsumer(segment) {
+  const words = tokenize(segment.trim());
+  if (!words || words.length === 0 || words.some((w) => w.gt || w.raw !== w.val)) return false;
+  const v = words.map((w) => w.val);
+  if (v[0] === "head" || v[0] === "tail") {
+    const rest = v.slice(1);
+    if (rest.length === 0) return false;
+    if (rest.length === 1) return /^-(?:[cn]?\d+)$/.test(rest[0]);
+    return rest.length === 2 && /^-[cn]$/.test(rest[0]) && /^\d+$/.test(rest[1]);
+  }
+  return (v[0] === "python3" || v[0] === "python") && v.length === 3 && v[1] === "-m" && v[2] === "json.tool";
+}
+
+// True when the whole command is one loopback fetch, or one followed by safe consumers (see the header).
+function isLoopbackCommand(command) {
+  if (isLoopbackFetch(command)) return true;
+  const segs = splitPipeline(command);
+  return !!segs && isLoopbackFetch(segs[0]) && segs.slice(1).every(isSafeConsumer);
+}
+
+// URL hosts of one split command, lower-cased, unique, in order (card research-cap-loopback-post). Diagnostic
+// only: never throws and never returns the command text.
+function urlHosts(cmd) {
+  const hosts = [];
+  try {
+    for (const w of String(cmd).match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []) {
+      const word = w.replace(/["']/g, "");
+      if (word === "" || word.startsWith("-")) continue;
+      let host = "";
+      const scheme = /^[a-z][a-z0-9+.-]*:\/\/([^/?#]*)/i.exec(word);
+      if (scheme) {
+        const auth = scheme[1].slice(scheme[1].lastIndexOf("@") + 1);
+        const m = /^(\[[^\]]*\]|[^:]*)/.exec(auth);
+        host = m ? m[1] : "";
+      } else {
+        const m = /^(\[::1\]|[a-z0-9.-]+)(:\d+)?([/?#]|$)/i.exec(word);
+        if (m && (/^(?:localhost|127\.0\.0\.1|\[::1\])$/i.test(m[1]) || m[2] || m[3])) host = m[1];
+      }
+      host = host.toLowerCase();
+      if (host && !hosts.includes(host)) hosts.push(host);
+    }
+  } catch {
+    // diagnostic only
+  }
+  return hosts;
+}
+
+// Returns one {verb, hosts} per split command of a Bash command line that resolves to a fetch (verb "curl" or
+// "wget"); non-fetch split commands contribute nothing. A non-string command (missing, or e.g. a number) is zero
 // fetches. commandForms runs on each split command's original text with its quotes intact (it does its own
 // quote parsing for a shell -c script), never on stripped or reconstructed text. A command that is one simple
-// loopback fetch (isLoopbackFetch) is not a fetch to count.
+// loopback fetch, alone or piped to a safe consumer (isLoopbackCommand), is not a fetch to count.
 function bashFetchVerbs(command) {
-  if (isLoopbackFetch(command)) return [];
+  if (isLoopbackCommand(command)) return [];
   const verbs = [];
   for (const cmd of splitTopLevel(command)) {
     for (const form of commandForms(cmd)) {
       const verb = firstWordBasename(form);
       if (FETCH_VERBS.has(verb)) {
-        verbs.push(verb);
+        verbs.push({ verb, hosts: urlHosts(cmd) });
         break;
       }
     }
@@ -401,7 +505,7 @@ runHook("research-cap", async (input) => {
   if (input.tool_name === "Bash") {
     const verbs = bashFetchVerbs(input.tool_input && input.tool_input.command);
     if (verbs.length === 0) return allow(); // an ordinary Bash command is never counted or denied here
-    entries = verbs.map((verb) => ({ tool: "Bash", verb }));
+    entries = verbs.map(({ verb, hosts }) => ({ tool: "Bash", verb, hosts }));
   } else {
     entries = [{ tool: input.tool_name }];
   }

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;
@@ -802,10 +817,32 @@ function waiverSources(dir, baselineHead) {
   return sources;
 }
 
+// A tree's own last-green record, read live; null when absent or unreadable (card worktree-count-baseline).
+function readLastGreen(dir) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(dir, LAST_GREEN_RELPATH), "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
 // The count check for the commands that ran green by exit code. Returns { problems, parsed }: `problems` are
 // block reasons, `parsed` the per-command summary lists of every run that was counted (for the last-green
 // record). A missing or unparseable summary, or no baseline, is a trace line and no check.
-function countCheck(dir, cfg, state, input, ran) {
+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;
+  // 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
@@ -829,7 +866,8 @@ function countCheck(dir, cfg, state, input, ran) {
         note(`count check did not run for \`${command}\`: no test summary in its output`);
         continue;
       }
-      const all = state.testTotals && typeof state.testTotals === "object" ? state.testTotals : null;
+      const baseline = baselineFor(command);
+      const all = baseline && typeof baseline === "object" ? baseline : null;
       const baseList = all ? readSummaries(all[command]) : null;
       if (!baseList) {
         parsed[command] = summaries;
@@ -1195,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) => {
@@ -1206,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
@@ -1404,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) {
@@ -1709,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);
     }
   }
 
@@ -1855,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();
@@ -1892,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,
@@ -1939,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 });
       }
     }
   }
@@ -1991,9 +2063,18 @@ runHook("stop-gate", async (input) => {
   const evidenceProblemAdded = problems.length > postCommandProblems;
 
   // 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);
-  problems.push(...counted.problems);
-  const countProblemAdded = counted.problems.length > 0;
+  const counted = countCheck(dir, cfg, state, input, ranGreen, vdir);
+  // 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).
@@ -2011,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(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 };
@@ -2112,6 +2193,7 @@ runHook("stop-gate", async (input) => {
                   summary: problems.slice(preVerificationProblems, postCommandProblems).join("\n\n"),
                   class: redClass,
                   who,
+                  ...buildBlockRecord(),
                 };
               }
             } catch {
@@ -2150,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,
@@ -2163,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
@@ -2186,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.2.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.2.0",
-    "@dougharness/gates": "1.2.0"
+    "@dougharness/flow": "1.4.0",
+    "@dougharness/gates": "1.4.0"
   },
   "bundleDependencies": [
     "@dougharness/flow",