tamperward 2.29.14 → 2.29.16

package/dist/cli/index.js

@@ -1381,6 +1381,38 @@ import { execFileSync as execFileSync4 } from "node:child_process";
 import { writeFileSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { isAbsolute as isAbsolute4, join as join5, relative, resolve as resolve2 } from "node:path";
+function sideSize(s) {
+  if (s == null) return { bytes: 0, lines: 0 };
+  let lines = 1;
+  for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) === 10) lines++;
+  return { bytes: Buffer.byteLength(s), lines };
+}
+function overReconstructCeiling(before, after) {
+  const maxBytes = RECONSTRUCT_MAX_BYTES();
+  const maxLines = RECONSTRUCT_MAX_LINES();
+  for (const [label, side] of [["before", before], ["after", after]]) {
+    const { bytes, lines } = sideSize(side);
+    if (bytes > maxBytes) return `${label} is ${bytes} bytes (over the ${maxBytes}-byte reconstruction budget)`;
+    if (lines > maxLines) return `${label} is ${lines} lines (over the ${maxLines}-line reconstruction budget)`;
+  }
+  return null;
+}
+function linearFallbackHunks(before, after) {
+  const b = before == null ? [] : before.split("\n");
+  const a = after == null ? [] : after.split("\n");
+  let p = 0;
+  while (p < b.length && p < a.length && b[p] === a[p]) p++;
+  let s = 0;
+  while (s < b.length - p && s < a.length - p && b[b.length - 1 - s] === a[a.length - 1 - s]) s++;
+  const delContent = b.slice(p, b.length - s);
+  const addContent = a.slice(p, a.length - s);
+  if (delContent.length === 0 && addContent.length === 0) return [];
+  const lines = [
+    ...delContent.map((content, i) => ({ type: "del", content, oldLine: p + 1 + i, newLine: null })),
+    ...addContent.map((content, i) => ({ type: "add", content, oldLine: null, newLine: p + 1 + i }))
+  ];
+  return [{ oldStart: p + 1, oldLines: delContent.length, newStart: p + 1, newLines: addContent.length, lines }];
+}
 function asStr(v) {
   return typeof v === "string" ? v : "";
 }
