tamperward 2.37.0 → 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 = {};
@@ -12201,7 +12201,7 @@ var init_fs_events = __esm({
 
 // src/cli/audit.ts
 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 { appendFileSync as appendFileSync4, closeSync as closeSync3, existsSync as existsSync9, mkdirSync as mkdirSync5, openSync as openSync3, 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;
@@ -12311,19 +12311,56 @@ function parseAuditEvent(value, line = 0) {
     ...typeof value.session === "string" ? { session: value.session } : {}
   };
 }
-function parseAuditJsonl(raw) {
-  const events = [];
-  raw.split(/\r?\n/).forEach((line, index) => {
-    if (!line.trim()) return;
-    let value;
-    try {
-      value = JSON.parse(line);
-    } catch {
-      throw new Error(`audit line ${index + 1} is not valid JSON`);
+function parseAuditLine(line, lineNumber) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    throw new Error(`audit line ${lineNumber} is not valid JSON`);
+  }
+  return parseAuditEvent(value, lineNumber);
+}
+function forEachAuditLine(file, onLine, maxLineBytes = MAX_AUDIT_LINE_BYTES) {
+  const fd = openSync3(file, "r");
+  try {
+    const chunk = Buffer.allocUnsafe(64 * 1024);
+    let pending = [];
+    let pendingBytes = 0;
+    let lineNumber = 0;
+    const emit3 = (parts) => {
+      lineNumber++;
+      let line = parts.length === 1 ? parts[0].toString("utf8") : Buffer.concat(parts).toString("utf8");
+      if (line.endsWith("\r")) line = line.slice(0, -1);
+      if (line.trim()) onLine(line, lineNumber);
+    };
+    for (; ; ) {
+      const read = readSync3(fd, chunk, 0, chunk.length, null);
+      if (read === 0) break;
+      let start = 0;
+      for (let i = 0; i < read; i++) {
+        if (chunk[i] !== 10) continue;
+        const part = chunk.subarray(start, i);
+        if (pendingBytes + part.length > maxLineBytes) {
+          throw new Error(`audit line ${lineNumber + 1} exceeds ${maxLineBytes} bytes (not an audit-v1 event)`);
+        }
+        emit3(pending.length ? [...pending, part] : [part]);
+        pending = [];
+        pendingBytes = 0;
+        start = i + 1;
+      }
+      if (start < read) {
+        const rest = Buffer.from(chunk.subarray(start, read));
+        pendingBytes += rest.length;
+        if (pendingBytes > maxLineBytes) {
+          throw new Error(`audit line ${lineNumber + 1} exceeds ${maxLineBytes} bytes (not an audit-v1 event)`);
+        }
+        pending.push(rest);
+      }
     }
-    events.push(parseAuditEvent(value, index + 1));
-  });
-  return events;
+    if (pending.length) emit3(pending);
+  } finally {
+    closeSync3(fd);
+  }
 }
 function parseSince(value, nowMs = Date.now()) {
   const relative13 = /^(\d+)(m|h|d)$/.exec(value);
@@ -12339,37 +12376,58 @@ function parseSince(value, nowMs = Date.now()) {
   }
   return parsed;
 }
-function summarizeAudit(events) {
-  const ordered = [...events].sort(
-    (a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp) || a.id.localeCompare(b.id)
-  );
+function createAuditAggregator() {
+  let events = 0;
+  let blocked = 0;
+  let warnings = 0;
   const rules = /* @__PURE__ */ new Map();
   const surfaces = /* @__PURE__ */ new Map();
   const sessions = /* @__PURE__ */ new Set();
-  for (const event of ordered) {
-    const bucket = rules.get(event.rule) ?? { events: 0, blocked: 0, warnings: 0 };
-    bucket.events++;
-    if (event.severity === "block") bucket.blocked++;
-    else bucket.warnings++;
-    rules.set(event.rule, bucket);
-    surfaces.set(event.surface, (surfaces.get(event.surface) ?? 0) + 1);
-    if (event.session) sessions.add(event.session);
-  }
-  const by_rule = [...rules.entries()].map(([rule, counts]) => ({ rule, ...counts })).sort((a, b) => b.events - a.events || a.rule.localeCompare(b.rule));
-  const by_surface = [...surfaces.entries()].map(([surface, count]) => ({ surface, events: count })).sort((a, b) => b.events - a.events || a.surface.localeCompare(b.surface));
+  const bounds = { first: null, last: null };
   return {
-    schema_version: AUDIT_SCHEMA_VERSION,
-    events: ordered.length,
-    blocked: ordered.filter((event) => event.severity === "block").length,
-    warnings: ordered.filter((event) => event.severity === "warn").length,
-    sessions: sessions.size,
-    first_event: ordered[0]?.timestamp ?? null,
-    last_event: ordered.at(-1)?.timestamp ?? null,
-    by_rule,
-    by_surface,
-    interpretation: "finding-is-not-proof-of-intent"
+    add(event) {
+      events++;
+      if (event.severity === "block") blocked++;
+      else warnings++;
+      const bucket = rules.get(event.rule) ?? { events: 0, blocked: 0, warnings: 0 };
+      bucket.events++;
+      if (event.severity === "block") bucket.blocked++;
+      else bucket.warnings++;
+      rules.set(event.rule, bucket);
+      surfaces.set(event.surface, (surfaces.get(event.surface) ?? 0) + 1);
+      if (event.session) sessions.add(event.session);
+      const ms = Date.parse(event.timestamp);
+      const { first, last } = bounds;
+      if (first === null || ms < first.ms || ms === first.ms && event.id.localeCompare(first.id) < 0) {
+        bounds.first = { ms, id: event.id, timestamp: event.timestamp };
+      }
+      if (last === null || ms > last.ms || ms === last.ms && event.id.localeCompare(last.id) > 0) {
+        bounds.last = { ms, id: event.id, timestamp: event.timestamp };
+      }
+    },
+    finish() {
+      const by_rule = [...rules.entries()].map(([rule, counts]) => ({ rule, ...counts })).sort((a, b) => b.events - a.events || a.rule.localeCompare(b.rule));
+      const by_surface = [...surfaces.entries()].map(([surface, count]) => ({ surface, events: count })).sort((a, b) => b.events - a.events || a.surface.localeCompare(b.surface));
+      return {
+        schema_version: AUDIT_SCHEMA_VERSION,
+        events,
+        blocked,
+        warnings,
+        sessions: sessions.size,
+        first_event: bounds.first === null ? null : bounds.first.timestamp,
+        last_event: bounds.last === null ? null : bounds.last.timestamp,
+        by_rule,
+        by_surface,
+        interpretation: "finding-is-not-proof-of-intent"
+      };
+    }
   };
 }
+function summarizeAudit(events) {
+  const aggregator = createAuditAggregator();
+  for (const event of events) aggregator.add(event);
+  return aggregator.finish();
+}
 function renderAuditStats(summary) {
   const out3 = [
     "TamperWard audit stats",
@@ -12408,21 +12466,24 @@ function runStats(opts = {}) {
     process.stdout.write(opts.json ? JSON.stringify(empty2) + "\n" : renderAuditStats(empty2));
     return 0;
   }
-  let events = parseAuditJsonl(readFileSync10(file, "utf8"));
-  if (cutoff !== null) {
-    events = events.filter((event) => Date.parse(event.timestamp) >= cutoff);
-  }
-  const summary = summarizeAudit(events);
+  const aggregator = createAuditAggregator();
+  forEachAuditLine(file, (line, lineNumber) => {
+    const event = parseAuditLine(line, lineNumber);
+    if (cutoff !== null && Date.parse(event.timestamp) < cutoff) return;
+    aggregator.add(event);
+  });
+  const summary = aggregator.finish();
   process.stdout.write(opts.json ? JSON.stringify(summary) + "\n" : renderAuditStats(summary));
   return 0;
 }
-var AUDIT_SCHEMA_VERSION, AUDIT_LOG_ENV, ALLOWED_KEYS;
+var AUDIT_SCHEMA_VERSION, AUDIT_LOG_ENV, MAX_AUDIT_LINE_BYTES, ALLOWED_KEYS;
 var init_audit = __esm({
   "src/cli/audit.ts"() {
     "use strict";
     init_repo_context();
     AUDIT_SCHEMA_VERSION = 1;
     AUDIT_LOG_ENV = "TAMPERWARD_AUDIT_LOG";
+    MAX_AUDIT_LINE_BYTES = 16 * 1024;
     ALLOWED_KEYS = /* @__PURE__ */ new Set([
       "schema_version",
       "id",
@@ -12438,14 +12499,14 @@ 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 { readFileSync as readFileSync10, appendFileSync as appendFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "node:fs";
 import { createHash as createHash7 } from "node:crypto";
 function setSnapshotCache(cache3) {
   snapshotCache = cache3;
 }
 function readStdin() {
   try {
-    return readFileSync11(0, "utf8");
+    return readFileSync10(0, "utf8");
   } catch (e) {
     throw new HookInputError(`cannot read the hook payload on stdin: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -12738,7 +12799,7 @@ function turnTransientBlocks(cwd, sessionId, policy, changes) {
   if (!existsSync10(log)) return none;
   let offset = 0;
   if (cp && existsSync10(cp)) {
-    const n2 = Number(readFileSync11(cp, "utf8"));
+    const n2 = Number(readFileSync10(cp, "utf8"));
     offset = Number.isFinite(n2) ? n2 : 0;
   }
   const drained = drainEvents(log, offset);
@@ -13012,13 +13073,13 @@ var init_ptree_cache = __esm({
 });
 
 // src/cli/hook-service.ts
-import { chmodSync, existsSync as existsSync11, lstatSync as lstatSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync12, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { chmodSync, existsSync as existsSync11, lstatSync as lstatSync6, 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";
 function readServiceState(paths) {
   try {
-    const v = JSON.parse(readFileSync12(paths.state, "utf8"));
+    const v = JSON.parse(readFileSync11(paths.state, "utf8"));
     if (!isRecord(v)) return null;
     const { pid, version, root, started_at } = v;
     if (typeof pid !== "number" || typeof version !== "string" || typeof root !== "string" || typeof started_at !== "string") return null;
@@ -13579,7 +13640,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 readFileSync13, realpathSync as realpathSync5 } from "node:fs";
+import { existsSync as existsSync12, 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 {
@@ -13673,34 +13734,34 @@ function verifierCandidates(cwd) {
     if (!candidates.includes(command)) candidates.push(command);
   };
   try {
-    const pkg = JSON.parse(readFileSync13(join15(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync12(join15(cwd, "package.json"), "utf8"));
     const test = isRecord(pkg) && isRecord(pkg.scripts) ? pkg.scripts.test : void 0;
     if (typeof test === "string" && test.trim() !== "" && !/error:\s*no test specified/i.test(test)) add("npm test");
   } catch {
   }
   try {
-    const pyproject = readFileSync13(join15(cwd, "pyproject.toml"), "utf8");
+    const pyproject = readFileSync12(join15(cwd, "pyproject.toml"), "utf8");
     if (/^\s*\[tool\.pytest(?:\.ini_options)?\]\s*$/m.test(pyproject)) add("pytest");
   } catch {
   }
   if (existsSync12(join15(cwd, "pytest.ini"))) add("pytest");
   try {
-    const setupCfg = readFileSync13(join15(cwd, "setup.cfg"), "utf8");
+    const setupCfg = readFileSync12(join15(cwd, "setup.cfg"), "utf8");
     if (/^\s*\[tool:pytest\]\s*$/m.test(setupCfg)) add("pytest");
   } catch {
   }
   try {
-    const tox = readFileSync13(join15(cwd, "tox.ini"), "utf8");
+    const tox = readFileSync12(join15(cwd, "tox.ini"), "utf8");
     if (/^\s*\[tox\]\s*$/m.test(tox)) add("tox");
   } catch {
   }
   try {
-    const cargo = readFileSync13(join15(cwd, "Cargo.toml"), "utf8");
+    const cargo = readFileSync12(join15(cwd, "Cargo.toml"), "utf8");
     if (/^\s*\[(?:package|workspace)\]\s*(?:#.*)?$/m.test(cargo)) add("cargo test");
   } catch {
   }
   try {
-    const goMod = readFileSync13(join15(cwd, "go.mod"), "utf8");
+    const goMod = readFileSync12(join15(cwd, "go.mod"), "utf8");
     if (/^\s*module\s+\S+\s*(?:\/\/.*)?$/m.test(goMod)) add("go test ./...");
   } catch {
   }
@@ -13772,7 +13833,7 @@ function planGitignore(cwd) {
   }
   const refused = refuseNonRegular(path);
   if (refused) return { item: "gitignore", path: rel, status: "error", detail: refused };
-  if (kind === "file") existing = readFileSync13(path, "utf8");
+  if (kind === "file") existing = readFileSync12(path, "utf8");
   try {
     const tracked = execFileSync6("git", ["ls-files", "--cached", "--", "node_modules"], {
       cwd,
@@ -13830,7 +13891,7 @@ function planClaudeHooks(cwd) {
   if (existsSync12(path)) {
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync13(path, "utf8"));
+      parsed = JSON.parse(readFileSync12(path, "utf8"));
     } catch {
       return {
         item: "agent",
@@ -13972,7 +14033,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) ? readFileSync13(path, "utf8") : null;
+  const existing = existsSync12(path) ? readFileSync12(path, "utf8") : null;
   const hookMode = () => existingMode(path, 493) | 73;
   if (existing === null) {
     return {
@@ -14063,7 +14124,7 @@ function planCodeowners(cwd) {
   const path = join15(cwd, existingRel ?? rel);
   const refused = refuseNonRegular(path);
   if (refused) return { item: "codeowners", path: existingRel ?? rel, status: "error", detail: refused };
-  const existing = existingRel ? readFileSync13(path, "utf8") : null;
+  const existing = existingRel ? readFileSync12(path, "utf8") : null;
   const missing = CODEOWNERS_PATHS.filter((p) => existing === null || !coveredBy(existing, p));
   if (existingRel !== void 0 && missing.length === 0) {
     return { item: "codeowners", path: existingRel, status: "ok", detail: "gate paths already have code owners" };
@@ -14114,7 +14175,7 @@ function planWorkflow(cwd, force) {
   }
   let src;
   try {
-    src = readFileSync13(path, "utf8");
+    src = readFileSync12(path, "utf8");
   } catch {
     return { item: "ci", path: rel, status: "error", detail: "exists but cannot be read \u2014 refusing to overwrite" };
   }
@@ -14414,7 +14475,7 @@ import {
   existsSync as existsSync13,
   lstatSync as lstatSync8,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync13,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync6,
   statSync as statSync3
@@ -14472,7 +14533,7 @@ function fingerprintRoot(root, cwd, h) {
       st = statSync3(path);
       if (!st.isFile()) throw new Error("not a regular file");
       h.update(label + "\0external-file\0" + path + "\0" + String(st.mode) + "\0");
-      h.update(readFileSync14(path));
+      h.update(readFileSync13(path));
       h.update("\0");
     } catch (e) {
       throw new Unattestable(
@@ -14506,7 +14567,7 @@ function fingerprintRoot(root, cwd, h) {
       h.update(rel + "\0" + ident.kind + "\0" + String(ident.mode) + "\0");
       if (ident.kind === "file") {
         try {
-          h.update(readFileSync14(path));
+          h.update(readFileSync13(path));
           h.update("\0");
         } catch (e) {
           throw new Unattestable(
@@ -14677,7 +14738,7 @@ function venvProblem(root) {
   const cfg = join16(root, "pyvenv.cfg");
   if (!existsSync13(cfg)) return "VIRTUAL_ENV " + JSON.stringify(root) + " has no pyvenv.cfg";
   try {
-    const body = readFileSync14(cfg, "utf8");
+    const body = readFileSync13(cfg, "utf8");
     if (/^\s*include-system-site-packages\s*=\s*true\s*$/im.test(body)) {
       return "Python environment " + JSON.stringify(root) + " enables system site-packages; those external package roots are not bounded";
     }
@@ -15193,7 +15254,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 readFileSync15, realpathSync as realpathSync7, statSync as statSync4 } from "node:fs";
+import { accessSync as accessSync2, constants as constants3, 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;
@@ -15238,7 +15299,7 @@ function findExecutable(name) {
   return null;
 }
 function fileSha256(path) {
-  return createHash11("sha256").update(readFileSync15(path)).digest("hex");
+  return createHash11("sha256").update(readFileSync14(path)).digest("hex");
 }
 function engineClientEnv() {
   return {
@@ -15672,7 +15733,7 @@ var init_verifier_backend = __esm({
 // src/verification-state.ts
 import { execFileSync as execFileSync8 } from "node:child_process";
 import { createHash as createHash12 } from "node:crypto";
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync15, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
 import { dirname as dirname8, join as join19 } from "node:path";
 function git2(args, cwd) {
   return execFileSync8("git", args, {
@@ -15721,7 +15782,7 @@ function interventionWiring(cwd) {
   return sources.map(([source, path]) => {
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync16(path, "utf8"));
+      parsed = JSON.parse(readFileSync15(path, "utf8"));
     } catch {
       return { source, present: false };
     }
@@ -15874,7 +15935,7 @@ function readVerificationRecord(cwd) {
   if (!path) return null;
   let raw;
   try {
-    raw = readFileSync16(path, "utf8");
+    raw = readFileSync15(path, "utf8");
   } catch {
     return null;
   }
@@ -15923,7 +15984,7 @@ function readVerifyingMarker(cwd) {
   if (!path) return null;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync16(path, "utf8"));
+    parsed = JSON.parse(readFileSync15(path, "utf8"));
   } catch {
     return null;
   }
@@ -16035,7 +16096,7 @@ var init_verification_state = __esm({
 // src/cli/verify.ts
 import { execFileSync as execFileSync9, spawnSync as spawnSync3 } from "node:child_process";
 import { createHash as createHash13 } from "node:crypto";
-import { chmodSync as chmodSync2, cpSync, lstatSync as lstatSync9, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync3, readFileSync as readFileSync17, readlinkSync as readlinkSync3, rmSync as rmSync8, symlinkSync, writeFileSync as writeFileSync10, existsSync as existsSync14 } from "node:fs";
+import { chmodSync as chmodSync2, cpSync, lstatSync as lstatSync9, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, readlinkSync as readlinkSync3, rmSync as rmSync8, symlinkSync, writeFileSync as writeFileSync10, existsSync as existsSync14 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { dirname as dirname9, isAbsolute as isAbsolute11, join as join20, relative as relative6, resolve as resolve9, sep as sep4 } from "node:path";
 function oracleAssuranceReport() {
@@ -16295,7 +16356,7 @@ function overlayDigest(dest, paths) {
     try {
       const st = lstatSync9(p);
       h.update(String(st.mode));
-      h.update(st.isSymbolicLink() ? readlinkSync3(p) : readFileSync17(p));
+      h.update(st.isSymbolicLink() ? readlinkSync3(p) : readFileSync16(p));
     } catch {
       h.update("<gone>");
     }
@@ -17092,7 +17153,7 @@ var init_verify = __esm({
 // src/cli/run.ts
 import { execFileSync as execFileSync10, spawn, spawnSync as spawnSync4 } from "node:child_process";
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { accessSync as accessSync3, constants as fsConstants, mkdtempSync as mkdtempSync4, readdirSync as readdirSync4, readFileSync as readFileSync18, readlinkSync as readlinkSync4, realpathSync as realpathSync8, rmSync as rmSync9, statSync as statSync5, writeFileSync as writeFileSync11 } from "node:fs";
+import { accessSync as accessSync3, constants as fsConstants, mkdtempSync as mkdtempSync4, readdirSync as readdirSync4, readFileSync as readFileSync17, readlinkSync as readlinkSync4, realpathSync as realpathSync8, rmSync as rmSync9, statSync as statSync5, writeFileSync as writeFileSync11 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { dirname as dirname10, join as join21, resolve as resolve10 } from "node:path";
 function authoritativeRunLifecyclePlatform(platform = process.platform) {
@@ -17246,7 +17307,7 @@ function runAgentSupervised(argv, cwd, budgetSecs, linuxPythonCandidates, lifecy
     }
     let state = {};
     try {
-      state = JSON.parse(readFileSync18(resultFile, "utf8"));
+      state = JSON.parse(readFileSync17(resultFile, "utf8"));
     } catch {
       return {
         exit: 1,
@@ -17290,7 +17351,7 @@ function observerExited(pid) {
   if (!pidAlive4(pid)) return true;
   if (process.platform !== "linux") return false;
   try {
-    const stat = readFileSync18(`/proc/${pid}/stat`, "utf8");
+    const stat = readFileSync17(`/proc/${pid}/stat`, "utf8");
     const state = stat.slice(stat.lastIndexOf(")") + 2).split(" ")[0];
     return state === "Z" || state === "X";
   } catch (e) {
@@ -17412,7 +17473,7 @@ function git4(args, cwd) {
 }
 function nowTicks() {
   try {
-    return Math.floor(parseFloat(readFileSync18("/proc/uptime", "utf8").split(" ")[0]) * 100);
+    return Math.floor(parseFloat(readFileSync17("/proc/uptime", "utf8").split(" ")[0]) * 100);
   } catch {
     return Number.POSITIVE_INFINITY;
   }
@@ -17435,7 +17496,7 @@ function survivorsHoldingTree(cwd, spawnedAfterTicks) {
     const n2 = Number(pid);
     if (n2 === process.pid) continue;
     try {
-      const stat = readFileSync18(`/proc/${pid}/stat`, "utf8");
+      const stat = readFileSync17(`/proc/${pid}/stat`, "utf8");
       const startTicks = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]);
       if (!Number.isFinite(startTicks) || startTicks < spawnedAfterTicks) continue;
     } catch {
@@ -18008,7 +18069,7 @@ raise SystemExit(0)
 
 // src/cli/doctor.ts
 import { execFileSync as execFileSync11 } from "node:child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync19, readdirSync as readdirSync5 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync18, readdirSync as readdirSync5 } from "node:fs";
 import { join as join22, resolve as resolve11 } from "node:path";
 function lifecyclePlatformCheck(platform = process.platform, linuxPython = platform === "linux" ? trustedLinuxPython() : null) {
   if (platform === "linux") {
@@ -18067,7 +18128,7 @@ function pinsInFile(path) {
   if (!existsSync15(path)) return [];
   let src = "";
   try {
-    src = readFileSync19(path, "utf8");
+    src = readFileSync18(path, "utf8");
   } catch {
     return [];
   }
@@ -18094,7 +18155,7 @@ function workflowPermissionCheck(cwd, workflowRels = [".github/workflows/tamperw
     }
     let doc;
     try {
-      doc = yaml.parse(readFileSync19(path, "utf8"));
+      doc = yaml.parse(readFileSync18(path, "utf8"));
     } catch (e) {
       broken.push(`${rel} is not valid YAML (${e instanceof Error ? e.message : String(e)})`);
       continue;
@@ -18518,7 +18579,7 @@ function diagnose(opts = {}) {
     }
     let doc;
     try {
-      doc = yaml.parse(readFileSync19(workflowPath, "utf8"));
+      doc = yaml.parse(readFileSync18(workflowPath, "utf8"));
     } catch (e) {
       return fail(
         "ci-verifier",
@@ -18831,7 +18892,7 @@ import { execFileSync as execFileSync12, spawnSync as spawnSync5 } from "node:ch
 import {
   existsSync as existsSync16,
   mkdtempSync as mkdtempSync5,
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync19,
   readdirSync as readdirSync6,
   realpathSync as realpathSync9,
   rmSync as rmSync10,
@@ -19145,7 +19206,7 @@ function straceOnce(root, command, budget) {
       }
     );
     const logs = traced.error ? [] : traceFiles(prefix);
-    const accesses = logs.flatMap((path) => parseStraceFileAccess(readFileSync20(path, "utf8"), TRACE_ROOT));
+    const accesses = logs.flatMap((path) => parseStraceFileAccess(readFileSync19(path, "utf8"), TRACE_ROOT));
     const raw = {
       spawnError: traced.error ? traced.error.message : null,
       status: traced.status,
@@ -19377,7 +19438,7 @@ var init_trace_verify = __esm({
 });
 
 // src/runtimes.ts
-import { existsSync as existsSync17, readFileSync as readFileSync21 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync20 } from "node:fs";
 import { join as join24 } from "node:path";
 function isRecord5(x) {
   return typeof x === "object" && x !== null && !Array.isArray(x);
@@ -19408,7 +19469,7 @@ function claudeSettingsBeyondTamperward(cwd) {
   let raw;
   try {
     if (!existsSync17(path)) return false;
-    raw = readFileSync21(path, "utf8");
+    raw = readFileSync20(path, "utf8");
   } catch {
     return false;
   }
@@ -19515,7 +19576,7 @@ var init_runtimes = __esm({
 
 // src/cli/onboard.ts
 import { execFileSync as execFileSync13 } from "node:child_process";
-import { lstatSync as lstatSync10, mkdtempSync as mkdtempSync6, readFileSync as readFileSync22, realpathSync as realpathSync10, rmSync as rmSync11 } from "node:fs";
+import { lstatSync as lstatSync10, mkdtempSync as mkdtempSync6, readFileSync as readFileSync21, realpathSync as realpathSync10, rmSync as rmSync11 } from "node:fs";
 import { tmpdir as tmpdir7 } from "node:os";
 import { join as join25, relative as relative8, resolve as resolve13, sep as sep6 } from "node:path";
 import { createInterface } from "node:readline";
@@ -19588,7 +19649,7 @@ function writeVerifyCommand(cwd, command) {
     return `${POLICY_FILE} is not a regular file; refusing to follow or replace a symlink or special file`;
   }
   const mode = existingMode(path, 420);
-  const original = kind === "file" ? readFileSync22(path, "utf8") : null;
+  const original = kind === "file" ? readFileSync21(path, "utf8") : null;
   let next;
   try {
     const doc = parseDocument(original && original.trim() ? original : "version: 1\n");
@@ -20200,7 +20261,7 @@ var init_capture = __esm({
 
 // src/research/manifest.ts
 import { createHash as createHash14 } from "node:crypto";
-import { readFileSync as readFileSync23 } from "node:fs";
+import { readFileSync as readFileSync22 } from "node:fs";
 import { dirname as dirname11, resolve as resolve15 } from "node:path";
 function taskFrom(raw, index, manifestDir) {
   const where = `task #${index + 1}`;
@@ -20234,7 +20295,7 @@ function readManifest(path) {
   const abs = resolve15(path);
   let bytes;
   try {
-    bytes = readFileSync23(abs);
+    bytes = readFileSync22(abs);
   } catch (e) {
     throw new ResearchError(`cannot read task manifest ${abs}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -20516,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";
@@ -20526,13 +20632,89 @@ 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"]])]
+    ]);
   }
 });
 
 // src/research/run.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { execFileSync as execFileSync14 } from "node:child_process";
-import { closeSync as closeSync3, existsSync as existsSync18, linkSync, mkdirSync as mkdirSync10, openSync as openSync3, readFileSync as readFileSync24, renameSync as renameSync4, rmSync as rmSync12, unlinkSync, writeFileSync as writeFileSync12, writeSync } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync18, linkSync, mkdirSync as mkdirSync10, openSync as openSync4, readFileSync as readFileSync23, renameSync as renameSync4, rmSync as rmSync12, unlinkSync, writeFileSync as writeFileSync12, writeSync } from "node:fs";
 import { hostname } from "node:os";
 import { join as join26, resolve as resolve16 } from "node:path";
 function git7(args, cwd) {
@@ -20546,7 +20728,7 @@ function researchLockPath(ledger) {
 }
 function readLockOwner(path) {
   try {
-    const parsed = JSON.parse(readFileSync24(path, "utf8"));
+    const parsed = JSON.parse(readFileSync23(path, "utf8"));
     if (!isRecord(parsed) || typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0) return null;
     if (typeof parsed.host !== "string" || typeof parsed.started_at !== "string" || typeof parsed.token !== "string") return null;
     return { pid: parsed.pid, host: parsed.host, started_at: parsed.started_at, token: parsed.token };
@@ -20612,12 +20794,12 @@ function acquireResearchLock(ledger, breakStaleLock = false) {
   const text = JSON.stringify(owner) + "\n";
   let fd = -1;
   try {
-    fd = openSync3(path, "wx", 384);
+    fd = openSync4(path, "wx", 384);
     writeSync(fd, text);
-    closeSync3(fd);
+    closeSync4(fd);
     fd = -1;
   } catch (e) {
-    if (fd !== -1) closeSync3(fd);
+    if (fd !== -1) closeSync4(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`
@@ -20631,7 +20813,7 @@ function acquireResearchLock(ledger, breakStaleLock = false) {
       if (released) return;
       released = true;
       try {
-        if (readFileSync24(path, "utf8") === text) unlinkSync(path);
+        if (readFileSync23(path, "utf8") === text) unlinkSync(path);
       } catch {
       }
     }
@@ -20640,7 +20822,7 @@ function acquireResearchLock(ledger, breakStaleLock = false) {
 function resumableRecord(path, expected) {
   let raw;
   try {
-    raw = JSON.parse(readFileSync24(path, "utf8"));
+    raw = JSON.parse(readFileSync23(path, "utf8"));
   } catch (e) {
     throw new ResearchError(`ledger record ${path} is malformed (${errorMessage(e).split("\n")[0]}); remove it to regenerate the pair, or use a new --out`);
   }
@@ -21061,27 +21243,95 @@ var init_run2 = __esm({
   }
 });
 
-// src/research/summarize.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync25 } 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(readFileSync25(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) {
@@ -21202,6 +21452,7 @@ var init_summarize = __esm({
     "use strict";
     init_machine_output();
     init_narrow();
+    init_ledger_files();
     init_adapter();
     init_record();
   }
@@ -21209,7 +21460,7 @@ var init_summarize = __esm({
 
 // src/research/init.ts
 import { createHash as createHash15 } from "node:crypto";
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync26, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync25, writeFileSync as writeFileSync13 } from "node:fs";
 import { basename as basename5, dirname as dirname12, resolve as resolve18 } from "node:path";
 function idFrom(repo) {
   const clean = repo.replace(/[\\/]$/, "").split(/[\\/]/).pop() || "task";
@@ -21261,7 +21512,7 @@ function runResearchInit(opts) {
   }
 }
 function requireHash(path) {
-  return createHash15("sha256").update(readFileSync26(path)).digest("hex");
+  return createHash15("sha256").update(readFileSync25(path)).digest("hex");
 }
 var init_init2 = __esm({
   "src/research/init.ts"() {
@@ -21328,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 readFileSync27, 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: readFileSync27(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");
@@ -21392,10 +21685,15 @@ function jsonBytes(value) {
 function validateResearchBundle(path) {
   let files;
   try {
-    files = parseTar(gunzipSync(readFileSync27(resolve19(path))));
+    files = parseTar(gunzipSync(readFileSync26(resolve19(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");
@@ -21422,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);
@@ -21443,10 +21743,10 @@ 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 = readFileSync27(resolve19(opts.manifest));
+    const manifest = readFileSync26(resolve19(opts.manifest));
     const sha3 = createHash16("sha256").update(manifest).digest("hex");
     if (sha3 !== summary.manifest_sha256) throw new ResearchError(`manifest sha256 ${sha3} does not match ledger ${summary.manifest_sha256}`);
     entries.push({ name: "manifest.json", bytes: manifest });
@@ -21494,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;
   }
 });
 
@@ -22474,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 readFileSync28, 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) {
@@ -22487,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));
@@ -22501,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)}`);
   }
@@ -22568,7 +22876,7 @@ function reconstructAfterViaGit(rawDiff, display2, before, isCreate) {
     if (statPath !== TARGET) throw new Error(`write diff reconstructs a different file (${statPath}) than the bound target`);
     git8(["--check"]);
     git8([]);
-    return op === "delete" ? null : readFileSync28(targetPath, "utf8");
+    return op === "delete" ? null : readFileSync27(targetPath, "utf8");
   } catch (e) {
     throw new Error(`could not reconstruct the write to ${display2} from its diff via git apply: ${e instanceof Error ? e.message : String(e)}`);
   } finally {
@@ -23312,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 readFileSync29, 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);
@@ -23320,9 +23628,9 @@ 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(readFileSync29(path, "utf8"));
+    const parsed = JSON.parse(readFileSync28(path, "utf8"));
     if (parsed && typeof parsed === "object" && parsed.records && typeof parsed.records === "object") return parsed;
   } catch {
     return null;
@@ -23482,9 +23790,9 @@ 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 = readFileSync29(file, "utf8");
+    const raw = readFileSync28(file, "utf8");
     let hooks = raw;
     try {
       const parsed = JSON.parse(raw);
@@ -24490,7 +24798,7 @@ var init_main = __esm({
 // src/cli/index.ts
 init_hook_client();
 init_exit();
-import { readFileSync as readFileSync30 } from "node:fs";
+import { readFileSync as readFileSync29 } from "node:fs";
 function loadMain() {
   return Promise.resolve().then(() => (init_main(), main_exports));
 }
@@ -24503,7 +24811,7 @@ async function launch(argv) {
   if (kind && hookServiceEnabled()) {
     let raw = null;
     try {
-      raw = readFileSync30(0, "utf8");
+      raw = readFileSync29(0, "utf8");
     } catch {
       raw = null;
     }

package/package.json

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