tamperward 2.39.3 → 2.39.5

package/dist/cli/index.js

@@ -10885,8 +10885,8 @@ var init_policy_load = __esm({
 
 // src/signoff.ts
 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";
+import { appendFileSync, closeSync as closeSync2, constants as constants3, fstatSync as fstatSync2, lstatSync as lstatSync3, mkdirSync, openSync as openSync2, readFileSync as readFileSync6 } from "node:fs";
+import { dirname as dirname2, join as join9, posix as posix4 } from "node:path";
 function compactOobToken(want, head) {
   const normalizedHead = head.trim().toLowerCase();
   if (!want || !FULL_OBJECT_ID.test(normalizedHead)) return null;
@@ -10905,17 +10905,75 @@ function fingerprint(rule, file, evidence) {
   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";
+  const rel = policy.signoff?.ledger ?? DEFAULT_LEDGER;
   if (!ledgerInsideRepo(rel)) {
     throw new PolicyError(`signoff.ledger must be a relative path inside the repository, got ${JSON.stringify(rel)}`);
   }
   return join9(cwd, rel);
 }
+function lstatOrAbsent(rel, shown, path) {
+  try {
+    return lstatSync3(path);
+  } catch (e) {
+    if (errnoCode(e) === "ENOENT") return null;
+    throw new PolicyError(
+      `signoff.ledger ${JSON.stringify(rel)}: cannot stat ${shown} (${errorMessage(e)}); refusing to treat the sign-off ledger as absent`
+    );
+  }
+}
+function kindOf(st) {
+  if (st.isSymbolicLink()) return "a symbolic link";
+  if (st.isDirectory()) return "a directory";
+  if (st.isFIFO()) return "a FIFO";
+  if (st.isSocket()) return "a socket";
+  if (st.isCharacterDevice() || st.isBlockDevice()) return "a device";
+  return "not a regular file";
+}
+function ledgerOnDisk(cwd, policy) {
+  const rel = policy.signoff?.ledger ?? DEFAULT_LEDGER;
+  ledgerPath(cwd, policy);
+  const parts = posix4.normalize(rel.replace(/\\/g, "/")).split("/").filter((part) => part && part !== ".");
+  let path = cwd;
+  for (let i = 0; i < parts.length; i++) {
+    const next = join9(path, parts[i]);
+    const shown = parts.slice(0, i + 1).join("/");
+    const st = lstatOrAbsent(rel, shown, next);
+    if (st === null) return { rel, path: join9(cwd, ...parts), exists: false };
+    const last = i === parts.length - 1;
+    if (st.isSymbolicLink() || (last ? !st.isFile() : !st.isDirectory())) {
+      throw new PolicyError(
+        `signoff.ledger ${JSON.stringify(rel)}: ${shown} is ${kindOf(st)}; the sign-off ledger is honored only as a regular file inside the repository, reached without following a link`
+      );
+    }
+    path = next;
+  }
+  return { rel, path, exists: true };
+}
+function openLedger(rel, path, flags) {
+  let fd;
+  try {
+    fd = openSync2(path, flags | (constants3.O_NOFOLLOW ?? 0), 420);
+  } catch (e) {
+    throw new PolicyError(`signoff.ledger ${JSON.stringify(rel)}: cannot open ${path} (${e instanceof Error ? e.message : String(e)})`);
+  }
+  if (!fstatSync2(fd).isFile()) {
+    closeSync2(fd);
+    throw new PolicyError(`signoff.ledger ${JSON.stringify(rel)}: ${path} is not a regular file; refusing to use it`);
+  }
+  return fd;
+}
 function readLedger(cwd, policy) {
-  const p = ledgerPath(cwd, policy);
-  if (!existsSync6(p)) return [];
+  const { rel, path, exists } = ledgerOnDisk(cwd, policy);
+  if (!exists) return [];
+  const fd = openLedger(rel, path, constants3.O_RDONLY);
+  let text;
+  try {
+    text = readFileSync6(fd, "utf8");
+  } finally {
+    closeSync2(fd);
+  }
   const out3 = [];
-  for (const line of readFileSync6(p, "utf8").split("\n")) {
+  for (const line of text.split("\n")) {
     if (!line.trim()) continue;
     try {
       const e = ledgerEntryFrom(JSON.parse(line));
@@ -10926,15 +10984,27 @@ function readLedger(cwd, policy) {
   return out3;
 }
 function appendEntry(cwd, policy, e) {
-  const p = ledgerPath(cwd, policy);
-  mkdirSync(dirname2(p), { recursive: true });
-  appendFileSync(p, JSON.stringify(e) + "\n");
+  const { rel, path } = ledgerOnDisk(cwd, policy);
+  try {
+    mkdirSync(dirname2(path), { recursive: true });
+  } catch (err3) {
+    throw new PolicyError(`signoff.ledger ${JSON.stringify(rel)}: cannot create ${dirname2(path)} (${errorMessage(err3)})`);
+  }
+  const fd = openLedger(rel, path, constants3.O_WRONLY | constants3.O_APPEND | constants3.O_CREAT);
+  try {
+    appendFileSync(fd, JSON.stringify(e) + "\n");
+  } finally {
+    closeSync2(fd);
+  }
 }
 function makeEntry(f, reason, now, ttlMs = DEFAULT_TTL_MS) {
   return { rule: f.rule, file: f.file, fingerprint: fingerprintOf(f), reason, recordedAt: now, expiresAt: now + ttlMs };
 }
+function honoredAt(e, now) {
+  return e.expiresAt > now && e.recordedAt <= now && e.expiresAt - e.recordedAt <= LEDGER_TTL_MS;
+}
 function applyLocalSignoffs(findings, cwd, policy, now = Date.now()) {
-  const ledger = readLedger(cwd, policy).filter((e) => e.expiresAt > now);
+  const ledger = readLedger(cwd, policy).filter((e) => honoredAt(e, now));
   const valid = new Set(ledger.map((e) => e.fingerprint));
   const cleared = [];
   const remaining = [];
@@ -10985,13 +11055,15 @@ function oobHeadFromEnv(env = process.env) {
 function oobFromEnv(env = process.env) {
   return (env.TAMPERWARD_OOB_SIGNOFF ?? "").split(",").map((s) => s.trim().replace(/^tamperward:allow:/, "")).filter(Boolean);
 }
-var DEFAULT_TTL_MS, COMPACT_OOB_PREFIX, FULL_OBJECT_ID, fingerprintOf;
+var LEDGER_TTL_MS, DEFAULT_TTL_MS, DEFAULT_LEDGER, COMPACT_OOB_PREFIX, FULL_OBJECT_ID, fingerprintOf;
 var init_signoff = __esm({
   "src/signoff.ts"() {
     "use strict";
     init_policy_load();
     init_narrow();
-    DEFAULT_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+    LEDGER_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+    DEFAULT_TTL_MS = LEDGER_TTL_MS;
+    DEFAULT_LEDGER = ".tamperward/ledger.jsonl";
     COMPACT_OOB_PREFIX = "tw1:";
     FULL_OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
     fingerprintOf = (f) => fingerprint(f.rule, f.file, f.evidence);
@@ -11437,7 +11509,7 @@ var init_deny = __esm({
 });
 
 // src/session.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync7, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync7, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname3, join as join10 } from "node:path";
 function writeBaseline(p, sha3) {
   mkdirSync2(dirname3(p), { recursive: true });
@@ -11463,7 +11535,7 @@ function turnBaseline(cwd, sessionId) {
   const p = baselinePath(cwd, sessionId);
   if (!p) return null;
   try {
-    if (existsSync7(p)) {
+    if (existsSync6(p)) {
       const v = readFileSync7(p, "utf8").trim();
       if (SHA.test(v)) return v;
     }
@@ -11507,7 +11579,7 @@ var init_session = __esm({
 
 // src/effect.ts
 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 { existsSync as existsSync7, lstatSync as lstatSync4, 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) {
   if (!isRecord(value)) return null;
@@ -11572,7 +11644,7 @@ function snapshotProtected(cwd, policy, prev, cache3) {
       if (pruned.has(r)) continue;
       let st;
       try {
-        st = lstatSync3(join11(cwd, r));
+        st = lstatSync4(join11(cwd, r));
       } catch {
         continue;
       }
@@ -11599,7 +11671,7 @@ function driftBetween(expected, current) {
   return { changed, deleted, added };
 }
 function loadTree(p) {
-  if (!p || !existsSync8(p)) return null;
+  if (!p || !existsSync7(p)) return null;
   try {
     return ptreeFrom(JSON.parse(readFileSync8(p, "utf8")));
   } catch {
@@ -11654,7 +11726,7 @@ var init_effect = __esm({
 });
 
 // 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 { appendFileSync as appendFileSync3, lstatSync as lstatSync5, 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 createHash5 } from "node:crypto";
 function snap(abs) {
@@ -11757,7 +11829,7 @@ function watchTree(dir, cb, onState, onError, watchFn = watch) {
         const child = rel ? `${rel}/${String(fname)}` : String(fname);
         cb(kind, child);
         try {
-          if (lstatSync4(join12(dir, child)).isDirectory()) addDir(child);
+          if (lstatSync5(join12(dir, child)).isDirectory()) addDir(child);
         } catch {
         }
       });
@@ -11793,7 +11865,7 @@ function watchTree(dir, cb, onState, onError, watchFn = watch) {
       const child = rel ? `${rel}/${name}` : name;
       if (SKIP2.test(child + "/")) continue;
       try {
-        if (lstatSync4(join12(dir, child)).isDirectory()) walk2(child);
+        if (lstatSync5(join12(dir, child)).isDirectory()) walk2(child);
       } catch {
       }
     }
@@ -11944,7 +12016,7 @@ var init_watch = __esm({
 });
 
 // src/detectors/fs-events.ts
-import { closeSync as closeSync2, openSync as openSync2, readSync as readSync2, statSync as statSync2 } from "node:fs";
+import { closeSync as closeSync3, openSync as openSync3, readSync as readSync2, statSync as statSync2 } from "node:fs";
 function fsEventFrom(line) {
   let value;
   try {
@@ -11991,12 +12063,12 @@ function readEvents(log, offset, maxBytes = MAX_EVENT_READ_BYTES, io = DEFAULT_E
   const available = size - start;
   const requested = Math.min(available, cap);
   const buffer = Buffer.allocUnsafe(requested);
-  const fd = openSync2(log, "r");
+  const fd = openSync3(log, "r");
   let bytesRead = 0;
   try {
     bytesRead = io.read(fd, buffer, 0, requested, start);
   } finally {
-    closeSync2(fd);
+    closeSync3(fd);
   }
   if (bytesRead <= 0) {
     return {
@@ -12201,7 +12273,7 @@ var init_fs_events = __esm({
 
 // src/cli/audit.ts
 import { createHash as createHash6, randomBytes } from "node:crypto";
-import { appendFileSync as appendFileSync4, closeSync as closeSync3, existsSync as existsSync9, mkdirSync as mkdirSync5, openSync as openSync3, readSync as readSync3 } from "node:fs";
+import { appendFileSync as appendFileSync4, closeSync as closeSync4, existsSync as existsSync8, mkdirSync as mkdirSync5, openSync as openSync4, readSync as readSync3 } 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;
@@ -12321,7 +12393,7 @@ function parseAuditLine(line, lineNumber) {
   return parseAuditEvent(value, lineNumber);
 }
 function forEachAuditLine(file, onLine, maxLineBytes = MAX_AUDIT_LINE_BYTES) {
-  const fd = openSync3(file, "r");
+  const fd = openSync4(file, "r");
   try {
     const chunk = Buffer.allocUnsafe(64 * 1024);
     let pending = [];
@@ -12359,7 +12431,7 @@ function forEachAuditLine(file, onLine, maxLineBytes = MAX_AUDIT_LINE_BYTES) {
     }
     if (pending.length) emit3(pending);
   } finally {
-    closeSync3(fd);
+    closeSync4(fd);
   }
 }
 function parseSince(value, nowMs = Date.now()) {
@@ -12460,7 +12532,7 @@ function runStats(opts = {}) {
   const file = opts.file ? isAbsolute8(opts.file) ? opts.file : resolve4(cwd, opts.file) : configured && configured !== "auto" ? isAbsolute8(configured) ? configured : resolve4(cwd, configured) : defaultAuditPath(cwd);
   const cutoff = opts.since ? parseSince(opts.since) : null;
   if (!file) throw new Error("stats needs --file outside a Git repository");
-  if (!existsSync9(file)) {
+  if (!existsSync8(file)) {
     if (explicitFile) throw new Error(`audit file not found: ${file}`);
     const empty2 = summarizeAudit([]);
     process.stdout.write(opts.json ? JSON.stringify(empty2) + "\n" : renderAuditStats(empty2));
@@ -12499,7 +12571,7 @@ var init_audit = __esm({
 });
 
 // src/cli/hook.ts
-import { readFileSync as readFileSync10, appendFileSync as appendFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "node:fs";
+import { readFileSync as readFileSync10, appendFileSync as appendFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync9 } from "node:fs";
 import { createHash as createHash7 } from "node:crypto";
 function setSnapshotCache(cache3) {
   snapshotCache = cache3;
@@ -12796,9 +12868,9 @@ function turnTransientBlocks(cwd, sessionId, policy, changes) {
     recordObserverHealth(cwd, sessionId, telemetry.state, telemetry.reason);
   }
   const cp = cursorPath(cwd, sessionId);
-  if (!existsSync10(log)) return none;
+  if (!existsSync9(log)) return none;
   let offset = 0;
-  if (cp && existsSync10(cp)) {
+  if (cp && existsSync9(cp)) {
     const n2 = Number(readFileSync10(cp, "utf8"));
     offset = Number.isFinite(n2) ? n2 : 0;
   }
@@ -12979,7 +13051,7 @@ var init_hook = __esm({
 });
 
 // src/ptree-cache.ts
-import { lstatSync as lstatSync5 } from "node:fs";
+import { lstatSync as lstatSync6 } from "node:fs";
 import { join as join14 } from "node:path";
 function keyOf(st) {
   return `${st.dev}:${st.ino}:${st.size}:${st.mode}:${st.mtimeNs}:${st.ctimeNs}`;
@@ -13033,7 +13105,7 @@ var init_ptree_cache = __esm({
         const abs = join14(cwd, rel);
         let st;
         try {
-          st = lstatSync5(abs, { bigint: true });
+          st = lstatSync6(abs, { bigint: true });
         } catch {
           this.map.delete(abs);
           this.stats.misses++;
@@ -13055,7 +13127,7 @@ var init_ptree_cache = __esm({
         const entry = compute();
         let after;
         try {
-          after = lstatSync5(abs, { bigint: true });
+          after = lstatSync6(abs, { bigint: true });
         } catch {
           this.map.delete(abs);
           return entry;
@@ -13073,7 +13145,7 @@ var init_ptree_cache = __esm({
 });
 
 // src/cli/hook-service.ts
-import { chmodSync, existsSync as existsSync11, lstatSync as lstatSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { chmodSync, existsSync as existsSync10, lstatSync as lstatSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
 import { createConnection as createConnection2, createServer } from "node:net";
 import { realpathSync as realpathSync4 } from "node:fs";
 import { sep } from "node:path";
@@ -13161,8 +13233,8 @@ function removeQuietly(p) {
   }
 }
 function ensurePrivateDir(dir, uid) {
-  if (!existsSync11(dir)) mkdirSync6(dir, { recursive: true, mode: 448 });
-  const st = lstatSync6(dir);
+  if (!existsSync10(dir)) mkdirSync6(dir, { recursive: true, mode: 448 });
+  const st = lstatSync7(dir);
   if (!st.isDirectory()) throw new Error(`${dir} is not a directory`);
   if (st.uid !== uid) throw new Error(`${dir} is owned by uid ${st.uid}, not ${uid}; refusing to serve from it`);
   if ((st.mode & 63) !== 0) chmodSync(dir, 448);
@@ -13358,7 +13430,7 @@ async function stopHookService(paths, expectedRoot) {
         process.kill(st.pid, "SIGTERM");
       } catch {
       }
-      const gone = () => !pidAlive2(st.pid) || !existsSync11(paths.socket);
+      const gone = () => !pidAlive2(st.pid) || !existsSync10(paths.socket);
       const until = Date.now() + STOP_WAIT_MS;
       while (!gone() && Date.now() < until) sleepSync(50);
       if (!gone()) throw new Error(`hook service pid ${st.pid} did not exit within ${STOP_WAIT_MS / 1e3}s`);
@@ -13594,11 +13666,11 @@ var init_verifier_limits = __esm({
 
 // src/safe-write.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { lstatSync as lstatSync7, renameSync as renameSync3, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { lstatSync as lstatSync8, renameSync as renameSync3, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "node:fs";
 function writeTargetKind(path) {
   let st;
   try {
-    st = lstatSync7(path, { throwIfNoEntry: false });
+    st = lstatSync8(path, { throwIfNoEntry: false });
   } catch (e) {
     if (errnoCode(e) === "ENOTDIR") return "absent";
     throw e;
@@ -13619,7 +13691,7 @@ function refuseNonRegular(path) {
 }
 function existingMode(path, fallback) {
   if (writeTargetKind(path) !== "file") return fallback;
-  return lstatSync7(path).mode & 511;
+  return lstatSync8(path).mode & 511;
 }
 function atomicReplaceFile(path, content, mode) {
   const tmp = `${path}.${process.pid}.${randomBytes2(8).toString("hex")}.tmp`;
@@ -13640,7 +13712,7 @@ var init_safe_write = __esm({
 // src/cli/init.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync12, realpathSync as realpathSync5 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync12, realpathSync as realpathSync5 } from "node:fs";
 import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute9, join as join15, relative as relative4, resolve as resolve6 } from "node:path";
 function gitConfig(cwd, key2) {
   try {
@@ -13744,7 +13816,7 @@ function verifierCandidates(cwd) {
     if (/^\s*\[tool\.pytest(?:\.ini_options)?\]\s*$/m.test(pyproject)) add("pytest");
   } catch {
   }
-  if (existsSync12(join15(cwd, "pytest.ini"))) add("pytest");
+  if (existsSync11(join15(cwd, "pytest.ini"))) add("pytest");
   try {
     const setupCfg = readFileSync12(join15(cwd, "setup.cfg"), "utf8");
     if (/^\s*\[tool:pytest\]\s*$/m.test(setupCfg)) add("pytest");
@@ -13804,7 +13876,7 @@ function planPolicy(cwd) {
   const path = join15(cwd, POLICY_FILE);
   const refused = refuseNonRegular(path);
   if (refused) return { item: "policy", path: POLICY_FILE, status: "error", detail: refused };
-  if (existsSync12(path)) {
+  if (existsSync11(path)) {
     try {
       loadPolicy(cwd);
     } catch (e) {
@@ -13823,7 +13895,7 @@ function planPolicy(cwd) {
 function planGitignore(cwd) {
   const rel = ".gitignore";
   const path = join15(cwd, rel);
-  if (!existsSync12(join15(cwd, "node_modules"))) return null;
+  if (!existsSync11(join15(cwd, "node_modules"))) return null;
   let existing = "";
   let kind;
   try {
@@ -13888,7 +13960,7 @@ function planClaudeHooks(cwd) {
   const refused = refuseNonRegular(path);
   if (refused) return { item: "agent", path: rel, status: "error", detail: refused };
   let settings = {};
-  if (existsSync12(path)) {
+  if (existsSync11(path)) {
     let parsed;
     try {
       parsed = JSON.parse(readFileSync12(path, "utf8"));
@@ -13940,7 +14012,7 @@ function planClaudeHooks(cwd) {
   return {
     item: "agent",
     path: rel,
-    status: existsSync12(path) ? "update" : "create",
+    status: existsSync11(path) ? "update" : "create",
     detail: [
       needPre && "wire PreToolUse deny",
       needStop && "wire Stop sweep",
@@ -13984,7 +14056,7 @@ function hooksDir(cwd) {
     if (out3) return resolve6(cwd, out3);
   } catch {
   }
-  return existsSync12(join15(cwd, ".git")) ? join15(cwd, ".git", "hooks") : null;
+  return existsSync11(join15(cwd, ".git")) ? join15(cwd, ".git", "hooks") : null;
 }
 function display(cwd, path) {
   const rel = relative4(cwd, path);
@@ -14011,11 +14083,11 @@ function planPreCommit(cwd) {
   const skip = (detail) => ({ item: "pre-commit", path: "(none)", status: "skip", detail });
   let path;
   let note;
-  if (existsSync12(join15(cwd, ".husky"))) {
+  if (existsSync11(join15(cwd, ".husky"))) {
     path = join15(cwd, ".husky", "pre-commit");
     note = "husky";
   } else {
-    const managed = MANAGED_HOOKS.find((m) => m.configs.some((c) => existsSync12(join15(cwd, c))));
+    const managed = MANAGED_HOOKS.find((m) => m.configs.some((c) => existsSync11(join15(cwd, c))));
     if (managed) {
       return skip(`${managed.name} manages this repository's hooks and regenerates them on install, so a line in the hooks directory would not last \u2014 ${managed.hint}`);
     }
@@ -14033,7 +14105,7 @@ function planPreCommit(cwd) {
   const rel = display(cwd, path);
   const refused = refuseNonRegular(path);
   if (refused) return { item: "pre-commit", path: rel, status: "error", detail: refused };
-  const existing = existsSync12(path) ? readFileSync12(path, "utf8") : null;
+  const existing = existsSync11(path) ? readFileSync12(path, "utf8") : null;
   const hookMode = () => existingMode(path, 493) | 73;
   if (existing === null) {
     return {
@@ -14164,7 +14236,7 @@ function planWorkflow(cwd, force) {
   };
   const refused = refuseNonRegular(path);
   if (refused) return { item: "ci", path: rel, status: "error", detail: refused };
-  if (!existsSync12(path)) {
+  if (!existsSync11(path)) {
     return {
       item: "ci",
       path: rel,
@@ -14522,8 +14594,8 @@ var init_fingerprint = __esm({
 // src/dependency-env.ts
 import { createHash as createHash10 } from "node:crypto";
 import {
-  existsSync as existsSync13,
-  lstatSync as lstatSync8,
+  existsSync as existsSync12,
+  lstatSync as lstatSync9,
   readdirSync as readdirSync3,
   readFileSync as readFileSync13,
   readlinkSync as readlinkSync2,
@@ -14548,7 +14620,7 @@ function inside(root, candidate) {
   return rel === "" || rel !== ".." && !rel.startsWith(".." + sep3) && !isAbsolute10(rel);
 }
 function modeKind(path) {
-  const st = lstatSync8(path);
+  const st = lstatSync9(path);
   if (st.isFile()) return { kind: "file", mode: st.mode };
   if (st.isDirectory()) return { kind: "dir", mode: st.mode };
   if (st.isSymbolicLink()) return { kind: "symlink", mode: st.mode };
@@ -14558,7 +14630,7 @@ function fingerprintRoot(root, cwd, h) {
   let rootStat;
   let currentReal;
   try {
-    rootStat = lstatSync8(root.path);
+    rootStat = lstatSync9(root.path);
     currentReal = realpathSync6(root.path);
   } catch (e) {
     throw new Unattestable(
@@ -14676,7 +14748,7 @@ function snapshot(roots, probes, cwd) {
   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"
+      "probe\0" + probe.kind + "\0" + probe.path + "\0" + (existsSync12(probe.path) ? "present" : "absent") + "\0"
     );
   }
   for (const root of roots) fingerprintRoot(root, cwd, h);
@@ -14735,7 +14807,7 @@ function resolveExecutable(token, cwd, env) {
   if (token.includes("/") || token.includes("\\")) {
     const path = isAbsolute10(token) ? token : resolve7(cwd, token);
     try {
-      return existsSync13(path) ? realpathSync6(path) : null;
+      return existsSync12(path) ? realpathSync6(path) : null;
     } catch {
       return null;
     }
@@ -14743,7 +14815,7 @@ function resolveExecutable(token, cwd, env) {
   for (const entry of (env.PATH ?? "").split(delimiter).filter(Boolean)) {
     const candidate = resolve7(entry, token);
     try {
-      if (existsSync13(candidate) && statSync3(candidate).isFile()) return realpathSync6(candidate);
+      if (existsSync12(candidate) && statSync3(candidate).isFile()) return realpathSync6(candidate);
     } catch {
     }
   }
@@ -14766,7 +14838,7 @@ function inferredVenvFromToken(token, cwd) {
   const parentName = basename4(parent).toLowerCase();
   if (parentName !== "bin" && parentName !== "scripts") return null;
   const root = dirname6(parent);
-  return existsSync13(join16(root, "pyvenv.cfg")) ? root : null;
+  return existsSync12(join16(root, "pyvenv.cfg")) ? root : null;
 }
 function unsupportedEcosystem(command, token) {
   const name = token ? basename4(token).toLowerCase() : "";
@@ -14782,11 +14854,11 @@ function inferredVenv(executable) {
   const parentName = basename4(parent).toLowerCase();
   if (parentName !== "bin" && parentName !== "scripts") return null;
   const root = dirname6(parent);
-  return existsSync13(join16(root, "pyvenv.cfg")) ? root : null;
+  return existsSync12(join16(root, "pyvenv.cfg")) ? root : null;
 }
 function venvProblem(root) {
   const cfg = join16(root, "pyvenv.cfg");
-  if (!existsSync13(cfg)) return "VIRTUAL_ENV " + JSON.stringify(root) + " has no pyvenv.cfg";
+  if (!existsSync12(cfg)) return "VIRTUAL_ENV " + JSON.stringify(root) + " has no pyvenv.cfg";
   try {
     const body = readFileSync13(cfg, "utf8");
     if (/^\s*include-system-site-packages\s*=\s*true\s*$/im.test(body)) {
@@ -14813,7 +14885,7 @@ function discoverDependencyEnvironment(cwdInput, command, env = process.env) {
   };
   try {
     const nodeModules = join16(cwd, "node_modules");
-    if (existsSync13(nodeModules)) addRoot("node_modules", nodeModules);
+    if (existsSync12(nodeModules)) addRoot("node_modules", nodeModules);
     else probes.push({ kind: "node_modules", path: nodeModules });
     const token = firstExecutable(command);
     const executable = resolveExecutable(token, cwd, env);
@@ -14825,7 +14897,7 @@ function discoverDependencyEnvironment(cwdInput, command, env = process.env) {
       venv = resolve7(env.VIRTUAL_ENV);
     } else {
       venv = inferredVenv(executable) ?? inferredVenvFromToken(token, cwd);
-      if (!venv && /(?:^|\s)uv\s+run(?:\s|$)/.test(command) && existsSync13(join16(cwd, ".venv", "pyvenv.cfg"))) {
+      if (!venv && /(?:^|\s)uv\s+run(?:\s|$)/.test(command) && existsSync12(join16(cwd, ".venv", "pyvenv.cfg"))) {
         venv = join16(cwd, ".venv");
       }
     }
@@ -15304,7 +15376,7 @@ if (child) {
 // src/verifier-backend.ts
 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 readFileSync14, realpathSync as realpathSync7, statSync as statSync4 } from "node:fs";
+import { accessSync as accessSync2, constants as constants4, readFileSync as readFileSync14, realpathSync as realpathSync7, statSync as statSync4 } from "node:fs";
 import { delimiter as delimiter2, dirname as dirname7, join as join18, resolve as resolve8 } from "node:path";
 function identity() {
   const uid = typeof process.getuid === "function" ? process.getuid() : null;
@@ -15341,7 +15413,7 @@ function findExecutable(name) {
     if (!raw) continue;
     const candidate = join18(raw, name);
     try {
-      accessSync2(candidate, constants3.X_OK);
+      accessSync2(candidate, constants4.X_OK);
       return realpathSync7(candidate);
     } catch {
     }
@@ -16405,7 +16477,7 @@ var init_verification_receipt = __esm({
 // src/cli/verify.ts
 import { execFileSync as execFileSync9, spawnSync as spawnSync3 } from "node:child_process";
 import { createHash as createHash14 } from "node:crypto";
-import { chmodSync as chmodSync2, cpSync, lstatSync as lstatSync9, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, readlinkSync as readlinkSync3, rmSync as rmSync9, symlinkSync, writeFileSync as writeFileSync11, existsSync as existsSync14 } from "node:fs";
+import { chmodSync as chmodSync2, cpSync, lstatSync as lstatSync10, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, readlinkSync as readlinkSync3, rmSync as rmSync9, symlinkSync, writeFileSync as writeFileSync11, existsSync as existsSync13 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { dirname as dirname10, isAbsolute as isAbsolute11, join as join21, relative as relative6, resolve as resolve9, sep as sep4 } from "node:path";
 function oracleAssuranceReport() {
@@ -16499,7 +16571,7 @@ function validateSymlinkGraph(target, out3, root, dependencyRoot, label) {
     const current = join21(base, ...stack);
     let st;
     try {
-      st = lstatSync9(current);
+      st = lstatSync10(current);
     } catch {
       continue;
     }
@@ -16541,7 +16613,7 @@ function rejectLinkedParent(cwd, rel) {
     current = join21(current, part);
     let st;
     try {
-      st = lstatSync9(current);
+      st = lstatSync10(current);
     } catch {
       continue;
     }
@@ -16567,7 +16639,7 @@ function materialize(cwd, dest, dependencyRoot) {
     rejectLinkedParent(cwd, rel);
     let st;
     try {
-      st = lstatSync9(src);
+      st = lstatSync10(src);
     } catch {
       continue;
     }
@@ -16601,7 +16673,7 @@ function probeFilesystemCaseSensitivity(dir) {
   const lower = join21(dir, ".tw-case-probe-a");
   try {
     writeFileSync11(upper, "", { flag: "wx" });
-    return !existsSync14(lower);
+    return !existsSync13(lower);
   } finally {
     rmSync9(upper, { force: true });
   }
@@ -16621,7 +16693,7 @@ function caseFoldCollision(paths) {
 }
 function dropSymlink(p) {
   try {
-    if (lstatSync9(p).isSymbolicLink()) rmSync9(p, { force: true });
+    if (lstatSync10(p).isSymbolicLink()) rmSync9(p, { force: true });
   } catch {
   }
 }
@@ -16663,7 +16735,7 @@ function overlayDigest(dest, paths) {
     h.update("\0");
     const p = join21(dest, rel);
     try {
-      const st = lstatSync9(p);
+      const st = lstatSync10(p);
       h.update(String(st.mode));
       h.update(st.isSymbolicLink() ? readlinkSync3(p) : readFileSync16(p));
     } catch {
@@ -17015,7 +17087,7 @@ function runVerifyImpl(opts) {
   if (!filesystemCaseSensitive) {
     const present = (rel) => {
       try {
-        lstatSync9(join21(cwd, rel));
+        lstatSync10(join21(cwd, rel));
         return true;
       } catch {
         return false;
@@ -18390,7 +18462,7 @@ raise SystemExit(0)
 
 // src/cli/doctor.ts
 import { execFileSync as execFileSync11 } from "node:child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync18, readdirSync as readdirSync5 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync18, readdirSync as readdirSync5 } from "node:fs";
 import { join as join23, resolve as resolve11 } from "node:path";
 function lifecyclePlatformCheck(platform = process.platform, linuxPython = platform === "linux" ? trustedLinuxPython() : null) {
   if (platform === "linux") {
@@ -18446,7 +18518,7 @@ function wiringState(status, authority) {
   return authority ? "BROKEN" : "WARN";
 }
 function pinsInFile(path) {
-  if (!existsSync15(path)) return [];
+  if (!existsSync14(path)) return [];
   let src = "";
   try {
     src = readFileSync18(path, "utf8");
@@ -18470,7 +18542,7 @@ function workflowPermissionCheck(cwd, workflowRels = [".github/workflows/tamperw
   const warnings = [];
   for (const rel of workflowRels) {
     const path = resolve11(cwd, rel);
-    if (!existsSync15(path)) {
+    if (!existsSync14(path)) {
       broken.push(`${rel} is missing`);
       continue;
     }
@@ -18875,7 +18947,7 @@ function diagnose(opts = {}) {
   } else {
     const workflowDirRel = ".github/workflows";
     const workflowDir = resolve11(cwd, workflowDirRel);
-    if (!existsSync15(workflowDir)) {
+    if (!existsSync14(workflowDir)) {
       return fail("ci-verifier", `${workflowDirRel}: workflow directory does not exist`);
     }
     let entries;
@@ -18895,7 +18967,7 @@ function diagnose(opts = {}) {
   const authorityWorkflows = [];
   for (const workflowRel of workflowRels) {
     const workflowPath = resolve11(cwd, workflowRel);
-    if (!existsSync15(workflowPath)) {
+    if (!existsSync14(workflowPath)) {
       return fail("ci-verifier", `${workflowRel}: workflow does not exist`);
     }
     let doc;
@@ -19211,7 +19283,7 @@ var init_status2 = __esm({
 // src/cli/trace-verify.ts
 import { execFileSync as execFileSync12, spawnSync as spawnSync5 } from "node:child_process";
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync15,
   mkdtempSync as mkdtempSync5,
   readFileSync as readFileSync19,
   readdirSync as readdirSync6,
@@ -19470,7 +19542,7 @@ function materializeBase(base, cwd, dest) {
   }
   const hostModules = join24(cwd, "node_modules");
   const tracedModules = join24(dest, "node_modules");
-  if (existsSync16(hostModules) && !existsSync16(tracedModules)) {
+  if (existsSync15(hostModules) && !existsSync15(tracedModules)) {
     symlinkSync2(resolve12(hostModules), tracedModules, "dir");
   }
 }
@@ -19782,7 +19854,7 @@ var init_immutable = __esm({
 });
 
 // src/runtimes.ts
-import { existsSync as existsSync17, readFileSync as readFileSync20 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync20 } from "node:fs";
 import { join as join25 } from "node:path";
 function isRecord6(x) {
   return typeof x === "object" && x !== null && !Array.isArray(x);
@@ -19812,7 +19884,7 @@ function claudeSettingsBeyondTamperward(cwd) {
   const path = join25(cwd, ".claude", "settings.json");
   let raw;
   try {
-    if (!existsSync17(path)) return false;
+    if (!existsSync16(path)) return false;
     raw = readFileSync20(path, "utf8");
   } catch {
     return false;
@@ -19839,7 +19911,7 @@ function detectRuntimes(cwd) {
   for (const rt of KNOWN_RUNTIMES) {
     const marker = rt.markers.find((m) => {
       try {
-        return existsSync17(join25(cwd, m));
+        return existsSync16(join25(cwd, m));
       } catch {
         return false;
       }
@@ -20864,7 +20936,7 @@ var init_adapter3 = __esm({
 
 // src/adapters/copilot-sdk/changes.ts
 import { execFileSync as execFileSync13 } from "node:child_process";
-import { mkdtempSync as mkdtempSync6, writeFileSync as writeFileSync13, readFileSync as readFileSync21, rmSync as rmSync12, existsSync as existsSync18, realpathSync as realpathSync10 } from "node:fs";
+import { mkdtempSync as mkdtempSync6, writeFileSync as writeFileSync13, readFileSync as readFileSync21, rmSync as rmSync12, existsSync as existsSync17, realpathSync as realpathSync10 } from "node:fs";
 import { tmpdir as tmpdir7 } from "node:os";
 import { basename as basename5, dirname as dirname12, isAbsolute as isAbsolute16, relative as relative11, resolve as resolve15, join as join26 } from "node:path";
 function asStr4(v) {
@@ -20883,7 +20955,7 @@ function canonicalContainedTarget(abs, root) {
   }
   let dir = abs;
   const tail = [];
-  while (!existsSync18(dir)) {
+  while (!existsSync17(dir)) {
     const parent = dirname12(dir);
     if (parent === dir) break;
     tail.unshift(basename5(dir));
@@ -21371,6 +21443,8 @@ var init_evidence = __esm({
         ref: "copilot-sdk-capture-2026-09-20",
         source: "harness/adapters/copilot-sdk/evidence/capture-2026-09-20.json",
         source_artifact_sha256: "c46fba989dc0e772012c5fdb1291cf099326d24da2b551788be2e1e85113e49a",
+        // sha256sum of the committed capture (#619 re-grounded it on 2026-09-20; #697 pins it).
+        committed_artifact_sha256: "1c2d1acdfabc927e72dfa765cdb8da6fd995e6cbcad89812496d5c34e62e7903",
         binding: {
           runtime_id: "github-copilot-sdk-hosted",
           runtime_version: "copilot-runtime@1.0.85",
@@ -21393,16 +21467,19 @@ var init_evidence = __esm({
           {
             id: "pre-deny:shell",
             result: "proven",
+            capture_path: "returned-reject",
             detail: "returned-reject path (permission.completed result.kind denied): a rejected permission decision blocked shell tool dispatch \u2014 protected state not mutated (shell-pre-deny observation, boundary seq 2 < completion seq 3)"
           },
           {
             id: "hook-not-invoked",
             result: "proven",
+            capture_path: "callback-failure",
             detail: "callback-failure path: a broken permission callback (sync-throw, reject and adapter-throw, independently) failed CLOSED \u2014 the tool did not dispatch and protected state stayed intact"
           },
           {
             id: "transport:timeout",
             result: "inconclusive",
+            capture_path: "callback-timeout",
             detail: "callback-timeout path: a hung permission handler emits no permission.completed (the pinned SDK has no handler timeout), so non-dispatch is intrinsically unobservable \u2014 timeout is not proven either way"
           }
         ]
@@ -21706,7 +21783,7 @@ var init_runtime_qualification = __esm({
 
 // src/cli/runtime.ts
 import { execFileSync as execFileSync14 } from "node:child_process";
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "node:fs";
 import { join as join27, dirname as dirname13 } from "node:path";
 function storePath(cwd) {
   const dir = gitDir(cwd);
@@ -21714,7 +21791,7 @@ function storePath(cwd) {
 }
 function readStore(cwd) {
   const path = storePath(cwd);
-  if (!path || !existsSync19(path)) return null;
+  if (!path || !existsSync18(path)) return null;
   try {
     const parsed = JSON.parse(readFileSync22(path, "utf8"));
     if (parsed && typeof parsed === "object" && parsed.records && typeof parsed.records === "object") return parsed;
@@ -21885,7 +21962,7 @@ function resolveHookConfigHash(canonicalId, cwd) {
     "github-copilot-cli": join27(cwd, ".github", "hooks", "tamperward.json")
   };
   const file = files[canonicalId];
-  if (!file || !existsSync19(file)) return null;
+  if (!file || !existsSync18(file)) return null;
   try {
     const raw = readFileSync22(file, "utf8");
     let hooks = raw;
@@ -22166,7 +22243,7 @@ var init_runtime = __esm({
 
 // src/cli/onboard.ts
 import { execFileSync as execFileSync15 } from "node:child_process";
-import { lstatSync as lstatSync10, mkdtempSync as mkdtempSync7, readFileSync as readFileSync23, realpathSync as realpathSync11, rmSync as rmSync13 } from "node:fs";
+import { lstatSync as lstatSync11, mkdtempSync as mkdtempSync7, readFileSync as readFileSync23, realpathSync as realpathSync11, rmSync as rmSync13 } from "node:fs";
 import { tmpdir as tmpdir8 } from "node:os";
 import { join as join28, relative as relative12, resolve as resolve16, sep as sep6 } from "node:path";
 import { createInterface } from "node:readline";
@@ -22674,7 +22751,7 @@ function runDemo(cwd, head, runners, out3) {
       return;
     }
     const targetPath = join28(wt, target.path);
-    const targetStat = lstatSync10(targetPath, { throwIfNoEntry: false });
+    const targetStat = lstatSync11(targetPath, { throwIfNoEntry: false });
     if (!targetStat || !targetStat.isFile() || targetStat.isSymbolicLink()) {
       out3("Demo skipped: the selected test is not a regular file in the disposable worktree.");
       return;
@@ -23347,7 +23424,7 @@ var init_record = __esm({
 // src/research/run.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { execFileSync as execFileSync16 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync20, linkSync, mkdirSync as mkdirSync12, openSync as openSync4, readFileSync as readFileSync25, renameSync as renameSync4, rmSync as rmSync14, unlinkSync, writeFileSync as writeFileSync15, writeSync } from "node:fs";
+import { closeSync as closeSync5, existsSync as existsSync19, linkSync, mkdirSync as mkdirSync12, openSync as openSync5, readFileSync as readFileSync25, renameSync as renameSync4, rmSync as rmSync14, unlinkSync, writeFileSync as writeFileSync15, writeSync } from "node:fs";
 import { hostname } from "node:os";
 import { join as join29, resolve as resolve19 } from "node:path";
 function git7(args, cwd) {
@@ -23384,7 +23461,7 @@ function lockHolder(path) {
 function acquireResearchLock(ledger, breakStaleLock = false) {
   mkdirSync12(ledger, { recursive: true });
   const path = researchLockPath(ledger);
-  if (breakStaleLock && existsSync20(path)) {
+  if (breakStaleLock && existsSync19(path)) {
     const owner2 = readLockOwner(path);
     if (!owner2) {
       throw new ResearchError(`research output ${ledger} has an unreadable lock at ${path}; verify no run is active, then remove it deliberately`);
@@ -23427,12 +23504,12 @@ function acquireResearchLock(ledger, breakStaleLock = false) {
   const text = JSON.stringify(owner) + "\n";
   let fd = -1;
   try {
-    fd = openSync4(path, "wx", 384);
+    fd = openSync5(path, "wx", 384);
     writeSync(fd, text);
-    closeSync4(fd);
+    closeSync5(fd);
     fd = -1;
   } catch (e) {
-    if (fd !== -1) closeSync4(fd);
+    if (fd !== -1) closeSync5(fd);
     if (e.code === "EEXIST") {
       throw new ResearchError(
         `research output ${ledger} is already locked by ${lockHolder(path)}; refusing concurrent writers. Verify the owner is not running, then remove ${path} deliberately or rerun with --break-lock`
@@ -23757,7 +23834,7 @@ function runResearch(opts) {
       try {
         for (let pair = 1; pair <= pairs; pair++) {
           const path = pairRecordPath(ledger, task.id, pair);
-          if (!existsSync20(path)) continue;
+          if (!existsSync19(path)) continue;
           const existing = resumableRecord(path, {
             task: task.id,
             pair,
@@ -23877,16 +23954,16 @@ var init_run2 = __esm({
 });
 
 // src/research/ledger-files.ts
-import { closeSync as closeSync5, constants as constants4, fstatSync as fstatSync2, lstatSync as lstatSync11, openSync as openSync5, readFileSync as readFileSync26, readdirSync as readdirSync7, realpathSync as realpathSync12 } from "node:fs";
+import { closeSync as closeSync6, constants as constants5, fstatSync as fstatSync3, lstatSync as lstatSync12, openSync as openSync6, readFileSync as readFileSync26, readdirSync as readdirSync7, realpathSync as realpathSync12 } from "node:fs";
 import { join as join30, resolve as resolve20 } from "node:path";
 function lstatOrNull(path) {
   try {
-    return lstatSync11(path);
+    return lstatSync12(path);
   } catch {
     return null;
   }
 }
-function kindOf(st) {
+function kindOf2(st) {
   if (st.isSymbolicLink()) return "a symlink";
   if (st.isDirectory()) return "a directory";
   if (st.isFIFO()) return "a FIFO";
@@ -23898,7 +23975,7 @@ function readRegularFile(path, realPairsDir, name) {
   const listed = lstatOrNull(path);
   if (listed === null) throw new ResearchError(`ledger record ${path} vanished while the ledger was being read`);
   if (!listed.isFile()) {
-    throw new ResearchError(`ledger record ${path} is ${kindOf(listed)}; only a regular file placed directly in pairs/ is read`);
+    throw new ResearchError(`ledger record ${path} is ${kindOf2(listed)}; only a regular file placed directly in pairs/ is read`);
   }
   if (listed.nlink !== 1) {
     throw new ResearchError(`ledger record ${path} has ${listed.nlink} links; a hard link can name a file outside pairs/, so only a singly linked regular file is read`);
@@ -23907,22 +23984,22 @@ function readRegularFile(path, realPairsDir, name) {
   if (real !== join30(realPairsDir, name)) {
     throw new ResearchError(`ledger record ${path} resolves outside the pairs directory (${real}); refusing to read it`);
   }
-  const flags = constants4.O_RDONLY | (constants4.O_NOFOLLOW ?? 0);
+  const flags = constants5.O_RDONLY | (constants5.O_NOFOLLOW ?? 0);
   let fd;
   try {
-    fd = openSync5(path, flags);
+    fd = openSync6(path, flags);
   } catch (e) {
     throw new ResearchError(`cannot open ledger record ${path}: ${errorMessage(e)}`);
   }
   try {
-    const opened = fstatSync2(fd);
+    const opened = fstatSync3(fd);
     const sameInode = process.platform === "win32" || opened.dev === listed.dev && opened.ino === listed.ino;
     if (!opened.isFile() || !sameInode || opened.nlink !== 1) {
       throw new ResearchError(`ledger record ${path} changed between listing and reading; refusing to read it`);
     }
     return readFileSync26(fd);
   } finally {
-    closeSync5(fd);
+    closeSync6(fd);
   }
 }
 function readPairFiles(ledger) {
@@ -24093,7 +24170,7 @@ var init_summarize = __esm({
 
 // src/research/init.ts
 import { createHash as createHash17 } from "node:crypto";
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync16 } from "node:fs";
 import { basename as basename6, dirname as dirname15, resolve as resolve21 } from "node:path";
 function idFrom(repo) {
   const clean = repo.replace(/[\\/]$/, "").split(/[\\/]/).pop() || "task";
@@ -24105,7 +24182,7 @@ function createResearchManifest(opts) {
   if (!opts.prompt) throw new ResearchError("research init requires --prompt");
   if (!opts.verifyCommand) throw new ResearchError("research init requires --verify-command");
   const out3 = resolve21(opts.out);
-  if (existsSync21(out3)) throw new ResearchError(`research init refuses to overwrite ${out3}; choose a new path`);
+  if (existsSync20(out3)) throw new ResearchError(`research init refuses to overwrite ${out3}; choose a new path`);
   const id = opts.id ?? idFrom(opts.repo);
   if (!/^[A-Za-z0-9._-]+$/.test(id)) throw new ResearchError(`research init id must match [A-Za-z0-9._-] (got "${id}")`);
   if (opts.verifyBudget !== void 0 && (!Number.isFinite(opts.verifyBudget) || opts.verifyBudget <= 0)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "2.39.3",
+  "version": "2.39.5",
   "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",