@@ -1402,31 +1434,39 @@ function synthFileChange(displayPath, before, after) {
   if (before === null) op = "add";
   else if (after === null) op = "delete";
   else op = "modify";
+  const over = overReconstructCeiling(before, after);
+  if (over) {
+    throw new Error(`cannot safely reconstruct the incoming edit to ${displayPath} within the hook budget: ${over}`);
+  }
+  const mk = (hunks) => [
+    { kind: "file", path: displayPath, oldPath: null, op, before, after, binary: false, hunks }
+  ];
   const dir = mkdtempSync(join5(tmpdir2(), "hf-"));
-  let raw = "";
   try {
     const a = join5(dir, "a");
     const b = join5(dir, "b");
     writeFileSync(a, before ?? "");
     writeFileSync(b, after ?? "");
     try {
-      raw = execFileSync4("git", ["diff", "--no-index", "--no-color", "--text", a, b], {
+      const raw = execFileSync4("git", ["diff", "--no-index", "--no-color", "--text", a, b], {
         encoding: "utf8",
-        maxBuffer: 256 * 1024 * 1024
+        maxBuffer: RECONSTRUCT_MAXBUFFER(),
+        timeout: RECONSTRUCT_TIMEOUT_MS(),
+        killSignal: "SIGKILL"
       });
+      const first = parseDiff(raw)[0];
+      return mk(first && first.kind === "file" ? first.hunks : []);
     } catch (e) {
       const failure = execFailure(e);
-      if (failure.status !== 1) {
-        throw new Error(`cannot diff the incoming edit to ${displayPath}: ${failure.code ?? failure.message}`);
+      if (failure.status === 1) {
+        const first = parseDiff(failure.stdout)[0];
+        return mk(first && first.kind === "file" ? first.hunks : []);
       }
-      raw = failure.stdout;
+      return mk(linearFallbackHunks(before, after));
     }
   } finally {
     rmSync(dir, { recursive: true, force: true });
   }
-  const first = parseDiff(raw)[0];
-  const hunks = first && first.kind === "file" ? first.hunks : [];
-  return [{ kind: "file", path: displayPath, oldPath: null, op, before, after, binary: false, hunks }];
 }
 function changesFromClaudeHook(input, cwd, base = cwd) {
   const ti = input.tool_input ?? {};
@@ -1471,12 +1511,22 @@ function changesFromClaudeHook(input, cwd, base = cwd) {
       return [];
   }
 }
+var num, RECONSTRUCT_TIMEOUT_MS, RECONSTRUCT_MAXBUFFER, RECONSTRUCT_MAX_BYTES, RECONSTRUCT_MAX_LINES;
 var init_changes = __esm({
   "src/adapters/claude/changes.ts"() {
     "use strict";
     init_parse();
     init_disk();
     init_narrow();
+    num = (name, fallback) => {
+      const raw = process.env[name];
+      const n = raw === void 0 ? NaN : Number(raw);
+      return Number.isFinite(n) && n > 0 ? n : fallback;
+    };
+    RECONSTRUCT_TIMEOUT_MS = () => num("TAMPERWARD_RECONSTRUCT_TIMEOUT_MS", 5e3);
+    RECONSTRUCT_MAXBUFFER = () => num("TAMPERWARD_RECONSTRUCT_MAXBUFFER", 32 * 1024 * 1024);
+    RECONSTRUCT_MAX_BYTES = () => num("TAMPERWARD_RECONSTRUCT_MAX_BYTES", 384 * 1024);
+    RECONSTRUCT_MAX_LINES = () => num("TAMPERWARD_RECONSTRUCT_MAX_LINES", 4e3);
   }
 });
 
@@ -3337,6 +3387,7 @@ var init_no_verify = __esm({
 
 // src/ts-lazy.ts
 import { createRequire as createRequire2 } from "node:module";
+import { createHash as createHash2 } from "node:crypto";
 function loadTs() {
   if (loaded === null) {
     const required = createRequire2(import.meta.url)("typescript");
@@ -3357,17 +3408,37 @@ function nestsWithinCeiling(src) {
   return true;
 }
 function parseSource(fileName, src, kind) {
-  if (Buffer.byteLength(src) > MAX_PARSE_BYTES) return null;
-  if (!nestsWithinCeiling(src)) return null;
-  const t = loadTs();
-  try {
-    return t.createSourceFile(fileName, src, t.ScriptTarget.Latest, true, kind ?? t.ScriptKind.TS);
-  } catch (e) {
-    if (e instanceof RangeError) return null;
-    throw e;
+  const bytes = Buffer.byteLength(src);
+  if (bytes > MAX_PARSE_BYTES) return null;
+  const key2 = `${kind ?? ""}\0${fileName}\0${createHash2("sha256").update(src).digest("hex")}`;
+  const at = parseCache.findIndex((e) => e.key === key2);
+  if (at !== -1) {
+    const [entry] = parseCache.splice(at, 1);
+    parseCache.push(entry);
+    return entry.sf;
+  }
+  let sf;
+  if (!nestsWithinCeiling(src)) {
+    sf = null;
+  } else {
+    const t = loadTs();
+    try {
+      sf = t.createSourceFile(fileName, src, t.ScriptTarget.Latest, true, kind ?? t.ScriptKind.TS);
+    } catch (e) {
+      if (e instanceof RangeError) sf = null;
+      else throw e;
+    }
   }
+  parseCache.push({ key: key2, sf, bytes });
+  parseCacheBytes += bytes;
+  while (parseCache.length > PARSE_CACHE_MAX_ENTRIES || parseCacheBytes > PARSE_CACHE_MAX_BYTES) {
+    const evicted = parseCache.shift();
+    if (!evicted) break;
+    parseCacheBytes -= evicted.bytes;
+  }
+  return sf;
 }
-var loaded, handler, ts, MAX_PARSE_BYTES, MAX_PARSE_DEPTH;
+var loaded, handler, ts, MAX_PARSE_BYTES, MAX_PARSE_DEPTH, PARSE_CACHE_MAX_ENTRIES, PARSE_CACHE_MAX_BYTES, parseCache, parseCacheBytes;
 var init_ts_lazy = __esm({
   "src/ts-lazy.ts"() {
     "use strict";
@@ -3390,6 +3461,10 @@ var init_ts_lazy = __esm({
     ts = new Proxy(/* @__PURE__ */ Object.create(null), handler);
     MAX_PARSE_BYTES = 4 * 1024 * 1024;
     MAX_PARSE_DEPTH = 256;
+    PARSE_CACHE_MAX_ENTRIES = 32;
+    PARSE_CACHE_MAX_BYTES = 24 * 1024 * 1024;
+    parseCache = [];
+    parseCacheBytes = 0;
   }
 });
 
@@ -6903,10 +6978,10 @@ function lex(src) {
       i = j + 1;
       continue;
     }
-    const num = src.slice(i).match(/^-?\d+(?:\.\d+)?/);
-    if (num) {
-      out3.push({ t: "num", v: num[0] });
-      i += num[0].length;
+    const num2 = src.slice(i).match(/^-?\d+(?:\.\d+)?/);
+    if (num2) {
+      out3.push({ t: "num", v: num2[0] });
+      i += num2[0].length;
       continue;
     }
     const op = src.slice(i).match(/^(?:==|!=|&&|\|\||<=|>=|[!()<>,[\]])/);
@@ -6931,13 +7006,13 @@ function foldConst(src) {
   let p = 0;
   const peek = () => toks[p];
   const eat = (v2) => toks[p]?.t === "op" && toks[p].v === v2 ? (p++, true) : false;
-  const num = (v2) => v2 === TRUTHY ? NaN : typeof v2 === "number" ? v2 : typeof v2 === "boolean" ? v2 ? 1 : 0 : v2 === null ? 0 : v2.trim() === "" ? 0 : Number(v2);
+  const num2 = (v2) => v2 === TRUTHY ? NaN : typeof v2 === "number" ? v2 : typeof v2 === "boolean" ? v2 ? 1 : 0 : v2 === null ? 0 : v2.trim() === "" ? 0 : Number(v2);
   const eq = (a, b) => {
     if (a === TRUTHY || b === TRUTHY) return void 0;
     if (typeof a === "string" && typeof b === "string") return a.toLowerCase() === b.toLowerCase();
     if (a === null && b === null) return true;
-    const x = num(a);
-    const y2 = num(b);
+    const x = num2(a);
+    const y2 = num2(b);
     return !Number.isNaN(x) && x === y2;
   };
   const or = () => {
@@ -6975,8 +7050,8 @@ function foldConst(src) {
         const e = eq(l, r);
         l = e === void 0 ? void 0 : t.v === "==" ? e : !e;
       } else {
-        const x = num(l);
-        const y2 = num(r);
+        const x = num2(l);
+        const y2 = num2(r);
         if (Number.isNaN(x) || Number.isNaN(y2)) l = void 0;
         else l = t.v === "<" ? x < y2 : t.v === ">" ? x > y2 : t.v === "<=" ? x <= y2 : x >= y2;
       }
@@ -9914,6 +9989,14 @@ var init_test_content_removal = __esm({
     KeptPool = class {
       text = "";
       inLiteral = [];
+      // O(1) fast path (#517): the ws-text of each kept significant line whose retained
+      // text BEGINS at a code position (inLiteral 0). A removed line whose ws-text equals
+      // one of these is kept — necessarily the SAME answer `indexOf` gives, since that exact
+      // text then occurs in `text` at a code position — but in O(1) instead of scanning the
+      // whole concatenated pool per removed line (a 20k-line high-churn spec was O(n²) here,
+      // ~13s, #517). The substring scan below is unchanged and still covers rewrapped/joined
+      // lines and moved fixtures, so `keeps` returns exactly what it did before.
+      wholeCodeLines = /* @__PURE__ */ new Set();
       addLive(src, path) {
         const p = partition(src, path);
         const lang = langOf(path);
@@ -9922,11 +10005,16 @@ var init_test_content_removal = __esm({
           if (i < p.live.length && p.live[i] !== "\n") continue;
           const line = p.live.slice(lineStart, i);
           if (isSignificantLine(line.trim(), lang)) {
+            let lineWs = "";
+            let startsAtCode = false;
             for (let j = lineStart; j < i; j++) {
               if (/\s/.test(p.live[j])) continue;
+              if (lineWs.length === 0) startsAtCode = p.inLiteral[j] === 0;
               this.text += p.live[j];
               this.inLiteral.push(p.inLiteral[j]);
+              lineWs += p.live[j];
             }
+            if (lineWs.length > 0 && startsAtCode) this.wholeCodeLines.add(lineWs);
           }
           lineStart = i + 1;
         }
@@ -9938,6 +10026,7 @@ var init_test_content_removal = __esm({
       }
       keeps(wsLine) {
         if (wsLine.length === 0) return true;
+        if (this.wholeCodeLines.has(wsLine)) return true;
         let at = this.text.indexOf(wsLine);
         while (at !== -1) {
           if (this.inLiteral[at] === 0) return true;
@@ -10763,7 +10852,7 @@ var init_policy_load = __esm({
 });
 
 // src/signoff.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { appendFileSync, mkdirSync, readFileSync as readFileSync6, existsSync as existsSync6 } from "node:fs";
 import { dirname as dirname2, join as join9 } from "node:path";
 function ledgerEntryFrom(value) {
@@ -10775,7 +10864,7 @@ function ledgerEntryFrom(value) {
   return { rule, ...file !== void 0 ? { file } : {}, fingerprint: fingerprint2, reason, recordedAt, expiresAt };
 }
 function fingerprint(rule, file, evidence) {
-  return createHash2("sha256").update(`${rule}\0${file ?? ""}\0${evidence}`).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(`${rule}\0${file ?? ""}\0${evidence}`).digest("hex").slice(0, 16);
 }
 function ledgerPath(cwd, policy) {
   const rel = policy.signoff?.ledger ?? ".tamperward/ledger.jsonl";
@@ -11335,7 +11424,7 @@ var init_session = __esm({
 });
 
 // src/effect.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { existsSync as existsSync8, lstatSync as lstatSync3, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync8, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { join as join11 } from "node:path";
 function ptreeFrom(value) {
@@ -11478,19 +11567,19 @@ var init_effect = __esm({
     init_narrow();
     UNSAFE2 = /[^A-Za-z0-9._-]/g;
     SKIP_DIRS2 = /* @__PURE__ */ new Set([".git", "node_modules", ".hg", ".svn"]);
-    sha = (buf) => createHash3("sha256").update(buf).digest("hex").slice(0, 16);
+    sha = (buf) => createHash4("sha256").update(buf).digest("hex").slice(0, 16);
   }
 });
 
 // src/cli/watch.ts
 import { appendFileSync as appendFileSync3, lstatSync as lstatSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync9, readdirSync as readdirSync2, watch, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join12 } from "node:path";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function snap(abs) {
   const e = inspectPath(abs);
   if (e.kind === "absent" || e.kind === "unreadable") return { mode: null, size: null, hash: null };
   if (e.kind !== "file" || e.content == null) return { mode: e.mode, size: null, hash: null };
-  const hash = createHash4("sha256").update(e.content).digest("hex").slice(0, 16);
+  const hash = createHash5("sha256").update(e.content).digest("hex").slice(0, 16);
   return { mode: e.mode, size: e.size, hash };
 }
 function defaultEventLog(cwd) {
@@ -12003,15 +12092,15 @@ var init_fs_events = __esm({
 });
 
 // src/cli/audit.ts
-import { createHash as createHash5, randomBytes } from "node:crypto";
+import { createHash as createHash6, randomBytes } from "node:crypto";
 import { appendFileSync as appendFileSync4, existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync10 } from "node:fs";
 import { dirname as dirname4, isAbsolute as isAbsolute8, join as join13, resolve as resolve4 } from "node:path";
 function sessionHash(sessionId) {
   if (!sessionId) return void 0;
-  return "sha256:" + createHash5("sha256").update(sessionId).digest("hex").slice(0, 24);
+  return "sha256:" + createHash6("sha256").update(sessionId).digest("hex").slice(0, 24);
 }
 function eventId() {
-  return "sha256:" + createHash5("sha256").update(randomBytes(32)).digest("hex").slice(0, 32);
+  return "sha256:" + createHash6("sha256").update(randomBytes(32)).digest("hex").slice(0, 32);
 }
 function configuredAuditPath(cwd, env = process.env) {
   const value = env[AUDIT_LOG_ENV];
@@ -12240,7 +12329,7 @@ var init_audit = __esm({
 
 // src/cli/hook.ts
 import { readFileSync as readFileSync11, appendFileSync as appendFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "node:fs";
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function setSnapshotCache(cache3) {
   snapshotCache = cache3;
 }
@@ -12478,7 +12567,7 @@ function sanctionPredictedWrites(cwd, sessionId, policy, changes) {
   let dirty = false;
   for (const c of changes) {
     if (c.kind !== "file" || c.after == null || !isProtected(c.path, policy)) continue;
-    const hash = createHash6("sha256").update(c.after).digest("hex").slice(0, 16);
+    const hash = createHash7("sha256").update(c.after).digest("hex").slice(0, 16);
     const prev = tree[c.path];
     tree[c.path] = {
       hash,
@@ -13325,7 +13414,7 @@ var init_safe_write = __esm({
 
 // src/cli/init.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync13, realpathSync as realpathSync5 } from "node:fs";
 import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute9, join as join15, relative as relative3, resolve as resolve5 } from "node:path";
 function gitConfig(cwd, key2) {
@@ -13375,7 +13464,7 @@ function stalePin(command) {
   return pin !== null && (pin !== TW_VERSION || !OURS.test(command));
 }
 function bodyHash(body) {
-  return createHash7("sha256").update(body).digest("hex").slice(0, 16);
+  return createHash8("sha256").update(body).digest("hex").slice(0, 16);
 }
 function workflowFile(body) {
   return `${WORKFLOW_MARK} v${TW_VERSION} sha256:${bodyHash(body)}
@@ -14120,7 +14209,7 @@ jobs:
 
 // src/fingerprint.ts
 import { execFileSync as execFileSync7 } from "node:child_process";
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 function treeFingerprint(cwd, keepIgnored) {
   const listed = execFileSync7("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd,
@@ -14129,7 +14218,7 @@ function treeFingerprint(cwd, keepIgnored) {
     env: trustedGitEnv()
   }).split("\0").filter(Boolean);
   const files = [.../* @__PURE__ */ new Set([...listed, ...keepIgnored ? ignoredPaths({ cwd }, keepIgnored) : []])].sort();
-  const h = createHash8("sha256");
+  const h = createHash9("sha256");
   for (const rel of files) {
     h.update(rel);
     h.update("\0");
@@ -14153,7 +14242,7 @@ var init_fingerprint = __esm({
 });
 
 // src/dependency-env.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import {
   existsSync as existsSync13,
   lstatSync as lstatSync8,
@@ -14306,7 +14395,7 @@ function fingerprintRoot(root, cwd, h) {
   walk2(root.realPath, "");
 }
 function snapshot(roots, probes, cwd) {
-  const h = createHash9("sha256");
+  const h = createHash10("sha256");
   for (const probe of probes) {
     h.update(
       "probe\0" + probe.kind + "\0" + probe.path + "\0" + (existsSync13(probe.path) ? "present" : "absent") + "\0"
@@ -14640,6 +14729,7 @@ function parseCapturedSupervisorResult(stdoutText) {
     signal: typeof raw.signal === "string" ? raw.signal : null,
     timedOut: Boolean(raw.timedOut),
     ...typeof raw.error === "string" && raw.error ? { error: raw.error } : {},
+    ...raw.pipeHeldOpen === true ? { pipeHeldOpen: true } : {},
     diagnostics
   };
 }
@@ -14657,6 +14747,7 @@ function runCapturedProcessSync(executable, args, opts) {
         timeoutMs: opts.timeoutMs,
         detached: Boolean(opts.detached),
         killGroupOnFinish: Boolean(opts.killGroupOnFinish),
+        drainMs: opts.drainMs ?? 1e3,
         captureBytes: DIAGNOSTIC_TAIL_BYTES
       }),
       { mode: 384 }
@@ -14789,6 +14880,7 @@ let done = false;
 let timedOut = false;
 let exitInfo = { exit: null, signal: null };
 let descendantTracker = null;
+let drainTimer = null;
 
 function killOwned() {
   if (!child || !child.pid) return;
@@ -14810,6 +14902,7 @@ function finish(extra) {
   if (done) return;
   done = true;
   if (descendantTracker) clearInterval(descendantTracker);
+  if (drainTimer) clearTimeout(drainTimer);
   try {
     // stdout is reserved for the trusted supervisor result. Candidate suite
     // stdout/stderr are separate pipes and are never inherited here.
@@ -14864,12 +14957,19 @@ if (child) {
       signal: signal == null ? null : String(signal),
     };
     if (cfg.killGroupOnFinish) killOwned();
+    // A leaked descendant can hold a pipe open so 'close' never fires; finish off
+    // exit after a bounded drain instead of hanging. 'close' still wins if first.
+    if (!drainTimer) {
+      drainTimer = setTimeout(() => finish({ pipeHeldOpen: true }), Number(cfg.drainMs));
+      drainTimer.unref();
+    }
   });
 
   // close fires after the stdio pipes close, so the retained tails include all
   // output that was drained before owned descendants were terminated.
   child.on('close', (code, signal) => {
     clearTimeout(timer);
+    if (drainTimer) clearTimeout(drainTimer);
     if (exitInfo.exit === null && code != null) exitInfo.exit = Number(code);
     if (exitInfo.signal === null && signal != null) exitInfo.signal = String(signal);
     finish({});
@@ -14880,7 +14980,7 @@ if (child) {
 });
 
 // src/verifier-backend.ts
-import { createHash as createHash10, randomUUID } from "node:crypto";
+import { createHash as createHash11, randomUUID } from "node:crypto";
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { accessSync as accessSync2, constants as constants3, readFileSync as readFileSync16, realpathSync as realpathSync7, statSync as statSync4 } from "node:fs";
 import { delimiter as delimiter2, dirname as dirname7, join as join18, resolve as resolve7 } from "node:path";
@@ -14927,7 +15027,7 @@ function findExecutable(name) {
   return null;
 }
 function fileSha256(path) {
-  return createHash10("sha256").update(readFileSync16(path)).digest("hex");
+  return createHash11("sha256").update(readFileSync16(path)).digest("hex");
 }
 function engineClientEnv() {
   return {
@@ -15360,7 +15460,7 @@ var init_verifier_backend = __esm({
 
 // src/cli/verify.ts
 import { execFileSync as execFileSync8, spawnSync as spawnSync3 } from "node:child_process";
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 import { chmodSync as chmodSync2, cpSync, lstatSync as lstatSync9, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync3, readFileSync as readFileSync17, readlinkSync as readlinkSync3, rmSync as rmSync7, symlinkSync, writeFileSync as writeFileSync9, existsSync as existsSync14 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { dirname as dirname8, isAbsolute as isAbsolute11, join as join19, relative as relative5, resolve as resolve8, sep as sep3 } from "node:path";
@@ -15574,7 +15674,7 @@ function baseEntries(base, cwd) {
   });
 }
 function overlayDigest(dest, paths) {
-  const h = createHash11("sha256");
+  const h = createHash12("sha256");
   for (const rel of [...paths].sort()) {
     h.update(rel);
     h.update("\0");
@@ -15714,7 +15814,12 @@ function runLocalSuite(dir, cmd, budgetSecs) {
         diagnostics: r.diagnostics
       };
     }
-    return { exit: r.exit, secs, diagnostics: r.diagnostics };
+    return {
+      exit: r.exit,
+      secs,
+      ...r.pipeHeldOpen ? { pipeHeldOpen: true } : {},
+      diagnostics: r.diagnostics
+    };
   } finally {
     rmSync7(scratch, { recursive: true, force: true });
   }
@@ -15873,7 +15978,29 @@ function runVerify(opts) {
   }
   const frozenNodeModules = dependencyEnvironment ? dependencyEnvironment.roots.find((root) => root.kind === "node_modules")?.realPath ?? null : null;
   const checkDeps = () => dependencyEnvironment ? checkDependencyEnvironment(cwd, dependencyEnvironment) : { ok: true };
-  const runStage = (dir) => isolated ? runContainerStage(verifierBackend, dir, cmd, budget) : runLocalSuite(dir, cmd, budget);
+  const runStage = opts.runStage ?? ((dir) => isolated ? runContainerStage(verifierBackend, dir, cmd, budget) : runLocalSuite(dir, cmd, budget));
+  const notQuiescent = (stage, r) => {
+    const detail = `the ${stage} suite exited (code ${r.exit ?? "unknown"}) but left a process holding stdout open after termination was attempted; the stage is not quiescent, so the run cannot be certified`;
+    opts.onVerdict?.({ verdict: "CANNOT_VERIFY", reason: "VERIFIER_BACKEND_RUNTIME_FAILURE", detail });
+    if (opts.json) {
+      out3(JSON.stringify({
+        schema_version: MACHINE_SCHEMA_VERSION,
+        verdict: "CANNOT_VERIFY",
+        reason: "VERIFIER_BACKEND_RUNTIME_FAILURE",
+        stage,
+        ...caseReport(),
+        detail,
+        diagnostics: diagnosticsJson(r.diagnostics, true),
+        verifier_backend: backendReport(),
+        oracle_assurance: oracleAssuranceReport()
+      }));
+    } else {
+      out3(`verify: the ${stage} suite exited but left a process holding stdout open \u2014 the stage is not quiescent, failing closed`);
+      out3("verify: " + detail);
+      renderStageDiagnostics(out3, stage, r);
+    }
+    return 2;
+  };
   let base;
   try {
     base = resolveBase(opts.base ?? "HEAD", cwd);
@@ -15933,6 +16060,10 @@ function runVerify(opts) {
     );
   }
   const visible = runStage(visDir);
+  if (visible.pipeHeldOpen) {
+    cleanup([visRoot]);
+    return notQuiescent("visible", visible);
+  }
   if (visible.failure === "backend" || visible.failure === "resource") {
     cleanup([visRoot]);
     const exhausted = visible.failure === "resource";
@@ -16002,6 +16133,10 @@ function runVerify(opts) {
   }
   const overlayBefore = overlayDigest(priDir, restored);
   const pristine = runStage(priDir);
+  if (pristine.pipeHeldOpen) {
+    cleanup([visRoot, priRoot]);
+    return notQuiescent("pristine", pristine);
+  }
   if (pristine.failure === "backend" || pristine.failure === "resource") {
     cleanup([visRoot, priRoot]);
     const exhausted = pristine.failure === "resource";
@@ -19101,7 +19236,7 @@ var init_capture = __esm({
 });
 
 // src/research/manifest.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 import { readFileSync as readFileSync23 } from "node:fs";
 import { dirname as dirname10, resolve as resolve14 } from "node:path";
 function taskFrom(raw, index, manifestDir) {
@@ -19159,7 +19294,7 @@ function readManifest(path) {
     if (seen.has(t.id)) throw new ResearchError(`task manifest ${abs}: duplicate task id "${t.id}"`);
     seen.add(t.id);
   }
-  return { path: abs, sha256: createHash13("sha256").update(bytes).digest("hex"), tasks };
+  return { path: abs, sha256: createHash14("sha256").update(bytes).digest("hex"), tasks };
 }
 var MANIFEST_VERSION;
 var init_manifest = __esm({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "2.29.14",
+  "version": "2.29.16",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",