tamperward 2.37.1 → 2.37.2

package/dist/cli/index.js

@@ -5300,13 +5300,13 @@ function merge(a, b) {
 function literals(e) {
   if (ts.isStringLiteral(e)) return { items: [e.text], opaque: false };
   if (!ts.isArrayLiteralExpression(e)) return { items: [], opaque: true };
-  const items = [];
+  const items2 = [];
   let opaque = false;
   for (const el of e.elements) {
-    if (ts.isStringLiteral(el) || ts.isNoSubstitutionTemplateLiteral(el)) items.push(el.text);
+    if (ts.isStringLiteral(el) || ts.isNoSubstitutionTemplateLiteral(el)) items2.push(el.text);
     else opaque = true;
   }
-  return { items, opaque };
+  return { items: items2, opaque };
 }
 function parseLists(src) {
   const res = { collectFrom: null, collectKey: "collectCoverageFrom", ignore: [], ignoreRe: [], opaqueCollect: false, opaqueIgnore: false };
@@ -5319,13 +5319,13 @@ function parseLists(src) {
         const k = keyName(node.name);
         const vitestCoverage = ownerKey(node) === "coverage";
         if (k === "collectCoverageFrom" || k === "include" && vitestCoverage) {
-          const { items, opaque } = literals(resolve23(node.initializer));
-          res.collectFrom = items;
+          const { items: items2, opaque } = literals(resolve23(node.initializer));
+          res.collectFrom = items2;
           res.collectKey = k === "include" ? "coverage.include" : k;
           if (opaque) res.opaqueCollect = true;
         } else if (k === "coveragePathIgnorePatterns" || k === "exclude" && vitestCoverage) {
-          const { items, opaque } = literals(resolve23(node.initializer));
-          (k === "exclude" ? res.ignore : res.ignoreRe).push(...items);
+          const { items: items2, opaque } = literals(resolve23(node.initializer));
+          (k === "exclude" ? res.ignore : res.ignoreRe).push(...items2);
           if (opaque) res.opaqueIgnore = true;
         }
       }
@@ -5923,15 +5923,15 @@ function keyName2(name) {
 function literals2(e) {
   if (isStr(e)) return { items: [e.text], opaque: false };
   if (!ts.isArrayLiteralExpression(e)) return { items: [], opaque: true };
-  const items = [];
+  const items2 = [];
   let opaque = false;
   for (const el of e.elements) {
-    if (isStr(el)) items.push(el.text);
+    if (isStr(el)) items2.push(el.text);
     else if (ts.isSpreadElement(el) && /^(?:configDefaults\.|default)(?:exclude|include)$/i.test(el.expression.getText())) {
-      items.push(.../exclude$/i.test(el.expression.getText()) ? VITEST_DEFAULT_EXCLUDE : VITEST_DEFAULT_INCLUDE);
+      items2.push(.../exclude$/i.test(el.expression.getText()) ? VITEST_DEFAULT_EXCLUDE : VITEST_DEFAULT_INCLUDE);
     } else opaque = true;
   }
-  return { items, opaque };
+  return { items: items2, opaque };
 }
 function ownerKey2(node) {
   const obj = node.parent;
@@ -6054,11 +6054,11 @@ function collect(root, runner) {
   const sel = empty();
   const seen = /* @__PURE__ */ new Set();
   const take = (key2, e) => {
-    const { items, opaque } = literals2(e);
+    const { items: items2, opaque } = literals2(e);
     if (opaque || seen.has(key2)) sel.opaque = true;
     seen.add(key2);
     sel.present = true;
-    return items.map(stripRootDir);
+    return items2.map(stripRootDir);
   };
   const ignores = (key2, e) => {
     const entries = take(key2, e).map((pattern) => ({ pattern, key: key2 }));
@@ -10701,10 +10701,10 @@ function validate(r, where) {
     throw new PolicyError(`${where}: ${msg}`);
   }
   const show = (v) => JSON.stringify(v) ?? String(v);
-  function refuseNegated(field, list3) {
+  function refuseNegated(field2, list3) {
     const neg = list3.find(isNegatedGlob);
     if (neg !== void 0) {
-      bad2(`${field}: negated glob ${show(neg)} is not allowed \u2014 a "!" pattern matches every path, so it would ${field === "ignore" ? "ignore every file" : field.startsWith("protected.") ? `put every file in ${field}` : "blind the rule on every file"}; list the paths to include instead`);
+      bad2(`${field2}: negated glob ${show(neg)} is not allowed \u2014 a "!" pattern matches every path, so it would ${field2 === "ignore" ? "ignore every file" : field2.startsWith("protected.") ? `put every file in ${field2}` : "blind the rule on every file"}; list the paths to include instead`);
     }
   }
   const out3 = {};
@@ -20577,7 +20577,52 @@ function pairRecordFrom(raw, where = "record") {
     }
   };
 }
-var SHA_RE, SHA256_RE;
+function onlyFields(raw, allowed, where) {
+  if (!isRecord(raw)) return;
+  for (const key2 of Object.keys(raw)) {
+    if (!allowed.includes(key2)) bad(`${where}.${key2} is not a field of the v1 pair record; refusing to carry it as portable evidence`);
+  }
+}
+function portableObject(raw, spec2, where) {
+  if (!isRecord(raw)) bad(`${where} is not an object`);
+  for (const [key2, value] of Object.entries(raw)) {
+    const field2 = spec2.get(key2);
+    const at = `${where}.${key2}`;
+    if (field2 === void 0) bad(`${at} is not a field of the v1 run document; refusing to carry it as portable evidence`);
+    if (field2 === "scalar") {
+      if (value !== null && typeof value === "object") bad(`${at} is not a scalar; refusing to carry it as portable evidence`);
+    } else if ("items" in field2) {
+      if (!Array.isArray(value)) bad(`${at} is not an array`);
+      value.forEach((item, i) => portableObject(item, field2.items, `${at}[${i}]`));
+    } else {
+      portableObject(value, field2.fields, at);
+    }
+  }
+}
+function portablePairRecordFrom(raw, where = "record") {
+  onlyFields(raw, PAIR_FIELDS, where);
+  if (isRecord(raw)) {
+    onlyFields(raw.adapter, ADAPTER_FIELDS, `${where}.adapter`);
+    onlyFields(raw.arms, ARMS_FIELDS, `${where}.arms`);
+    if (isRecord(raw.arms)) {
+      for (const arm of ARMS_FIELDS) {
+        const trajectory = raw.arms[arm];
+        const at = `${where}.arms.${arm}`;
+        onlyFields(trajectory, TRAJECTORY_FIELDS, at);
+        if (isRecord(trajectory)) {
+          onlyFields(trajectory.agent, AGENT_FIELDS, `${at}.agent`);
+          onlyFields(trajectory.treatment, TREATMENT_FIELDS, `${at}.treatment`);
+          if (isRecord(trajectory.treatment) && trajectory.treatment.envelope !== null && trajectory.treatment.envelope !== void 0) {
+            portableObject(trajectory.treatment.envelope, RUN_DOCUMENT_FIELDS, `${at}.treatment.envelope`);
+          }
+          onlyFields(trajectory.outcome, OUTCOME_FIELDS, `${at}.outcome`);
+        }
+      }
+    }
+  }
+  return pairRecordFrom(raw, where);
+}
+var SHA_RE, SHA256_RE, PAIR_FIELDS, ADAPTER_FIELDS, ARMS_FIELDS, TRAJECTORY_FIELDS, AGENT_FIELDS, TREATMENT_FIELDS, OUTCOME_FIELDS, fields, items, RUN_DOCUMENT_FIELDS;
 var init_record = __esm({
   "src/research/record.ts"() {
     "use strict";
@@ -20587,6 +20632,82 @@ var init_record = __esm({
     init_derive();
     SHA_RE = /^[0-9a-f]{40,64}$/;
     SHA256_RE = /^[0-9a-f]{64}$/;
+    PAIR_FIELDS = [
+      "schema_version",
+      "command",
+      "document",
+      "task",
+      "pair",
+      "adapter",
+      "model",
+      "tamperward_version",
+      "agent_argv",
+      "agent_budget",
+      "manifest_sha256",
+      "verify_command",
+      "arms"
+    ];
+    ADAPTER_FIELDS = ["name", "layers"];
+    ARMS_FIELDS = ["ungated", "gated"];
+    TRAJECTORY_FIELDS = [
+      "arm",
+      "workspace",
+      "base",
+      "head",
+      "started_at",
+      "finished_at",
+      "agent",
+      "treatment",
+      "outcome",
+      "released_green",
+      "measured",
+      "unmeasurable"
+    ];
+    AGENT_FIELDS = ["exit_code", "signal", "timed_out", "failure"];
+    TREATMENT_FIELDS = ["verdict", "exit_code", "complete", "disposition", "envelope"];
+    OUTCOME_FIELDS = [
+      "verify_verdict",
+      "visible_exit",
+      "pristine_exit",
+      "visible_green",
+      "pristine_green",
+      "masked_failure",
+      "surviving_protected_mutations",
+      "warn_findings",
+      "rules",
+      "honest_completion"
+    ];
+    fields = (entries) => ({ fields: new Map(entries) });
+    items = (entries) => ({ items: new Map(entries) });
+    RUN_DOCUMENT_FIELDS = /* @__PURE__ */ new Map([
+      ["schema_version", "scalar"],
+      ["verdict", "scalar"],
+      ["exit_code", "scalar"],
+      ["complete", "scalar"],
+      ["base", "scalar"],
+      ["head", "scalar"],
+      ["reason", "scalar"],
+      ["agent", fields([["exit_code", "scalar"], ["timed_out", "scalar"], ["lifecycle_owned", "scalar"], ["budget_secs", "scalar"]])],
+      ["checks", fields([["diff", "scalar"], ["worktree", "scalar"], ["verify", "scalar"]])],
+      ["verifier_backend", fields([
+        ["kind", "scalar"],
+        ["trust", "scalar"],
+        ["available", "scalar"],
+        ["image", "scalar"],
+        ["engine", "scalar"],
+        ["reason", "scalar"],
+        ["resources", fields([["memory_bytes", "scalar"], ["memory_swap_bytes", "scalar"], ["cpus", "scalar"], ["pids", "scalar"]])]
+      ])],
+      ["dependency_environment", fields([
+        ["status", "scalar"],
+        ["fingerprint", "scalar"],
+        ["reason", "scalar"],
+        ["image", "scalar"],
+        ["roots", items([["kind", "scalar"], ["path", "scalar"]])],
+        ["diagnostics", fields([["full_snapshots", "scalar"], ["reused_snapshots", "scalar"], ["total_ms", "scalar"]])]
+      ])],
+      ["observer", fields([["enabled", "scalar"], ["blocking", "scalar"]])]
+    ]);
   }
 });
 
@@ -21122,27 +21243,95 @@ var init_run2 = __esm({
   }
 });
 
-// src/research/summarize.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync24 } from "node:fs";
+// src/research/ledger-files.ts
+import { closeSync as closeSync5, constants as constants4, fstatSync as fstatSync2, lstatSync as lstatSync11, openSync as openSync5, readFileSync as readFileSync24, readdirSync as readdirSync7, realpathSync as realpathSync11 } from "node:fs";
 import { join as join27, resolve as resolve17 } from "node:path";
-function readLedger2(dir) {
-  const pairsDir = join27(resolve17(dir), "pairs");
+function lstatOrNull(path) {
+  try {
+    return lstatSync11(path);
+  } catch {
+    return null;
+  }
+}
+function kindOf(st) {
+  if (st.isSymbolicLink()) return "a symlink";
+  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 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`);
+  }
+  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`);
+  }
+  const real = realpathSync11.native(path);
+  if (real !== join27(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);
+  let fd;
+  try {
+    fd = openSync5(path, flags);
+  } catch (e) {
+    throw new ResearchError(`cannot open ledger record ${path}: ${errorMessage(e)}`);
+  }
+  try {
+    const opened = fstatSync2(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 readFileSync24(fd);
+  } finally {
+    closeSync5(fd);
+  }
+}
+function readPairFiles(ledger) {
+  const root = resolve17(ledger);
+  const pairsDir = join27(root, "pairs");
+  const dirStat = lstatOrNull(pairsDir);
+  if (dirStat !== null && dirStat.isSymbolicLink()) {
+    throw new ResearchError(`ledger pairs directory ${pairsDir} is a symlink; only a real directory is read`);
+  }
+  if (dirStat === null || !dirStat.isDirectory()) throw new ResearchError(`ledger ${root} has no pairs directory`);
+  const realPairsDir = realpathSync11.native(pairsDir);
   let names;
   try {
     names = readdirSync7(pairsDir).filter((n2) => n2.endsWith(".json")).sort();
   } catch (e) {
     throw new ResearchError(`cannot read ledger ${pairsDir}: ${errorMessage(e)}`);
   }
-  if (names.length === 0) throw new ResearchError(`ledger ${pairsDir} holds no pair records`);
-  return names.map((n2) => {
-    const path = join27(pairsDir, n2);
+  return names.map((name) => {
+    const path = join27(pairsDir, name);
+    return { name, path, bytes: readRegularFile(path, realPairsDir, name) };
+  });
+}
+var init_ledger_files = __esm({
+  "src/research/ledger-files.ts"() {
+    "use strict";
+    init_narrow();
+    init_adapter();
+  }
+});
+
+// src/research/summarize.ts
+function readLedger2(dir) {
+  const files = readPairFiles(dir);
+  if (files.length === 0) throw new ResearchError(`ledger ${dir} holds no pair records`);
+  return files.map((f) => {
     let raw;
     try {
-      raw = JSON.parse(readFileSync24(path, "utf8"));
+      raw = JSON.parse(f.bytes.toString("utf8"));
     } catch (e) {
-      throw new ResearchError(`ledger record ${path} is not valid JSON: ${errorMessage(e)}`);
+      throw new ResearchError(`ledger record ${f.path} is not valid JSON: ${errorMessage(e)}`);
     }
-    return pairRecordFrom(raw, path);
+    return pairRecordFrom(raw, f.path);
   });
 }
 function weakened(t) {
@@ -21263,6 +21452,7 @@ var init_summarize = __esm({
     "use strict";
     init_machine_output();
     init_narrow();
+    init_ledger_files();
     init_adapter();
     init_record();
   }
@@ -21389,63 +21579,105 @@ var init_report2 = __esm({
 // src/research/bundle.ts
 import { createHash as createHash16 } from "node:crypto";
 import { gzipSync, gunzipSync } from "node:zlib";
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readdirSync as readdirSync8, readFileSync as readFileSync26, statSync as statSync6, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname13, join as join28, resolve as resolve19 } from "node:path";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync26, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname13, resolve as resolve19 } from "node:path";
 function octal(value, width) {
   return value.toString(8).padStart(width - 1, "0") + "\0";
 }
-function tarEntry(name, bytes) {
+function tarHeader(name, size) {
   const header = Buffer.alloc(BLOCK, 0);
-  const safe = name.replace(/^\/+/, "").slice(0, 99);
-  header.write(safe, 0, "utf8");
+  header.write(name, 0, "utf8");
   header.write(octal(420, 8), 100, "ascii");
   header.write(octal(0, 8), 108, "ascii");
   header.write(octal(0, 8), 116, "ascii");
-  header.write(octal(bytes.length, 12), 124, "ascii");
+  header.write(octal(size, 12), 124, "ascii");
   header.write(octal(0, 12), 136, "ascii");
   header.fill(32, 148, 156);
-  header[156] = 48;
+  header[TYPE_OFFSET] = 48;
   header.write("ustar", 257, "ascii");
   header.write("00", 263, "ascii");
   const checksum = header.reduce((sum, b) => sum + b, 0);
   header.write(octal(checksum, 8), 148, "ascii");
+  return header;
+}
+function tarEntry(name, bytes) {
+  if (name.startsWith("/") || Buffer.byteLength(name, "utf8") > TAR_NAME_MAX) {
+    throw new ResearchError(`archive entry name ${name} cannot be stored byte for byte in a ustar header`);
+  }
   const padding = Buffer.alloc((BLOCK - bytes.length % BLOCK) % BLOCK, 0);
-  return Buffer.concat([header, bytes, padding]);
+  return Buffer.concat([tarHeader(name, bytes.length), bytes, padding]);
 }
 function makeTar(entries) {
   return Buffer.concat([...entries.map((e) => tarEntry(e.name, e.bytes)), Buffer.alloc(BLOCK * 2, 0)]);
 }
+function field(header, start, length) {
+  const raw = header.subarray(start, start + length);
+  const end = raw.indexOf(0);
+  return raw.subarray(0, end === -1 ? raw.length : end).toString("utf8");
+}
 function parseTar(bytes) {
   const files = /* @__PURE__ */ new Map();
-  for (let offset = 0; offset + BLOCK <= bytes.length; ) {
+  let offset = 0;
+  for (; ; ) {
+    if (offset + BLOCK > bytes.length) throw new ResearchError("research bundle is missing its end-of-archive blocks");
     const header = bytes.subarray(offset, offset + BLOCK);
-    if (header.every((b) => b === 0)) break;
-    const name = header.subarray(0, 100).toString("utf8").replace(/\0.*$/, "");
-    const sizeText = header.subarray(124, 136).toString("ascii").replace(/\0.*$/, "").trim();
-    const size = Number.parseInt(sizeText || "0", 8);
+    if (header.every((b) => b === 0)) {
+      const second = bytes.subarray(offset + BLOCK, offset + 2 * BLOCK);
+      if (second.length !== BLOCK || !second.every((b) => b === 0) || offset + 2 * BLOCK !== bytes.length) {
+        throw new ResearchError("research bundle carries bytes after its end-of-archive blocks");
+      }
+      return files;
+    }
+    const name = field(header, 0, NAME_FIELD);
+    const prefix = field(header, PREFIX_OFFSET, PREFIX_FIELD);
+    if (prefix) {
+      throw new ResearchError(`research bundle entry ${prefix}/${name} uses a ustar prefix; this bundle format stores every name in the name field`);
+    }
+    const type = header[TYPE_OFFSET];
+    if (type !== 48) {
+      throw new ResearchError(`research bundle entry ${name} is not a regular file entry (type flag ${JSON.stringify(String.fromCharCode(type))})`);
+    }
+    const size = Number.parseInt(field(header, 124, 12).trim() || "0", 8);
     if (!name || name.startsWith("/") || name.split("/").includes("..") || !Number.isSafeInteger(size) || size < 0) {
       throw new ResearchError("research bundle contains an unsafe or malformed archive entry");
     }
+    if (Buffer.byteLength(name, "utf8") > TAR_NAME_MAX || !header.equals(tarHeader(name, size))) {
+      throw new ResearchError(`research bundle entry ${name} has a header this bundle format does not write`);
+    }
     const start = offset + BLOCK;
     const end = start + size;
     if (end > bytes.length) throw new ResearchError("research bundle is truncated");
+    const padded = start + Math.ceil(size / BLOCK) * BLOCK;
+    if (padded > bytes.length || !bytes.subarray(end, padded).every((b) => b === 0)) {
+      throw new ResearchError(`research bundle entry ${name} carries bytes in its padding`);
+    }
+    if (files.has(name)) throw new ResearchError(`research bundle contains a duplicate archive entry ${name}`);
     files.set(name, Buffer.from(bytes.subarray(start, end)));
-    offset = start + Math.ceil(size / BLOCK) * BLOCK;
+    offset = padded;
   }
-  return files;
 }
-function walkLedger(ledger) {
+function packagedRecords(ledger) {
+  const files = readPairFiles(ledger);
+  if (files.length === 0) throw new ResearchError(`ledger ${ledger} holds no pair records`);
+  const records = [];
   const entries = [];
-  const pairs = join28(ledger, "pairs");
-  if (!existsSync20(pairs) || !statSync6(pairs).isDirectory()) throw new ResearchError(`ledger ${ledger} has no pairs directory`);
-  const names = readdirSync8(pairs).filter((n2) => n2.endsWith(".json")).sort();
-  if (names.length === 0) throw new ResearchError(`ledger ${ledger} holds no pair records`);
-  for (const name of names) {
-    const path = join28(pairs, name);
-    if (!statSync6(path).isFile()) continue;
-    entries.push({ name: `ledger/pairs/${name}`, bytes: readFileSync26(path) });
+  for (const f of files) {
+    let raw;
+    try {
+      raw = JSON.parse(f.bytes.toString("utf8"));
+    } catch (e) {
+      throw new ResearchError(`ledger record ${f.path} is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const record = portablePairRecordFrom(raw, f.path);
+    const archiveName = `ledger/pairs/${f.name}`;
+    const nameBytes = Buffer.byteLength(archiveName, "utf8");
+    if (nameBytes > TAR_NAME_MAX) {
+      throw new ResearchError(`pair record name ${f.name} is too long for the archive (${nameBytes} bytes as ${archiveName}; the limit is ${TAR_NAME_MAX})`);
+    }
+    records.push(record);
+    entries.push({ name: archiveName, bytes: jsonBytes(record) });
   }
-  return entries;
+  return { records, entries };
 }
 function jsonBytes(value) {
   return Buffer.from(JSON.stringify(value, null, 2) + "\n", "utf8");
@@ -21457,6 +21689,11 @@ function validateResearchBundle(path) {
   } catch (e) {
     throw new ResearchError(`cannot read research bundle ${path}: ${e instanceof Error ? e.message : String(e)}`);
   }
+  for (const name of files.keys()) {
+    if (!TOP_LEVEL_ENTRIES.has(name) && !PAIR_ENTRY_RE.test(name)) {
+      throw new ResearchError(`research bundle carries an entry that is not evidence: ${name}`);
+    }
+  }
   const provenance = files.get("provenance.json");
   const summaryBytes = files.get("summary.json");
   const report2 = files.get("report.txt");
@@ -21483,14 +21720,16 @@ function validateResearchBundle(path) {
   if (parsedSummary.document !== "summary" || parsedSummary.command !== "research") throw new ResearchError("research bundle summary is not a research summary");
   const records = [];
   for (const [name, bytes] of files) {
-    if (!name.startsWith("ledger/pairs/") || !name.endsWith(".json")) continue;
+    if (!PAIR_ENTRY_RE.test(name)) continue;
     let raw;
     try {
       raw = JSON.parse(bytes.toString("utf8"));
     } catch {
       throw new ResearchError(`invalid JSON in ${name}`);
     }
-    records.push(pairRecordFrom(raw, name));
+    const record = portablePairRecordFrom(raw, name);
+    if (!bytes.equals(jsonBytes(record))) throw new ResearchError(`${name} is not the canonical serialization of its pair record`);
+    records.push(record);
   }
   if (records.length === 0) throw new ResearchError("research bundle contains no pair records");
   const derived = summarizeRecords(records);
@@ -21504,8 +21743,8 @@ function createResearchBundle(opts) {
   if (!opts.ledger) throw new ResearchError("research bundle requires --ledger");
   if (!opts.out) throw new ResearchError("research bundle requires --out");
   const ledger = resolve19(opts.ledger);
-  const summary = summarizeLedger(ledger);
-  const entries = walkLedger(ledger);
+  const { records, entries } = packagedRecords(ledger);
+  const summary = summarizeRecords(records);
   if (opts.manifest) {
     const manifest = readFileSync26(resolve19(opts.manifest));
     const sha3 = createHash16("sha256").update(manifest).digest("hex");
@@ -21555,17 +21794,25 @@ function runResearchBundle(opts) {
     throw e;
   }
 }
-var BLOCK, BUNDLE_VERSION;
+var BLOCK, BUNDLE_VERSION, TOP_LEVEL_ENTRIES, PAIR_ENTRY_RE, TAR_NAME_MAX, NAME_FIELD, TYPE_OFFSET, PREFIX_OFFSET, PREFIX_FIELD;
 var init_bundle = __esm({
   "src/research/bundle.ts"() {
     "use strict";
     init_machine_output();
     init_adapter();
+    init_ledger_files();
     init_record();
     init_report2();
     init_summarize();
     BLOCK = 512;
     BUNDLE_VERSION = 1;
+    TOP_LEVEL_ENTRIES = /* @__PURE__ */ new Set(["summary.json", "report.txt", "provenance.json", "manifest.json"]);
+    PAIR_ENTRY_RE = /^ledger\/pairs\/[^/]+\.json$/;
+    TAR_NAME_MAX = 99;
+    NAME_FIELD = 100;
+    TYPE_OFFSET = 156;
+    PREFIX_OFFSET = 345;
+    PREFIX_FIELD = 155;
   }
 });
 
@@ -22535,7 +22782,7 @@ var init_adapter4 = __esm({
 
 // src/adapters/copilot-sdk/changes.ts
 import { execFileSync as execFileSync15 } from "node:child_process";
-import { mkdtempSync as mkdtempSync7, writeFileSync as writeFileSync15, readFileSync as readFileSync27, rmSync as rmSync13, existsSync as existsSync21, realpathSync as realpathSync11 } from "node:fs";
+import { mkdtempSync as mkdtempSync7, writeFileSync as writeFileSync15, readFileSync as readFileSync27, rmSync as rmSync13, existsSync as existsSync20, realpathSync as realpathSync12 } from "node:fs";
 import { tmpdir as tmpdir8 } from "node:os";
 import { basename as basename6, dirname as dirname14, isAbsolute as isAbsolute17, relative as relative12, resolve as resolve22, join as join29 } from "node:path";
 function asStr4(v) {
@@ -22548,13 +22795,13 @@ function relForDisplay5(path, cwd) {
 function canonicalContainedTarget(abs, root) {
   let realRoot;
   try {
-    realRoot = realpathSync11(root);
+    realRoot = realpathSync12(root);
   } catch (e) {
     throw new Error(`trusted repository root ${root} cannot be resolved: ${e instanceof Error ? e.message : String(e)}`);
   }
   let dir = abs;
   const tail = [];
-  while (!existsSync21(dir)) {
+  while (!existsSync20(dir)) {
     const parent = dirname14(dir);
     if (parent === dir) break;
     tail.unshift(basename6(dir));
@@ -22562,7 +22809,7 @@ function canonicalContainedTarget(abs, root) {
   }
   let realDir;
   try {
-    realDir = realpathSync11(dir);
+    realDir = realpathSync12(dir);
   } catch (e) {
     throw new Error(`write target ${abs} cannot be resolved: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -23373,7 +23620,7 @@ var init_runtime_qualification = __esm({
 
 // src/cli/runtime.ts
 import { execFileSync as execFileSync16 } from "node:child_process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync13, readFileSync as readFileSync28, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync28, writeFileSync as writeFileSync16 } from "node:fs";
 import { join as join30, dirname as dirname15 } from "node:path";
 function storePath(cwd) {
   const dir = gitDir(cwd);
@@ -23381,7 +23628,7 @@ function storePath(cwd) {
 }
 function readStore(cwd) {
   const path = storePath(cwd);
-  if (!path || !existsSync22(path)) return null;
+  if (!path || !existsSync21(path)) return null;
   try {
     const parsed = JSON.parse(readFileSync28(path, "utf8"));
     if (parsed && typeof parsed === "object" && parsed.records && typeof parsed.records === "object") return parsed;
@@ -23543,7 +23790,7 @@ function resolveHookConfigHash(canonicalId, cwd) {
     "github-copilot-cli": join30(cwd, ".github", "hooks", "tamperward.json")
   };
   const file = files[canonicalId];
-  if (!file || !existsSync22(file)) return null;
+  if (!file || !existsSync21(file)) return null;
   try {
     const raw = readFileSync28(file, "utf8");
     let hooks = raw;

package/package.json

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