@dougharness/cli 1.0.1 → 1.1.0

package/node_modules/@dougharness/gates/lib/baseline.mjs

@@ -5,7 +5,7 @@
 // SessionStart script (its earlier capture, when the platform fires it).
 
 import { execFileSync } from "node:child_process";
-import { readFileSync, readdirSync } from "node:fs";
+import { readFileSync, readdirSync, mkdirSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { join, resolve, sep } from "node:path";
 import { matchAny } from "./glob.mjs";
@@ -158,3 +158,168 @@ export function captureBaseline(dir, paths) {
 export function sinceBaseline(dir, paths, baseline) {
   return paths.filter((p) => !(p in baseline) || fileIdentity(join(dir, p)) !== baseline[p]);
 }
+
+// The verified-tree fingerprint (card stop-gate-process-storm, goal 2): the HEAD sha plus the content
+// identity of every dirty path and every proposal-path file on disk, at the moment it is computed. Null
+// when `changed` is not the array shape changedFiles returns (no git, or git unavailable) — there is
+// nothing to fingerprint reliably, so the tree can never be judged "unchanged" on this path.
+export function treeFingerprint(dir, cfg, changed) {
+  if (!Array.isArray(changed)) return null;
+  const walked = walkProposalPathFiles(dir, cfg.proposalPaths);
+  const paths = [...new Set([...changed, ...walked])];
+  // `at` (state.mjs's comment for state.verified) is when this fingerprint was taken; sameTree below never
+  // reads it, so recomputing it on the after-wait path (a fresh Date.now()) never affects equality.
+  return { head: headAt(dir), tree: captureBaseline(dir, paths), at: Date.now() };
+}
+
+// Whether two treeFingerprint results describe the same tree: both present, the same HEAD, the same set of
+// paths, and an identical identity for each. Never throws (a hook reader must never throw): a malformed
+// fingerprint — e.g. a hand-edited state.verified — just compares unequal rather than blocking the gate.
+export function sameTree(a, b) {
+  try {
+    if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+    if (a.head !== b.head) return false;
+    const at = a.tree && typeof a.tree === "object" ? a.tree : null;
+    const bt = b.tree && typeof b.tree === "object" ? b.tree : null;
+    if (!at || !bt) return false;
+    const ak = Object.keys(at).sort();
+    const bk = Object.keys(bt).sort();
+    if (ak.length !== bk.length) return false;
+    for (let i = 0; i < ak.length; i++) if (ak[i] !== bk[i]) return false;
+    return ak.every((k) => at[k] === bt[k]);
+  } catch {
+    return false;
+  }
+}
+
+// card stop-gate-no-test-paths: whether every path changed since the last green verification (`verified`, a
+// treeFingerprint recorded in state.verified) is on preCommit.noTestPaths, read with the pre-commit hook's
+// exact rule (.githooks/pre-commit): an entry matches a path when equal, or, ending in "/", when the path
+// starts with it. Not a glob. "Changed since" is the union of the paths committed since verified.head that are
+// absent from verified.tree or whose current identity differs from the recorded one (a path committed with the
+// verified content is not a change), every path dirty now (read with --no-renames, both sides of a rename) that is absent from verified.tree or whose identity moved, and every verified.tree path
+// whose identity moved (reverted or committed with other content). Fails closed: false when there is no
+// verified fingerprint, its head is unknown to git, git is unavailable, the union is empty, the list is
+// missing, empty, or holds a non-string or empty entry, or any path is off the list. Never throws.
+export function onlyNoTestPathsChanged(dir, cfg, verified, changed) {
+  try {
+    const list = cfg && cfg.preCommit && cfg.preCommit.noTestPaths;
+    if (!Array.isArray(list) || list.length === 0 || !list.every((e) => typeof e === "string" && e !== "")) return false;
+    const moved = movedSinceVerified(dir, verified, changed);
+    if (!moved || moved.size === 0) return false;
+    const hit = (p) => list.some((e) => (e.endsWith("/") ? p.startsWith(e) : p === e));
+    return [...moved].every(hit);
+  } catch {
+    return false;
+  }
+}
+
+// The "changed since the last green" set onlyNoTestPathsChanged judges (card gate-docs-skip-unless-named factors
+// it out so the docs rule reads the same set): a Set of paths, or null when there is no usable verified
+// fingerprint, `changed` is not an array, its head is unknown to git, or anything throws. Never throws.
+export function movedSinceVerified(dir, verified, changed) {
+  try {
+    if (!verified || typeof verified !== "object" || !verified.tree || typeof verified.tree !== "object" || Array.isArray(verified.tree)) return null;
+    if (!Array.isArray(changed)) return null;
+    const committed = committedSince(dir, verified.head);
+    if (!Array.isArray(committed)) return null;
+    const moved = new Set();
+    for (const p of committed) {
+      if (!(p in verified.tree) || fileIdentity(join(dir, p)) !== verified.tree[p]) moved.add(p);
+    }
+    // changedFiles collapses a rename `old -> new` to `new`, hiding a path moved out of a source location, so
+    // the dirty set is collected here with --no-renames (both sides), exactly as pre-commit does.
+    const git = (args) =>
+      execFileSync("git", args, { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 })
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .filter((p) => !p.startsWith(".claude/worktrees/") && !p.startsWith(".doug/.state/") && p !== ".doug/anchor.md");
+    const dirty = [...git(["diff", "--name-only", "--no-renames", "HEAD", "--"]), ...git(["ls-files", "--others", "--exclude-standard"])];
+    for (const p of new Set([...dirty, ...Object.keys(verified.tree)])) {
+      if (!(p in verified.tree) || fileIdentity(join(dir, p)) !== verified.tree[p]) moved.add(p);
+    }
+    return moved;
+  } catch {
+    return null;
+  }
+}
+
+// card gate-skip-readonly-researchers: the start fingerprint of a subagent, written by the trace hook on
+// SubagentStart and read by the stop gate. One small JSON file per agent under .doug/.state/agent-start/<session>/.
+// Ids are reduced to [A-Za-z0-9_-] so one can never escape the directory. Both functions never throw: a failed
+// write means no record, an unreadable record reads as null (the gate then runs as before).
+function agentStartFile(dir, sessionId, agentId) {
+  const clean = (v) => String(v ?? "").replace(/[^A-Za-z0-9_-]/g, "_") || "_";
+  return join(dir, ".doug/.state/agent-start", clean(sessionId), `${clean(agentId)}.json`);
+}
+
+export function writeAgentStart(dir, cfg, sessionId, agentId) {
+  try {
+    const fp = treeFingerprint(dir, cfg, changedFiles(dir));
+    if (!fp) return;
+    const file = agentStartFile(dir, sessionId, agentId);
+    mkdirSync(join(file, ".."), { recursive: true });
+    writeFileSync(file, JSON.stringify(fp));
+  } catch {
+    // no record
+  }
+}
+
+export function readAgentStart(dir, sessionId, agentId) {
+  try {
+    return JSON.parse(readFileSync(agentStartFile(dir, sessionId, agentId), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// card stop-gate-runs-only-on-code-turns: the turn-start fingerprint, written by scripts/turn-start.mjs on
+// UserPromptSubmit and read by the main Stop gate. One small JSON file per session under
+// .doug/.state/turn-start/<session>.json, same id sanitising as agentStartFile. Both functions never throw: a
+// failed write means no record, an unreadable record reads as null (the gate then verifies as before).
+function turnStartFile(dir, sessionId) {
+  const clean = String(sessionId ?? "").replace(/[^A-Za-z0-9_-]/g, "_") || "_";
+  return join(dir, ".doug/.state/turn-start", `${clean}.json`);
+}
+
+export function writeTurnStart(dir, cfg, sessionId) {
+  try {
+    const fp = treeFingerprint(dir, cfg, changedFiles(dir));
+    if (!fp) return;
+    const file = turnStartFile(dir, sessionId);
+    mkdirSync(join(file, ".."), { recursive: true });
+    writeFileSync(file, JSON.stringify(fp));
+  } catch {
+    // no record
+  }
+}
+
+export function readTurnStart(dir, sessionId) {
+  try {
+    return JSON.parse(readFileSync(turnStartFile(dir, sessionId), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// Whether the tree still matches a turn-start record once every path on preCommit.noTestPaths is dropped from
+// both (the pre-commit hook's rule: equal, or a prefix when the entry ends in "/"). Returns null when it cannot
+// tell (no or malformed record, no current fingerprint, any throw) so the caller verifies; otherwise
+// { same, exact, dirty }: `exact` = equal with nothing dropped; `same` = same HEAD, same code paths, same identities; `dirty` = the current tree still holds
+// code paths. Never throws.
+export function turnTreeStatus(cfg, start, current) {
+  try {
+    if (!start || !current || typeof start !== "object" || typeof current !== "object") return null;
+    if (!start.tree || typeof start.tree !== "object" || Array.isArray(start.tree)) return null;
+    if (!current.tree || typeof current.tree !== "object" || Array.isArray(current.tree)) return null;
+    const list = cfg && cfg.preCommit && Array.isArray(cfg.preCommit.noTestPaths) ? cfg.preCommit.noTestPaths.filter((e) => typeof e === "string" && e !== "") : [];
+    const skip = (p) => list.some((e) => (e.endsWith("/") ? p.startsWith(e) : p === e));
+    const strip = (fp) => ({ head: fp.head, tree: Object.fromEntries(Object.entries(fp.tree).filter(([p]) => !skip(p))) });
+    const a = strip(start);
+    const b = strip(current);
+    return { same: sameTree(a, b), exact: sameTree(start, current), dirty: Object.keys(b.tree).length > 0 };
+  } catch {
+    return null;
+  }
+}

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

@@ -18,6 +18,60 @@ function stripLeadingDotSlash(f) {
   return typeof f === "string" && f.startsWith("./") ? f.slice(2) : f;
 }
 
+const TEST_FILE_RE = /\.(?:test|spec)\.[A-Za-z]+$/;
+
+// Every path a tsc error line names (card stop-gate-tsc-red-claim): a path token immediately followed by
+// `(<line>,<col>): error TS<digits>` anywhere on the line, so a `pnpm -r` prefix does not hide it. Same
+// normalisation as failingTestFilesFrom (leading "./", then `dir + "/"`). Never throws: reads as none.
+export function tscErrorPaths(output, dir) {
+  try {
+    const paths = new Set();
+    const MARK = "): error TS";
+    const isDigit = (c) => c >= "0" && c <= "9";
+    const isStop = (c) => /[\s"'`()]/.test(c);
+    for (const line of String(output || "").split("\n")) {
+      // Cheap pre-filter, and no backtracking regex: every step below is a linear walk from a marker.
+      let at = line.indexOf(MARK);
+      while (at !== -1) {
+        const after = at + MARK.length;
+        let i = at - 1;
+        const colEnd = i;
+        while (i >= 0 && isDigit(line[i])) i--;
+        let ok = i < colEnd && line[i] === "," ;
+        if (ok) {
+          i--;
+          const lineEnd = i;
+          while (i >= 0 && isDigit(line[i])) i--;
+          ok = i < lineEnd && line[i] === "(";
+        }
+        if (ok && isDigit(line[after] || "")) {
+          const pathEnd = i;
+          let j = pathEnd;
+          while (j > 0 && !isStop(line[j - 1])) j--;
+          if (j < pathEnd) {
+            let f = stripLeadingDotSlash(line.slice(j, pathEnd));
+            if (typeof dir === "string" && dir && f.startsWith(dir + "/")) f = f.slice(dir.length + 1);
+            paths.add(f);
+          }
+        }
+        at = line.indexOf(MARK, at + 1);
+      }
+    }
+    return [...paths];
+  } catch {
+    return [];
+  }
+}
+
+// The tsc error paths in `output` that are not test files; one of these means the failure is not red by design.
+export function nonTestTscPathsFrom(output, dir) {
+  try {
+    return tscErrorPaths(output, dir).filter((f) => !TEST_FILE_RE.test(f));
+  } catch {
+    return [];
+  }
+}
+
 // Test files a failed verification command's output names: every path token ending in ".test.<ext>" or
 // ".spec.<ext>" (ext = letters) on a line containing "FAIL" or "failed", deduplicated, normalised to a
 // repository-relative path when absolute under `dir`. Moved here from stop-gate.mjs (card
@@ -28,6 +82,7 @@ export function failingTestFilesFrom(output, dir) {
   try {
     const files = new Set();
     const tokenRe = /[^\s"'`]+\.(?:test|spec)\.[A-Za-z]+/g;
+    for (const p of tscErrorPaths(output, dir)) if (TEST_FILE_RE.test(p)) files.add(p);
     for (const line of String(output || "").split("\n")) {
       if (!line.includes("FAIL") && !line.includes("failed")) continue;
       for (const m of line.matchAll(tokenRe)) {
@@ -72,13 +127,15 @@ export function classifyFinalBlock({ preVerificationProblems, evidenceProblemAdd
     const namedByCommand = failures.map((cf) => failingTestFilesFrom(cf.output, dir));
     const allNamed = [...new Set(namedByCommand.flat())];
 
+    const nonTestTsc = failures.some((cf) => nonTestTscPathsFrom(cf.output, dir).length > 0);
+
     const onlyFailedCommands =
       preVerificationProblems === 0 &&
       !evidenceProblemAdded &&
       failures.length > 0 &&
       postCommandProblems - preVerificationProblems === failures.length;
     const everyCommandNamedAFile = failures.length > 0 && namedByCommand.every((files) => files.length > 0);
-    if (onlyFailedCommands && everyCommandNamedAFile && Array.isArray(redByDesignClaimFiles) && redByDesignClaimFiles.length > 0) {
+    if (onlyFailedCommands && !nonTestTsc && everyCommandNamedAFile && Array.isArray(redByDesignClaimFiles) && redByDesignClaimFiles.length > 0) {
       const claimSet = new Set(redByDesignClaimFiles);
       if (allNamed.every((f) => claimSet.has(f))) return "expected-red";
     }

package/node_modules/@dougharness/gates/lib/checkpoint.mjs

@@ -43,7 +43,7 @@ export function refName(at = new Date()) {
 
 export function commitMessage(cfg, gateResults) {
   const head = (cfg.checkpoint && cfg.checkpoint.message) || DEFAULT_MESSAGE;
-  const gate = (gateResults || []).map((r) => `${r.name} ${r.ok ? "ok" : "failed"}`).join(", ");
+  const gate = (gateResults || []).map((r) => `${r.name}${r.targeted ? ` (targeted: ${r.targeted} files)` : ""} ${r.ok ? "ok" : "failed"}`).join(", ");
   return gate ? `${head}\n\ngate: ${gate}` : head;
 }
 

package/node_modules/@dougharness/gates/lib/config.mjs

@@ -83,6 +83,9 @@ export const DEFAULTS = Object.freeze({
   // Per-subagent cap on WebSearch plus WebFetch calls (scripts/research-cap.mjs, card research-fetch-cap): null
   // or 0 turns it off. The main session is never capped.
   research: { maxFetches: 6 },
+  // Card autopilot-unlimited: the context percentage (1..100) at which `/doug-next --auto` ends and hands off; read by
+  // doug-flow's scripts/context.mjs. A value that is not a finite number in that range folds back to 60 (loadConfig).
+  autopilot: { contextThreshold: 60 },
 });
 
 export function projectDir(input) {
@@ -152,6 +155,22 @@ function normaliseArrayShapes(cfg) {
   }
 }
 
+function normaliseAutopilot(cfg) {
+  const a = cfg.autopilot;
+  if (a === null || typeof a !== "object" || Array.isArray(a)) {
+    cfg.autopilot = { ...DEFAULTS.autopilot };
+    return;
+  }
+  const v = a.contextThreshold;
+  if (v === undefined || v === null) {
+    cfg.autopilot = { ...a, contextThreshold: DEFAULTS.autopilot.contextThreshold };
+    return;
+  }
+  if (typeof v === "number" && Number.isFinite(v) && v >= 1 && v <= 100) return;
+  process.stderr.write(`[doug] ${CONFIG_RELPATH} autopilot.contextThreshold must be a number from 1 to 100; using the default\n`);
+  cfg.autopilot = { ...a, contextThreshold: DEFAULTS.autopilot.contextThreshold };
+}
+
 export function loadConfig(dir) {
   const file = join(dir, CONFIG_RELPATH);
   if (!existsSync(file)) return { ...DEFAULTS, _present: false };
@@ -159,6 +178,7 @@ export function loadConfig(dir) {
     const raw = JSON.parse(readFileSync(file, "utf8"));
     const merged = { ...deepMerge(DEFAULTS, raw), _present: true };
     normaliseArrayShapes(merged);
+    normaliseAutopilot(merged);
     return merged;
   } catch (err) {
     // A broken config must never silently disable gates. Fall back to defaults and say so.

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

@@ -0,0 +1,95 @@
+// card gate-docs-skip-unless-named: the docs rule shared by the Stop gate and the pre-commit hook
+// (.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:
+// "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 =
+// the repo; prints "skip", or "targeted" then one file per line; prints nothing for the full gate.
+
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const TEST_FILE = /\.test\.(mjs|js|ts|cjs)$/;
+const CODE_FILE = /\.(mjs|js|ts|cjs|sh)$/;
+// Only plainly shell-safe paths are handed to a command line; anything else runs the full gate.
+const SAFE_PATH = /^[A-Za-z0-9_.@+/-]+$/;
+
+export function isDocsMarkdown(p) {
+  return typeof p === "string" && p.startsWith("docs/") && p.endsWith(".md");
+}
+
+function noTestHit(list, p) {
+  return list.some((e) => (e.endsWith("/") ? p.startsWith(e) : p === e));
+}
+
+function validList(cfg) {
+  const list = cfg && cfg.preCommit && cfg.preCommit.noTestPaths;
+  return Array.isArray(list) && list.length > 0 && list.every((e) => typeof e === "string" && e !== "") ? list : null;
+}
+
+// -> 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 found = [];
+  for (const f of tracked) {
+    const isTest = TEST_FILE.test(f);
+    const underTests = f.startsWith("tests/") || f.includes("/tests/");
+    const code = CODE_FILE.test(f) && !f.startsWith("docs/");
+    if (!isTest && !underTests && !code) continue;
+    if (f.startsWith("docs/")) continue;
+    const text = readFileSync(join(dir, f), "utf8");
+    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);
+  }
+  return found.sort();
+}
+
+// preCommit.docsTests: absent or [] -> []; otherwise the entries, or null when malformed or not a tracked file.
+function docsTestsList(cfg, tracked) {
+  const v = cfg && cfg.preCommit && cfg.preCommit.docsTests;
+  if (v === undefined) return [];
+  if (!Array.isArray(v) || !v.every((e) => typeof e === "string" && e !== "")) return null;
+  const set = new Set(tracked);
+  return v.every((e) => set.has(e)) ? v : null;
+}
+
+// moved: the changed paths (Set or array). Returns { kind: "skip" } | { kind: "targeted", files } | null.
+export function docsGateDecision(dir, cfg, moved) {
+  try {
+    const list = validList(cfg);
+    if (!list) return null;
+    const paths = [...moved];
+    if (paths.length === 0 || !paths.every((p) => typeof p === "string" && p !== "")) return null;
+    const docs = paths.filter((p) => !noTestHit(list, p));
+    if (docs.length === 0 || !docs.every(isDocsMarkdown)) return null;
+    const raw = execFileSync("git", ["ls-files", "-z"], { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 10000, maxBuffer: 64 * 1024 * 1024 });
+    const tracked = raw.split("\0").filter(Boolean);
+    const named = namingTests(dir, docs, tracked);
+    const extra = docsTestsList(cfg, tracked);
+    if (!named || !extra) return null;
+    const files = [...new Set([...named, ...extra])].sort();
+    if (files.length === 0) return { kind: "skip" };
+    if (!files.every((f) => SAFE_PATH.test(f))) return null;
+    return { kind: "targeted", files };
+  } catch {
+    return null;
+  }
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  try {
+    const cfg = JSON.parse(process.env.DOUG_NO_TEST_CONFIG);
+    const staged = readFileSync(0, "utf8").split("\n").filter((l) => l !== "");
+    const d = docsGateDecision(process.cwd(), cfg, staged);
+    if (d && d.kind === "skip") process.stdout.write("skip\n");
+    else if (d) process.stdout.write(`targeted\n${d.files.join("\n")}\n`);
+  } catch {
+    // no output: the hook runs the full gate
+  }
+}

package/node_modules/@dougharness/gates/lib/evidence.mjs

@@ -20,6 +20,8 @@ export const RUNNER_PATTERNS = [
   /\bgradle\w*\b.*\btest\b/,
   /\bdotnet\s+test\b/,
   /\bmake\s+(test|check)\b/,
+  // card verified-tree-record: the vendored or plugin verify.mjs only; a project's own verify.mjs must not count.
+  /(\.doug\/hooks|doug-gates)\/scripts\/verify\.mjs\b/,
 ];
 
 // The commands the stop gate runs, by name, plus every other configured project command except install.

package/node_modules/@dougharness/gates/lib/run.mjs

@@ -6,6 +6,10 @@ import { spawnSync } from "node:child_process";
 export function commandEnv(base = process.env) {
   const env = { ...base, CI: base.CI ?? "1", NO_COLOR: "1" };
   delete env.FORCE_COLOR;
+  // card worktree-gate-mixed-tree-agent: the stop gate's per-tree plumbing never reaches the commands it runs.
+  delete env.DOUG_STOP_GATE_TREE;
+  delete env.DOUG_STOP_GATE_DEADLINE;
+  delete env.DOUG_STOP_GATE_CHILD;
   return env;
 }
 

package/node_modules/@dougharness/gates/lib/state.mjs

@@ -93,6 +93,11 @@ export function emptyState() {
     // the Decide card stop-gate-honours-tester-claim's to add. Absent from an old state file loads as null
     // via the emptyState spread above.
     redByDesignClaim: null,
+    // Test totals per verification command, { [command]: { total, skipped, todo } } (card test-count-ratchet):
+    // copied from the last-green record (.doug/.state/test-totals.json) by session-start-baseline.mjs in the same
+    // write as `baseline`, never overwritten once non-null. The Stop gate compares against this, never against
+    // the file, so a session cannot lower its own bar by going green. null = no baseline, no count check.
+    testTotals: null,
     // context (card context-window-handoff): { pct, at, notifiedAt? } — absent until the status line first
     // records a reading (statusline.mjs), so not a default key here. pct and at are written by the status line
     // on every rounded-pct change; notifiedAt is written by the Stop gate (stop-gate.mjs) when it notices, and

package/node_modules/@dougharness/gates/lib/test-totals.mjs

@@ -0,0 +1,139 @@
+// Test-count ratchet (card test-count-ratchet): pure logic for parsing a vitest summary, comparing it with a
+// baseline, and matching a waiver. The Stop gate calls it; nothing here touches the filesystem or throws.
+//
+// Known limits, stated on purpose:
+//   - Counts cannot see delete-one-add-one: a session that removes a test and adds an unrelated one keeps
+//     every number level and passes.
+//   - The verified-unchanged skip runs no test command, so there is no output to count there; no count check
+//     happens on it. (The pre-commit credit path is counted from the totals the hook records in last-run.json.)
+//   - The baseline is the number of `Tests` summaries a command prints plus their sum (ADR 0013): a session
+//     that adds or removes a package changes the number of summaries and blocks with no waiver until a new
+//     baseline is taken.
+//   - Runners other than vitest print no `Tests` summary in this shape: no summary is parsed, no check runs.
+
+const ANSI_RE = /\u001b\[[0-9;]*m/g;
+
+export function stripAnsi(text) {
+  return String(text).replace(ANSI_RE, "");
+}
+
+const SEGMENT_RE = /^(\d+) (failed|passed|skipped|todo)$/;
+const TESTS_LINE_RE = /^\s*Tests\s+(.+?)\s*$/;
+const TOTAL_RE = /^(.*) \((\d+)\)$/;
+
+// One line's value part ("1 failed | 2 passed | 3 skipped (6)") -> { total, skipped, todo } or null.
+function parseSummaryValue(value) {
+  const m = TOTAL_RE.exec(value);
+  if (!m) return null;
+  const counts = { skipped: 0, todo: 0 };
+  for (const seg of m[1].split(" | ")) {
+    const s = SEGMENT_RE.exec(seg.trim());
+    if (!s) return null;
+    if (s[2] === "skipped" || s[2] === "todo") counts[s[2]] = Number(s[1]);
+  }
+  return { total: Number(m[2]), skipped: counts.skipped, todo: counts.todo };
+}
+
+// Every `Tests` summary line is kept as its own entry, in output order; a byte-identical duplicate counts
+// twice (ADR 0013: the number of summaries is part of the baseline).
+// -> { status: "ok", summaries: [{ total, skipped, todo }, ...], totals: <their sum> } | { status: "none" }
+export function parseTotals(output) {
+  try {
+    if (typeof output !== "string") return { status: "none" };
+    const summaries = [];
+    for (const line of stripAnsi(output).split(/\r?\n/)) {
+      const m = TESTS_LINE_RE.exec(line);
+      if (!m) continue;
+      const parsed = parseSummaryValue(m[1]);
+      if (parsed) summaries.push(parsed);
+    }
+    if (summaries.length === 0) return { status: "none" };
+    return { status: "ok", summaries, totals: sumTotals(summaries) };
+  } catch {
+    return { status: "none" };
+  }
+}
+
+// Field-wise sum of a list of { total, skipped, todo }.
+export function sumTotals(summaries) {
+  const out = { total: 0, skipped: 0, todo: 0 };
+  for (const s of summaries) {
+    out.total += s.total;
+    out.skipped += s.skipped;
+    out.todo += s.todo;
+  }
+  return out;
+}
+
+// Reads a baseline entry or a recorded parseTotals result in any shape -> a list of valid summaries, or null.
+// A list; an old { total, skipped, todo } (a list of one); a recorded { status: "ok", summaries }; an old
+// recorded { status: "ok", totals } (a list of one); an old recorded { status: "conflict", summaries }.
+// Never throws.
+export function readSummaries(x) {
+  try {
+    let list;
+    if (Array.isArray(x)) list = x;
+    else if (x && typeof x === "object") {
+      if (x.status === "ok") list = Array.isArray(x.summaries) ? x.summaries : [x.totals];
+      else if (x.status === "conflict") list = x.summaries;
+      else if (x.status === undefined) list = [x];
+      else return null;
+    } else return null;
+    if (!Array.isArray(list) || list.length === 0) return null;
+    const out = list.map(validTotals);
+    return out.every((s) => s) ? out : null;
+  } catch {
+    return null;
+  }
+}
+
+const isCount = (n) => Number.isInteger(n) && n >= 0;
+
+// A baseline entry usable for comparison, or null.
+export function validTotals(t) {
+  if (!t || typeof t !== "object") return null;
+  if (!isCount(t.total) || !isCount(t.skipped) || !isCount(t.todo)) return null;
+  return { total: t.total, skipped: t.skipped, todo: t.todo };
+}
+
+// Total dropped, or skipped/todo rose. A rise in total or a drop in skipped/todo is never a problem.
+export function compareTotals(baseline, now) {
+  const out = [];
+  if (now.total < baseline.total) out.push({ kind: "total", baseline: baseline.total, now: now.total });
+  if (now.skipped > baseline.skipped) out.push({ kind: "skipped", baseline: baseline.skipped, now: now.skipped });
+  if (now.todo > baseline.todo) out.push({ kind: "todo", baseline: baseline.todo, now: now.todo });
+  return out;
+}
+
+export function deltaTotals(baseline, now) {
+  return { total: now.total - baseline.total, skipped: now.skipped - baseline.skipped, todo: now.todo - baseline.todo };
+}
+
+const WAIVER_RE = /^test-count-waiver: total=([+-]?\d+) skipped=([+-]?\d+) todo=([+-]?\d+);(.*)$/;
+
+// One line -> { total, skipped, todo, reason } or null. The reason must be non-empty after trimming.
+export function parseWaiver(line) {
+  if (typeof line !== "string") return null;
+  const m = WAIVER_RE.exec(line.trim());
+  if (!m) return null;
+  const reason = m[4].trim();
+  if (!reason) return null;
+  return { total: Number(m[1]) + 0, skipped: Number(m[2]) + 0, todo: Number(m[3]) + 0, reason };
+}
+
+// sources: strings, each possibly several lines. Covers only when all three deltas equal the actual ones.
+export function waiverCovers(sources, delta) {
+  try {
+    if (!Array.isArray(sources)) return false;
+    for (const src of sources) {
+      if (typeof src !== "string") continue;
+      for (const line of src.split(/\r?\n/)) {
+        const w = parseWaiver(line);
+        if (w && w.total === delta.total && w.skipped === delta.skipped && w.todo === delta.todo) return true;
+      }
+    }
+  } catch {
+    // a broken source never covers
+  }
+  return false;
+}

package/node_modules/@dougharness/gates/lib/trace.mjs

@@ -7,6 +7,7 @@
 
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { scanText } from "./secret-rules.mjs";
 
 export const TRACE_DIR_RELPATH = ".doug/.state/trace";
 
@@ -28,11 +29,27 @@ function clip(s, n = 120) {
 
 // A one-line summary of a tool's input: the command, the file, the pattern, or the description. Never the whole input.
 // "skill" (card learn-signals) records a Skill tool call's skill name, so trace-derived signals can count
-// which skills actually get invoked.
-export function detailOf(toolInput) {
+// which skills actually get invoked. Card trace-redact-secrets: the full source string is scanned (scanText, the
+// same secrets config as secret-scan) before clipping; a hit records "[redacted: <rule>]", a scanner error
+// records "[redacted: scan-error]" (fail closed to redacting, never throws). Card trace-redact-reason: redactOrClip
+// is that scan-then-clip, shared by detailOf and the PermissionDenied reason.
+export function redactOrClip(s, secrets = {}) {
+  try {
+    if (!(secrets && secrets.enabled === false)) {
+      const hit = scanText(s, secrets || {});
+      if (hit) return "[redacted: " + hit.rule + "]";
+    }
+  } catch {
+    return "[redacted: scan-error]";
+  }
+  return clip(s);
+}
+
+export function detailOf(toolInput, secrets = {}) {
   if (!toolInput || typeof toolInput !== "object") return null;
   for (const key of ["command", "file_path", "notebook_path", "pattern", "description", "prompt", "url", "skill"]) {
-    if (typeof toolInput[key] === "string" && toolInput[key].trim()) return clip(toolInput[key]);
+    const s = toolInput[key];
+    if (typeof s === "string" && s.trim()) return redactOrClip(s, secrets);
   }
   return null;
 }
@@ -90,9 +107,9 @@ export function usageFromTranscript(file) {
 // same as every other event here: InstructionsLoaded's `detail` is the loaded file's path and its `reason` the
 // matcher's load_reason ("session_start", "path_glob_match", ...) - `file_content` is never read off the input,
 // so it can never end up on the line even by accident. PermissionDenied's `detail` is the denied tool's input
-// (via detailOf, same as a Pre/PostToolUse line), `ok` is forced false, and `reason` is the clipped denial_reason.
+// (via detailOf, same as a Pre/PostToolUse line), `ok` is forced false, and `reason` is the denial_reason via redactOrClip (secret-scanned, then clipped).
 // Every other event's `reason` is null.
-export function traceLine(input, { now = new Date(), context = null } = {}) {
+export function traceLine(input, { now = new Date(), context = null, secrets } = {}) {
   const event = input.hook_event_name || null;
   const response = input.tool_response ?? input.tool_output ?? null;
   let ok = null;
@@ -105,10 +122,10 @@ export function traceLine(input, { now = new Date(), context = null } = {}) {
   let detail = null;
   let reason = null;
   if (event === "PreToolUse" || event === "PostToolUse" || event === "PermissionDenied") {
-    detail = detailOf(input.tool_input);
+    detail = detailOf(input.tool_input, secrets);
   }
   if (event === "PermissionDenied") {
-    reason = typeof input.denial_reason === "string" && input.denial_reason.trim() ? clip(input.denial_reason, 120) : null;
+    reason = typeof input.denial_reason === "string" && input.denial_reason.trim() ? redactOrClip(input.denial_reason, secrets) : null;
   } else if (event === "InstructionsLoaded") {
     detail = typeof input.file_path === "string" && input.file_path ? input.file_path : null;
     reason = typeof input.load_reason === "string" && input.load_reason ? input.load_reason : null;