tamperward 2.34.0 → 2.36.0

package/dist/cli/index.js

@@ -10872,8 +10872,8 @@ import { dirname as dirname2, join as join9 } from "node:path";
 function compactOobToken(want, head) {
   const normalizedHead = head.trim().toLowerCase();
   if (!want || !FULL_OBJECT_ID.test(normalizedHead)) return null;
-  const digest = createHash3("sha256").update(`tamperward:oob:v1\0${want}\0${normalizedHead}`).digest("base64url");
-  return `${COMPACT_OOB_PREFIX}${digest}`;
+  const digest2 = createHash3("sha256").update(`tamperward:oob:v1\0${want}\0${normalizedHead}`).digest("base64url");
+  return `${COMPACT_OOB_PREFIX}${digest2}`;
 }
 function ledgerEntryFrom(value) {
   if (!isRecord(value)) return null;
@@ -14883,8 +14883,8 @@ function parseCapturedSupervisorResult(stdoutText) {
   };
 }
 function runCapturedProcessSync(executable, args, opts) {
-  const stateDir = mkdtempSync2(join17(tmpdir3(), "tw-suite-capture-"));
-  const configFile = join17(stateDir, "config.json");
+  const stateDir2 = mkdtempSync2(join17(tmpdir3(), "tw-suite-capture-"));
+  const configFile = join17(stateDir2, "config.json");
   const backstop = opts.backstopMs ?? 3e4;
   try {
     writeFileSync8(
@@ -14932,7 +14932,7 @@ function runCapturedProcessSync(executable, args, opts) {
     }
     return parsed;
   } finally {
-    rmSync6(stateDir, { recursive: true, force: true });
+    rmSync6(stateDir2, { recursive: true, force: true });
   }
 }
 var DIAGNOSTIC_TAIL_BYTES, EMPTY_STREAM, CLEANUP_HELPERS_SRC, CAPTURE_SUPERVISOR;
@@ -15651,12 +15651,375 @@ var init_verifier_backend = __esm({
   }
 });
 
-// src/cli/verify.ts
-import { execFileSync as execFileSync8, spawnSync as spawnSync3 } from "node:child_process";
+// src/verification-state.ts
+import { execFileSync as execFileSync8 } from "node:child_process";
 import { createHash as createHash12 } from "node:crypto";
-import { chmodSync as chmodSync2, cpSync, lstatSync as lstatSync9, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, readlinkSync as readlinkSync3, rmSync as rmSync7, symlinkSync, writeFileSync as writeFileSync9, existsSync as existsSync14 } from "node:fs";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync16, 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, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 1 << 28,
+    env: trustedGitEnv()
+  });
+}
+function resolveBaseRev(baseRef, cwd) {
+  assertRev(baseRef);
+  const rev2 = git2(["rev-parse", "--verify", `${baseRef}^{commit}`], cwd).trim();
+  try {
+    return git2(["merge-base", rev2, "HEAD"], cwd).trim();
+  } catch {
+    return rev2;
+  }
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+}
+function digest(value) {
+  return createHash12("sha256").update(canonicalJson(value)).digest("hex");
+}
+function surfacePaths(base, cwd, policy) {
+  let listing;
+  try {
+    listing = git2(["ls-tree", "-r", "--name-only", "-z", base], cwd);
+  } catch {
+    return [];
+  }
+  const inputs = policy.verify?.inputs ?? [];
+  return listing.split("\0").filter(Boolean).filter((p) => isProtected(p, policy) || matchesAny(p, inputs)).sort();
+}
+function interventionWiring(cwd) {
+  const dir = claudeConfigDir();
+  const sources = [
+    ["repo", join19(cwd, ".claude", "settings.json")],
+    ["repo.local", join19(cwd, ".claude", "settings.local.json")],
+    ["user", join19(dir, "settings.json")],
+    ["user.local", join19(dir, "settings.local.json")]
+  ];
+  return sources.map(([source, path]) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync16(path, "utf8"));
+    } catch {
+      return { source, present: false };
+    }
+    if (!isRecord4(parsed)) return { source, present: true, shape: "non-object" };
+    return {
+      source,
+      present: true,
+      hooks: parsed.hooks ?? null,
+      disableAllHooks: parsed.disableAllHooks ?? null
+    };
+  });
+}
+function dependenciesBinding(root, policy, command) {
+  const backend = policy.verify?.backend ?? "local";
+  if (backend === "container") {
+    return digest({ backend, image: policy.verify?.image ?? null });
+  }
+  const dep = discoverDependencyEnvironment(root, command);
+  return digest({ backend, status: dep.status, fingerprint: dep.fingerprint ?? null });
+}
+function computeBinding(cwd, inputs, precomputed) {
+  const root = repoRoot(cwd);
+  const head = git2(["rev-parse", "--verify", "HEAD^{commit}"], root).trim();
+  const base = resolveBaseRev(inputs.base_ref, root);
+  const policy = inputs.explicit_base ? loadPolicyAt(base, root) ?? defaultPolicy() : loadPolicy(root);
+  const command = inputs.command_source === "flag" ? inputs.command : policy.verify?.command ?? "";
+  if (!command) {
+    throw new Error("no verifier command is configured for the recorded verification");
+  }
+  const budget = inputs.budget_source === "flag" ? inputs.budget : policy.verify?.budget ?? 300;
+  const protectedIgnored = (rel) => isProtected(rel, policy);
+  return {
+    // NOTE (#500/#600 follow-up): `tree` hashes every tracked and ignored-protected
+    // file and `dependencies` walks the attested dependency roots, on EVERY call.
+    // Right for `verify` (once per run) and reused there via `precomputed.tree`,
+    // but `status` is meant to be polled continuously by a status bar/dashboard,
+    // where a large repository makes each poll a full read. A stat-cache identity
+    // (git's index plus hashing only what changed) is a deliberate follow-up, not
+    // built here.
+    tree: precomputed?.tree ?? treeFingerprint(root, protectedIgnored),
+    head,
+    base,
+    policy: digest(policy),
+    verifier: digest({
+      command,
+      budget,
+      inputs: policy.verify?.inputs ?? [],
+      backend: policy.verify?.backend ?? "local",
+      image: policy.verify?.image ?? null
+    }),
+    surface: digest(surfacePaths(base, root, policy)),
+    intervention: digest(interventionWiring(root)),
+    dependencies: dependenciesBinding(root, policy, command)
+  };
+}
+function stateDir(cwd) {
+  const ctx = repoContext(cwd);
+  return ctx ? join19(ctx.gitDir, "tamperward") : null;
+}
+function verificationRecordPath(cwd) {
+  const dir = stateDir(cwd);
+  return dir ? join19(dir, "verification-state.json") : null;
+}
+function verifyingMarkerPath(cwd) {
+  const dir = stateDir(cwd);
+  return dir ? join19(dir, "verifying.json") : null;
+}
+function recordVerification(cwd, inputs, treeFingerprintValue) {
+  const path = verificationRecordPath(cwd);
+  if (!path) return false;
+  const binding = computeBinding(
+    repoRoot(cwd),
+    inputs,
+    treeFingerprintValue ? { tree: treeFingerprintValue } : void 0
+  );
+  const record = {
+    schema_version: VERIFICATION_STATE_SCHEMA_VERSION,
+    verdict: "VERIFIED",
+    verified_at: (/* @__PURE__ */ new Date()).toISOString(),
+    tw_version: TW_VERSION,
+    inputs,
+    binding
+  };
+  mkdirSync8(dirname8(path), { recursive: true });
+  writeFileSync9(path, JSON.stringify(record) + "\n");
+  return true;
+}
+function invalidateVerificationRecordIfCurrent(cwd) {
+  const record = readVerificationRecord(cwd);
+  if (!record) return false;
+  let live;
+  try {
+    live = computeBinding(cwd, record.inputs);
+  } catch {
+    return false;
+  }
+  if (firstMismatch(record.binding, live)) return false;
+  const path = verificationRecordPath(cwd);
+  if (!path) return false;
+  try {
+    rmSync7(path, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRecord4(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isBinding(v) {
+  if (!isRecord4(v)) return false;
+  return BINDING_INPUTS.every((k) => {
+    const val = v[k];
+    return typeof val === "string" && val.length > 0;
+  });
+}
+function parseVerificationRecord(value) {
+  if (!isRecord4(value)) return null;
+  if (value.schema_version !== VERIFICATION_STATE_SCHEMA_VERSION) return null;
+  if (value.verdict !== "VERIFIED") return null;
+  if (typeof value.verified_at !== "string") return null;
+  if (typeof value.tw_version !== "string") return null;
+  const inputs = value.inputs;
+  if (!isRecord4(inputs)) return null;
+  if (typeof inputs.base_ref !== "string" || inputs.base_ref.length === 0) return null;
+  if (typeof inputs.explicit_base !== "boolean") return null;
+  if (inputs.command_source !== "policy" && inputs.command_source !== "flag") return null;
+  if (typeof inputs.command !== "string") return null;
+  if (inputs.budget_source !== "policy" && inputs.budget_source !== "flag") return null;
+  if (typeof inputs.budget !== "number" || !Number.isFinite(inputs.budget)) return null;
+  if (!isBinding(value.binding)) return null;
+  return {
+    schema_version: VERIFICATION_STATE_SCHEMA_VERSION,
+    verdict: "VERIFIED",
+    verified_at: value.verified_at,
+    tw_version: value.tw_version,
+    inputs: {
+      base_ref: inputs.base_ref,
+      explicit_base: inputs.explicit_base,
+      command_source: inputs.command_source,
+      command: inputs.command,
+      budget_source: inputs.budget_source,
+      budget: inputs.budget
+    },
+    binding: value.binding
+  };
+}
+function readVerificationRecord(cwd) {
+  const path = verificationRecordPath(cwd);
+  if (!path) return null;
+  let raw;
+  try {
+    raw = readFileSync16(path, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  return parseVerificationRecord(parsed);
+}
+function pidAlive3(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return isRecord4(e) && e.code === "EPERM";
+  }
+}
+function beginVerifying(cwd) {
+  const path = verifyingMarkerPath(cwd);
+  if (!path) return false;
+  try {
+    const marker = {
+      schema_version: VERIFICATION_STATE_SCHEMA_VERSION,
+      pid: process.pid,
+      started_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    mkdirSync8(dirname8(path), { recursive: true });
+    writeFileSync9(path, JSON.stringify(marker) + "\n");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function endVerifying(cwd) {
+  const path = verifyingMarkerPath(cwd);
+  if (!path) return;
+  try {
+    rmSync7(path, { force: true });
+  } catch {
+  }
+}
+function readVerifyingMarker(cwd) {
+  const path = verifyingMarkerPath(cwd);
+  if (!path) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync16(path, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isRecord4(parsed)) return null;
+  if (parsed.schema_version !== VERIFICATION_STATE_SCHEMA_VERSION) return null;
+  if (typeof parsed.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0) return null;
+  if (typeof parsed.started_at !== "string") return null;
+  if (!pidAlive3(parsed.pid)) return null;
+  return { schema_version: VERIFICATION_STATE_SCHEMA_VERSION, pid: parsed.pid, started_at: parsed.started_at };
+}
+function firstMismatch(recorded, live) {
+  for (const input of MISMATCH_PRIORITY) {
+    if (recorded[input] !== live[input]) return input;
+  }
+  return null;
+}
+function evaluateVerificationState(cwd) {
+  if (readVerifyingMarker(cwd)) {
+    return { state: "VERIFYING", reason: "a verification is in progress" };
+  }
+  const record = readVerificationRecord(cwd);
+  if (!record) {
+    return {
+      state: "UNVERIFIED",
+      reason: "no successful verification has been recorded for this repository"
+    };
+  }
+  let live;
+  try {
+    live = computeBinding(cwd, record.inputs);
+  } catch (e) {
+    return {
+      state: "BROKEN",
+      reason: "verification authority wiring is invalid or unavailable",
+      detail: e instanceof Error ? e.message : String(e),
+      verified_at: record.verified_at,
+      verifier_command: record.inputs.command,
+      record
+    };
+  }
+  const changed = firstMismatch(record.binding, live);
+  if (!changed) {
+    return {
+      state: "CURRENT",
+      verified_at: record.verified_at,
+      base: live.base,
+      head: live.head,
+      verifier_command: record.inputs.command,
+      record
+    };
+  }
+  return {
+    state: "STALE",
+    changed_input: changed,
+    reason: STALE_REASON[changed],
+    verified_at: record.verified_at,
+    base: live.base,
+    head: live.head,
+    verifier_command: record.inputs.command,
+    record
+  };
+}
+var VERIFICATION_STATE_SCHEMA_VERSION, BINDING_INPUTS, STALE_REASON, MISMATCH_PRIORITY;
+var init_verification_state = __esm({
+  "src/verification-state.ts"() {
+    "use strict";
+    init_build();
+    init_trusted();
+    init_fingerprint();
+    init_policy();
+    init_policy_load();
+    init_repo_context();
+    init_wiring();
+    init_dependency_env();
+    VERIFICATION_STATE_SCHEMA_VERSION = 1;
+    BINDING_INPUTS = [
+      "tree",
+      "head",
+      "base",
+      "policy",
+      "verifier",
+      "surface",
+      "intervention",
+      "dependencies"
+    ];
+    STALE_REASON = {
+      tree: "candidate tree changed since verification",
+      head: "HEAD commit changed since verification",
+      base: "trusted base commit changed since verification",
+      policy: "TamperWard policy changed since verification",
+      verifier: "verifier configuration changed since verification",
+      surface: "protected verification surface changed since verification",
+      intervention: "runtime steering wiring changed since verification",
+      dependencies: "dependency environment changed since verification"
+    };
+    MISMATCH_PRIORITY = [
+      "head",
+      "base",
+      "verifier",
+      "surface",
+      "intervention",
+      "dependencies",
+      "policy",
+      "tree"
+    ];
+  }
+});
+
+// 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 { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname8, isAbsolute as isAbsolute11, join as join19, relative as relative6, resolve as resolve9, sep as sep4 } from "node:path";
+import { dirname as dirname9, isAbsolute as isAbsolute11, join as join20, relative as relative6, resolve as resolve9, sep as sep4 } from "node:path";
 function oracleAssuranceReport() {
   return {
     level: "suite-exit-only",
@@ -15665,14 +16028,14 @@ function oracleAssuranceReport() {
     limitation: "candidate source executes inside the configured suite process and may terminate or interpose on that in-process oracle; isolated-container is execution-domain isolation, not semantic/oracle isolation"
   };
 }
-function git2(args, cwd) {
-  return execFileSync8("git", args, { cwd, encoding: "utf8", maxBuffer: 1 << 28, env: trustedGitEnv() });
+function git3(args, cwd) {
+  return execFileSync9("git", args, { cwd, encoding: "utf8", maxBuffer: 1 << 28, env: trustedGitEnv() });
 }
 function resolveBase(base, cwd) {
   assertRev(base);
-  const rev2 = git2(["rev-parse", "--verify", `${base}^{commit}`], cwd).trim();
+  const rev2 = git3(["rev-parse", "--verify", `${base}^{commit}`], cwd).trim();
   try {
-    return git2(["merge-base", rev2, "HEAD"], cwd).trim();
+    return git3(["merge-base", rev2, "HEAD"], cwd).trim();
   } catch {
     return rev2;
   }
@@ -15720,15 +16083,15 @@ function rootedLinkTarget(target) {
   return isAbsolute11(target) || driveRelativeLinkTarget(target);
 }
 function safeSymlink(target, out3, root, label) {
-  if (rootedLinkTarget(target) || !inside2(root, resolve9(dirname8(out3), target))) {
+  if (rootedLinkTarget(target) || !inside2(root, resolve9(dirname9(out3), target))) {
     throw linkEscape(label, target);
   }
-  rmSync7(out3, { force: true });
+  rmSync8(out3, { force: true });
   symlinkSync(target, out3);
 }
 function validateSymlinkGraph(target, out3, root, dependencyRoot, label) {
   let domain = "tree";
-  let stack = linkParts(relative6(root, dirname8(out3)));
+  let stack = linkParts(relative6(root, dirname9(out3)));
   const pending = linkParts(target);
   const seen = /* @__PURE__ */ new Set();
   let hops = 0;
@@ -15745,7 +16108,7 @@ function validateSymlinkGraph(target, out3, root, dependencyRoot, label) {
       continue;
     }
     const base = domain === "deps" && dependencyRoot ? dependencyRoot : root;
-    const current = join19(base, ...stack);
+    const current = join20(base, ...stack);
     let st;
     try {
       st = lstatSync9(current);
@@ -15787,7 +16150,7 @@ function rejectLinkedParent(cwd, rel) {
   const parts = rel.split("/").slice(0, -1);
   let current = cwd;
   for (const part of parts) {
-    current = join19(current, part);
+    current = join20(current, part);
     let st;
     try {
       st = lstatSync9(current);
@@ -15812,7 +16175,7 @@ function materialize(cwd, dest, dependencyRoot) {
   }
   const links = [];
   for (const rel of listed) {
-    const src = join19(cwd, rel);
+    const src = join20(cwd, rel);
     rejectLinkedParent(cwd, rel);
     let st;
     try {
@@ -15820,8 +16183,8 @@ function materialize(cwd, dest, dependencyRoot) {
     } catch {
       continue;
     }
-    const out3 = join19(dest, rel);
-    mkdirSync8(dirname8(out3), { recursive: true });
+    const out3 = join20(dest, rel);
+    mkdirSync9(dirname9(out3), { recursive: true });
     dropSymlink(out3);
     if (st.isSymbolicLink()) {
       const target = readlinkSync3(src);
@@ -15840,19 +16203,19 @@ function materialize(cwd, dest, dependencyRoot) {
   for (const link of links) {
     validateSymlinkGraph(link.target, link.out, dest, dependencyRoot, link.rel);
   }
-  if (dependencyRoot) symlinkSync(dependencyRoot, join19(dest, "node_modules"), "dir");
+  if (dependencyRoot) symlinkSync(dependencyRoot, join20(dest, "node_modules"), "dir");
 }
 function workingTreePaths(cwd) {
-  return git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
+  return git3(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
 }
 function probeFilesystemCaseSensitivity(dir) {
-  const upper = join19(dir, ".tw-case-probe-A");
-  const lower = join19(dir, ".tw-case-probe-a");
+  const upper = join20(dir, ".tw-case-probe-A");
+  const lower = join20(dir, ".tw-case-probe-a");
   try {
-    writeFileSync9(upper, "", { flag: "wx" });
+    writeFileSync10(upper, "", { flag: "wx" });
     return !existsSync14(lower);
   } finally {
-    rmSync7(upper, { force: true });
+    rmSync8(upper, { force: true });
   }
 }
 function foldCase(p) {
@@ -15870,7 +16233,7 @@ function caseFoldCollision(paths) {
 }
 function dropSymlink(p) {
   try {
-    if (lstatSync9(p).isSymbolicLink()) rmSync7(p, { force: true });
+    if (lstatSync9(p).isSymbolicLink()) rmSync8(p, { force: true });
   } catch {
   }
 }
@@ -15899,22 +16262,22 @@ function verifierCoveredInputs(cmd, atBase, policy) {
   return covered;
 }
 function baseEntries(base, cwd) {
-  return git2(["ls-tree", "-r", "-z", base], cwd).split("\0").filter(Boolean).map((rec) => {
+  return git3(["ls-tree", "-r", "-z", base], cwd).split("\0").filter(Boolean).map((rec) => {
     const tab = rec.indexOf("	");
     const [mode, type] = rec.slice(0, tab).split(" ");
     return { mode, type, path: rec.slice(tab + 1) };
   });
 }
 function overlayDigest(dest, paths) {
-  const h = createHash12("sha256");
+  const h = createHash13("sha256");
   for (const rel of [...paths].sort()) {
     h.update(rel);
     h.update("\0");
-    const p = join19(dest, rel);
+    const p = join20(dest, rel);
     try {
       const st = lstatSync9(p);
       h.update(String(st.mode));
-      h.update(st.isSymbolicLink() ? readlinkSync3(p) : readFileSync16(p));
+      h.update(st.isSymbolicLink() ? readlinkSync3(p) : readFileSync17(p));
     } catch {
       h.update("<gone>");
     }
@@ -15943,16 +16306,16 @@ function overlayPristine(cwd, base, dest, policy, cmd, dependencyRoot, caseSensi
     if (e.type === "commit") {
       throw new Error(`the base's ${e.path} is a submodule; the pristine copy cannot reproduce it`);
     }
-    const content = execFileSync8("git", ["show", `${base}:${e.path}`], { cwd, maxBuffer: 1 << 28, env: trustedGitEnv() });
-    const out3 = join19(dest, e.path);
-    mkdirSync8(dirname8(out3), { recursive: true });
-    rmSync7(out3, { force: true });
+    const content = execFileSync9("git", ["show", `${base}:${e.path}`], { cwd, maxBuffer: 1 << 28, env: trustedGitEnv() });
+    const out3 = join20(dest, e.path);
+    mkdirSync9(dirname9(out3), { recursive: true });
+    rmSync8(out3, { force: true });
     if (e.mode === "120000") {
       const target = content.toString("utf8");
       safeSymlink(target, out3, dest, `the base's ${e.path}`);
       restoredLinks.push({ path: e.path, out: out3, target });
     } else {
-      writeFileSync9(out3, content);
+      writeFileSync10(out3, content);
       chmodSync2(out3, parseInt(e.mode.slice(-4), 8) & 511);
     }
     restored.push(e.path);
@@ -15961,7 +16324,7 @@ function overlayPristine(cwd, base, dest, policy, cmd, dependencyRoot, caseSensi
   const inCopy = workingTreePaths(cwd);
   for (const rel of inCopy) {
     if (!isOverlay(rel) || baseProtected.has(fold(rel))) continue;
-    rmSync7(join19(dest, rel), { force: true });
+    rmSync8(join20(dest, rel), { force: true });
     removed++;
   }
   for (const link of restoredLinks) {
@@ -15975,9 +16338,9 @@ function suiteEnv(scratch) {
     if (DROPPED_ENV.has(k) || PINNED_NPM.test(k)) continue;
     env[k] = v;
   }
-  const userRc = join19(scratch, "npmrc-user");
-  const globalRc = join19(scratch, "npmrc-global");
-  for (const f of [userRc, globalRc]) writeFileSync9(f, "", { mode: 292 });
+  const userRc = join20(scratch, "npmrc-user");
+  const globalRc = join20(scratch, "npmrc-global");
+  for (const f of [userRc, globalRc]) writeFileSync10(f, "", { mode: 292 });
   env.npm_config_userconfig = userRc;
   env.npm_config_globalconfig = globalRc;
   env.npm_config_node_options = " ";
@@ -16008,7 +16371,7 @@ function runLocalSuite(dir, cmd, budgetSecs) {
       reason: `checkpointed-local verifier is unsupported on ${process.platform}; no trusted local shell contract is defined`
     };
   }
-  const scratch = mkdtempSync3(join19(tmpdir4(), "tw-verify-run-"));
+  const scratch = mkdtempSync3(join20(tmpdir4(), "tw-verify-run-"));
   try {
     const r = runCapturedProcessSync(shell.executable, shell.args, {
       cwd: dir,
@@ -16053,7 +16416,7 @@ function runLocalSuite(dir, cmd, budgetSecs) {
       diagnostics: r.diagnostics
     };
   } finally {
-    rmSync7(scratch, { recursive: true, force: true });
+    rmSync8(scratch, { recursive: true, force: true });
   }
 }
 function diagnosticsJson(diagnostics, includeTail) {
@@ -16098,6 +16461,15 @@ function verifyVerdictLine(verdict2, ctx) {
   }
 }
 function runVerify(opts) {
+  const markerCwd = repoRoot(opts.cwd ?? process.cwd());
+  const marked = opts.silent ? false : beginVerifying(markerCwd);
+  try {
+    return runVerifyImpl(opts);
+  } finally {
+    if (marked) endVerifying(markerCwd);
+  }
+}
+function runVerifyImpl(opts) {
   const cwd = repoRoot(opts.cwd ?? process.cwd());
   const colour = opts.silent ? false : colourEnabled(process.env, process.stdout);
   const paintVerify = (s) => {
@@ -16137,7 +16509,7 @@ function runVerify(opts) {
     return cannotVerify("POLICY_ERROR", `cannot load policy (${e instanceof Error ? e.message : String(e)})`);
   }
   if (opts.requireAncestor) {
-    const requested = git2(["rev-parse", "--verify", `${opts.base ?? "HEAD"}^{commit}`], cwd).trim();
+    const requested = git3(["rev-parse", "--verify", `${opts.base ?? "HEAD"}^{commit}`], cwd).trim();
     if (!baseIsAncestorOfHead(requested, cwd)) {
       return cannotVerify(
         "BASE_NOT_ANCESTOR",
@@ -16245,17 +16617,17 @@ function runVerify(opts) {
   } catch {
     return cannotVerify("BASE_UNRESOLVABLE", `cannot resolve base rev "${opts.base ?? "HEAD"}"`);
   }
-  const visRoot = mkdtempSync3(join19(tmpdir4(), "tw-verify-vis-"));
-  const visDir = join19(visRoot, "t");
+  const visRoot = mkdtempSync3(join20(tmpdir4(), "tw-verify-vis-"));
+  const visDir = join20(visRoot, "t");
   const cleanup = (dirs) => {
     if (opts.keep) return;
-    for (const d of dirs) rmSync7(d, { recursive: true, force: true });
+    for (const d of dirs) rmSync8(d, { recursive: true, force: true });
   };
   filesystemCaseSensitive = (opts.probeCaseSensitivity ?? probeFilesystemCaseSensitivity)(visRoot);
   if (!filesystemCaseSensitive) {
     const present = (rel) => {
       try {
-        lstatSync9(join19(cwd, rel));
+        lstatSync9(join20(cwd, rel));
         return true;
       } catch {
         return false;
@@ -16287,7 +16659,7 @@ function runVerify(opts) {
     );
   }
   try {
-    mkdirSync8(visDir);
+    mkdirSync9(visDir);
     materialize(cwd, visDir, frozenNodeModules);
   } catch (e) {
     cleanup([visRoot]);
@@ -16388,12 +16760,12 @@ function runVerify(opts) {
       { stage: "visible", dependency_environment: dependencyReport(), verifier_backend: backendReport(), oracle_assurance: oracleAssuranceReport() }
     );
   }
-  const priRoot = mkdtempSync3(join19(tmpdir4(), "tw-verify-pri-"));
-  const priDir = join19(priRoot, "t");
+  const priRoot = mkdtempSync3(join20(tmpdir4(), "tw-verify-pri-"));
+  const priDir = join20(priRoot, "t");
   let restored = [];
   let removedAdded = 0;
   try {
-    mkdirSync8(priDir);
+    mkdirSync9(priDir);
     materialize(cwd, priDir, frozenNodeModules);
     ({ restored, removed: removedAdded } = overlayPristine(
       cwd,
@@ -16479,6 +16851,25 @@ function runVerify(opts) {
     code2 = 1;
   }
   opts.onVerdict?.({ verdict: verdict2 });
+  if (verdict2 === "VERIFIED") {
+    try {
+      const inputs = {
+        base_ref: opts.base ?? "HEAD",
+        explicit_base: opts.base !== void 0,
+        command_source: opts.cmd !== void 0 ? "flag" : "policy",
+        command: cmd,
+        budget_source: opts.budget !== void 0 ? "flag" : "policy",
+        budget
+      };
+      recordVerification(cwd, inputs, treeBefore);
+    } catch {
+    }
+  } else {
+    try {
+      invalidateVerificationRecordIfCurrent(cwd);
+    } catch {
+    }
+  }
   const signedOff = verdict2 === "MASKED_FAILURE" ? oobToken("verify", oobFromEnv(), oobHeadFromEnv()) : null;
   if (signedOff) code2 = 0;
   if (opts.json) {
@@ -16584,6 +16975,7 @@ var init_verify = __esm({
     init_verifier_backend();
     init_machine_output();
     init_signoff();
+    init_verification_state();
     init_suite_diagnostics();
     init_text();
     init_status();
@@ -16680,11 +17072,11 @@ var init_verify = __esm({
 });
 
 // src/cli/run.ts
-import { execFileSync as execFileSync9, spawn, spawnSync as spawnSync4 } from "node:child_process";
+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 readFileSync17, readlinkSync as readlinkSync4, realpathSync as realpathSync8, rmSync as rmSync8, statSync as statSync5, writeFileSync as writeFileSync10 } from "node:fs";
+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 { tmpdir as tmpdir5 } from "node:os";
-import { dirname as dirname9, join as join20, resolve as resolve10 } from "node:path";
+import { dirname as dirname10, join as join21, resolve as resolve10 } from "node:path";
 function authoritativeRunLifecyclePlatform(platform = process.platform) {
   return platform === "linux";
 }
@@ -16721,7 +17113,7 @@ function writableByCaller2(path) {
       return true;
     } catch {
     }
-    const parent = dirname9(cur);
+    const parent = dirname10(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -16760,9 +17152,9 @@ function trustedLinuxPython(candidates = DEFAULT_TRUSTED_PYTHON_CANDIDATES) {
   };
 }
 function runAgentSupervised(argv, cwd, budgetSecs, linuxPythonCandidates, lifecycleTestMode, machineMode = false) {
-  const stateDir = mkdtempSync4(join20(tmpdir5(), "tw-agent-supervisor-"));
-  const resultFile = join20(stateDir, "result.json");
-  const agentEnvFile = join20(stateDir, "agent-env.json");
+  const stateDir2 = mkdtempSync4(join21(tmpdir5(), "tw-agent-supervisor-"));
+  const resultFile = join21(stateDir2, "result.json");
+  const agentEnvFile = join21(stateDir2, "agent-env.json");
   try {
     const linux = process.platform === "linux";
     let executable;
@@ -16779,7 +17171,7 @@ function runAgentSupervised(argv, cwd, budgetSecs, linuxPythonCandidates, lifecy
           failure: trustedPython.reason ?? "trusted Linux python3 interpreter is unavailable"
         };
       }
-      writeFileSync10(agentEnvFile, JSON.stringify(process.env), { mode: 384 });
+      writeFileSync11(agentEnvFile, JSON.stringify(process.env), { mode: 384 });
       executable = trustedPython.path;
       args = [
         "-I",
@@ -16836,7 +17228,7 @@ function runAgentSupervised(argv, cwd, budgetSecs, linuxPythonCandidates, lifecy
     }
     let state = {};
     try {
-      state = JSON.parse(readFileSync17(resultFile, "utf8"));
+      state = JSON.parse(readFileSync18(resultFile, "utf8"));
     } catch {
       return {
         exit: 1,
@@ -16861,13 +17253,13 @@ function runAgentSupervised(argv, cwd, budgetSecs, linuxPythonCandidates, lifecy
       ...state.failure ? { failure: state.failure } : {}
     };
   } finally {
-    rmSync8(stateDir, { recursive: true, force: true });
+    rmSync9(stateDir2, { recursive: true, force: true });
   }
 }
 function waitMs(ms) {
   Atomics.wait(waitCell, 0, 0, ms);
 }
-function pidAlive3(pid) {
+function pidAlive4(pid) {
   if (!pid || !Number.isInteger(pid) || pid <= 0) return false;
   try {
     process.kill(pid, 0);
@@ -16877,10 +17269,10 @@ function pidAlive3(pid) {
   }
 }
 function observerExited(pid) {
-  if (!pidAlive3(pid)) return true;
+  if (!pidAlive4(pid)) return true;
   if (process.platform !== "linux") return false;
   try {
-    const stat = readFileSync17(`/proc/${pid}/stat`, "utf8");
+    const stat = readFileSync18(`/proc/${pid}/stat`, "utf8");
     const state = stat.slice(stat.lastIndexOf(")") + 2).split(" ")[0];
     return state === "Z" || state === "X";
   } catch (e) {
@@ -16888,8 +17280,8 @@ function observerExited(pid) {
   }
 }
 function supervisedObserverLog(cwd) {
-  const gd = gitDir(cwd) ?? join20(cwd, ".git");
-  return join20(
+  const gd = gitDir(cwd) ?? join21(cwd, ".git");
+  return join21(
     gd,
     "tamperward",
     `run-observer-${process.pid}-${Date.now()}-${randomBytes3(4).toString("hex")}.jsonl`
@@ -16997,12 +17389,12 @@ function finishObserverAdvisory(observer, write = out) {
   const telemetry = stopObserverProcess(observer);
   observerSummary(observer, telemetry, write);
 }
-function git3(args, cwd) {
-  return execFileSync9("git", args, { cwd, encoding: "utf8", maxBuffer: 1 << 28, env: trustedGitEnv() });
+function git4(args, cwd) {
+  return execFileSync10("git", args, { cwd, encoding: "utf8", maxBuffer: 1 << 28, env: trustedGitEnv() });
 }
 function nowTicks() {
   try {
-    return Math.floor(parseFloat(readFileSync17("/proc/uptime", "utf8").split(" ")[0]) * 100);
+    return Math.floor(parseFloat(readFileSync18("/proc/uptime", "utf8").split(" ")[0]) * 100);
   } catch {
     return Number.POSITIVE_INFINITY;
   }
@@ -17025,7 +17417,7 @@ function survivorsHoldingTree(cwd, spawnedAfterTicks) {
     const n2 = Number(pid);
     if (n2 === process.pid) continue;
     try {
-      const stat = readFileSync17(`/proc/${pid}/stat`, "utf8");
+      const stat = readFileSync18(`/proc/${pid}/stat`, "utf8");
       const startTicks = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]);
       if (!Number.isFinite(startTicks) || startTicks < spawnedAfterTicks) continue;
     } catch {
@@ -17069,7 +17461,7 @@ function runEnvelope(opts) {
   let base;
   try {
     const requestedBase = assertRev(opts.base ?? "HEAD");
-    base = git3(["rev-parse", "--verify", `${requestedBase}^{commit}`], cwd).trim();
+    base = git4(["rev-parse", "--verify", `${requestedBase}^{commit}`], cwd).trim();
   } catch {
     err(`tamperward run: cannot resolve trusted base ${opts.base ?? "HEAD"} \u2014 failing closed.`);
     return 2;
@@ -17091,7 +17483,7 @@ function runEnvelope(opts) {
     return 2;
   }
   if (!opts.allowDirty) {
-    const dirty = git3(["status", "--porcelain"], cwd).trim();
+    const dirty = git4(["status", "--porcelain"], cwd).trim();
     if (dirty) {
       err("tamperward run: working tree is dirty before the agent starts \u2014 the envelope cannot");
       err("attribute changes. Commit or stash first, or pass --allow-dirty to own the risk.");
@@ -17196,7 +17588,7 @@ tamperward run \u2014 agent exit ${agentExit}; OBJECT_REWRITE \u2192 ENFORCEMENT
     emitRunJson("OBJECT_REWRITE", 1);
     return 1;
   }
-  const head = git3(["rev-parse", "HEAD"], cwd).trim();
+  const head = git4(["rev-parse", "HEAD"], cwd).trim();
   const isAncestor = spawnSync4("git", ["merge-base", "--is-ancestor", base, head], { cwd, env: trustedGitEnv() });
   if (isAncestor.status !== 0) {
     err(`tamperward run: HEAD ${head.slice(0, 10)} is not a descendant of the trusted base ${base.slice(0, 10)} \u2014`);
@@ -17597,9 +17989,9 @@ raise SystemExit(0)
 });
 
 // src/cli/doctor.ts
-import { execFileSync as execFileSync10 } from "node:child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync18, readdirSync as readdirSync5 } from "node:fs";
-import { join as join21, resolve as resolve11 } from "node:path";
+import { execFileSync as execFileSync11 } from "node:child_process";
+import { existsSync as existsSync15, readFileSync as readFileSync19, 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") {
     if (linuxPython?.path) {
@@ -17657,7 +18049,7 @@ function pinsInFile(path) {
   if (!existsSync15(path)) return [];
   let src = "";
   try {
-    src = readFileSync18(path, "utf8");
+    src = readFileSync19(path, "utf8");
   } catch {
     return [];
   }
@@ -17684,7 +18076,7 @@ function workflowPermissionCheck(cwd, workflowRels = [".github/workflows/tamperw
     }
     let doc;
     try {
-      doc = yaml.parse(readFileSync18(path, "utf8"));
+      doc = yaml.parse(readFileSync19(path, "utf8"));
     } catch (e) {
       broken.push(`${rel} is not valid YAML (${e instanceof Error ? e.message : String(e)})`);
       continue;
@@ -17797,9 +18189,9 @@ function collectLocalPosture(cwd, policy, authorityWorkflows, explicitWorkflow =
   addWiring("codeowners", "codeowners", true);
   checks.push(workflowPermissionCheck(cwd, authorityWorkflows));
   const pins = [
-    ...pinsInFile(join21(cwd, ".claude", "settings.json")),
-    ...pinsInFile(join21(cwd, ".git", "hooks", "pre-commit")),
-    ...pinsInFile(join21(cwd, ".husky", "pre-commit"))
+    ...pinsInFile(join22(cwd, ".claude", "settings.json")),
+    ...pinsInFile(join22(cwd, ".git", "hooks", "pre-commit")),
+    ...pinsInFile(join22(cwd, ".husky", "pre-commit"))
   ];
   const below = pins.filter((pin) => (compareVersions(pin, TW_VERSION) ?? 0) < 0);
   const above = pins.filter((pin) => (compareVersions(TW_VERSION, pin) ?? 0) < 0);
@@ -17917,7 +18309,7 @@ function evaluateGitHubProtection(snapshot2, requiredCheck = "tamperward", requi
 }
 function gitText(cwd, args) {
   try {
-    return execFileSync10("git", args, {
+    return execFileSync11("git", args, {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -17951,7 +18343,7 @@ function githubApi(cwd, endpoint) {
   const token = process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN ?? "";
   const invocation = githubApiInvocation(endpoint, token);
   try {
-    const stdout = execFileSync10(
+    const stdout = execFileSync11(
       invocation.executable,
       invocation.args,
       {
@@ -18095,7 +18487,7 @@ function diagnose(opts = {}) {
         `${workflowDirRel}: could not enumerate workflows (${e instanceof Error ? e.message : String(e)})`
       );
     }
-    for (const name of entries) workflowRels.push(join21(workflowDirRel, name));
+    for (const name of entries) workflowRels.push(join22(workflowDirRel, name));
   }
   const requiredSecs = requiredVerifierAuthoritySeconds(policy.verify.budget);
   const requiredMinutes = Math.ceil(requiredSecs / 60);
@@ -18108,7 +18500,7 @@ function diagnose(opts = {}) {
     }
     let doc;
     try {
-      doc = yaml.parse(readFileSync18(workflowPath, "utf8"));
+      doc = yaml.parse(readFileSync19(workflowPath, "utf8"));
     } catch (e) {
       return fail(
         "ci-verifier",
@@ -18282,19 +18674,153 @@ var init_doctor = __esm({
   }
 });
 
+// src/cli/status.ts
+function authorityFromChecks(checks) {
+  if (checks.some((c) => c.state === "BROKEN")) return "BROKEN";
+  if (checks.some((c) => c.state === "WARN")) return "PARTIAL";
+  return "ACTIVE";
+}
+function interventionFromCheck(check2) {
+  if (!check2) return { state: "UNKNOWN", detail: "agent hook wiring could not be evaluated" };
+  const map = {
+    OK: "ACTIVE",
+    WARN: "PARTIAL",
+    BROKEN: "INACTIVE"
+  };
+  return { state: map[check2.state], detail: check2.detail };
+}
+function buildStatusModel(cwd) {
+  let authority;
+  let intervention;
+  try {
+    const outcome = diagnose({ cwd });
+    authority = { state: authorityFromChecks(outcome.checks) };
+    const summary = outcome.checks.filter((c) => c.state !== "OK").map((c) => `${c.id}: ${c.state}`);
+    if (summary.length) authority.detail = summary.join("; ");
+    intervention = interventionFromCheck(outcome.checks.find((c) => c.id === "claude-hooks"));
+  } catch (e) {
+    const detail = e instanceof Error ? e.message : String(e);
+    authority = { state: "UNKNOWN", detail };
+    intervention = { state: "UNKNOWN", detail };
+  }
+  const verification = evaluateVerificationState(cwd);
+  const agent = intervention.state === "ACTIVE" || intervention.state === "PARTIAL" ? "claude-code" : "none";
+  return { authority, intervention, verification, runtime: { agent } };
+}
+function shortId(id) {
+  return id ? `${id.slice(0, 10)}...` : void 0;
+}
+function renderStatus(model, colour) {
+  const v = model.verification;
+  const lines = ["TamperWard", ""];
+  lines.push(statusLine(AUTHORITY_SEVERITY[model.authority.state], "Authority", model.authority.state, colour));
+  lines.push(statusLine(INTERVENTION_SEVERITY[model.intervention.state], "Intervention", model.intervention.state, colour));
+  lines.push(statusLine(VERIFICATION_SEVERITY[v.state], "Verification", v.state, colour));
+  const rows = [];
+  const record = v.record;
+  if (record) {
+    const verifiedTree = shortId(record.binding.tree);
+    if (verifiedTree) rows.push(["Verified tree", verifiedTree]);
+    const baseShort = shortId(v.base ?? record.binding.base);
+    if (baseShort) rows.push(["Base", `${record.inputs.base_ref}@${baseShort}`]);
+    if (v.verifier_command) rows.push(["Verifier", v.verifier_command]);
+  }
+  rows.push(["Runtime", model.runtime.agent]);
+  if (v.state === "STALE" && v.reason) rows.push(["Reason", v.reason]);
+  else if (v.state === "BROKEN") rows.push(["Reason", v.detail ?? v.reason ?? "authority wiring is invalid"]);
+  else if (v.state === "VERIFYING") rows.push(["Reason", v.reason ?? "a verification is in progress"]);
+  else if (v.state === "UNVERIFIED") rows.push(["Next", "run `tamperward verify` to establish a verified baseline"]);
+  if (rows.length) {
+    lines.push("");
+    const width = Math.max(...rows.map(([k]) => k.length));
+    for (const [k, val] of rows) lines.push(`${k.padEnd(width)}  ${val}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function statusDocument(model) {
+  const v = model.verification;
+  const verification = { state: v.state };
+  if (v.reason) verification.reason = v.reason;
+  if (v.changed_input) verification.changed_input = v.changed_input;
+  if (v.detail) verification.detail = v.detail;
+  if (v.verified_at) verification.verified_at = v.verified_at;
+  if (v.base) verification.base = v.base;
+  if (v.head) verification.head = v.head;
+  if (v.verifier_command) verification.verifier_command = v.verifier_command;
+  if (v.record) {
+    verification.tree = v.record.binding.tree;
+    verification.binding = { ...v.record.binding };
+  }
+  return machineOutput({
+    command: "status",
+    authority: model.authority,
+    intervention: model.intervention,
+    verification,
+    runtime: model.runtime
+  });
+}
+function runStatus(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  if (!repoContext(cwd)) {
+    const why = outsideRepository(cwd) ?? "cwd is not inside a repository the gate can read";
+    process.stderr.write(`tamperward: status needs a git repository (${why})
+`);
+    return 2;
+  }
+  const model = buildStatusModel(cwd);
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(statusDocument(model)) + "\n");
+  } else {
+    process.stdout.write(renderStatus(model, colourEnabled(process.env, process.stdout)));
+  }
+  return 0;
+}
+var AUTHORITY_SEVERITY, INTERVENTION_SEVERITY, VERIFICATION_SEVERITY;
+var init_status2 = __esm({
+  "src/cli/status.ts"() {
+    "use strict";
+    init_machine_output();
+    init_repo_context();
+    init_repo_context();
+    init_doctor();
+    init_verification_state();
+    init_text();
+    init_status();
+    AUTHORITY_SEVERITY = {
+      ACTIVE: "ok",
+      PARTIAL: "warn",
+      BROKEN: "bad",
+      UNKNOWN: "info"
+    };
+    INTERVENTION_SEVERITY = {
+      ACTIVE: "ok",
+      PARTIAL: "warn",
+      INACTIVE: "bad",
+      UNKNOWN: "info"
+    };
+    VERIFICATION_SEVERITY = {
+      CURRENT: "ok",
+      STALE: "warn",
+      VERIFYING: "info",
+      BROKEN: "bad",
+      UNVERIFIED: "info"
+    };
+  }
+});
+
 // src/cli/trace-verify.ts
-import { execFileSync as execFileSync11, spawnSync as spawnSync5 } from "node:child_process";
+import { execFileSync as execFileSync12, spawnSync as spawnSync5 } from "node:child_process";
 import {
   existsSync as existsSync16,
   mkdtempSync as mkdtempSync5,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync20,
   readdirSync as readdirSync6,
   realpathSync as realpathSync9,
-  rmSync as rmSync9,
+  rmSync as rmSync10,
   symlinkSync as symlinkSync2
 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
-import { isAbsolute as isAbsolute12, join as join22, relative as relative7, resolve as resolve12, sep as sep5 } from "node:path";
+import { isAbsolute as isAbsolute12, join as join23, relative as relative7, resolve as resolve12, sep as sep5 } from "node:path";
 function unescapeStraceString(s) {
   return s.replace(/\\([0-7]{1,3})/g, (_m, oct) => String.fromCharCode(parseInt(oct, 8))).replace(/\\x([0-9a-fA-F]{2})/g, (_m, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
 }
@@ -18506,8 +19032,8 @@ function summarizeTraceRuns(opts) {
     unresolved_accesses
   };
 }
-function git4(args, cwd) {
-  return execFileSync11("git", args, {
+function git5(args, cwd) {
+  return execFileSync12("git", args, {
     cwd,
     encoding: "utf8",
     maxBuffer: 256 * 1024 * 1024,
@@ -18520,7 +19046,7 @@ function commandExists(command) {
   return !r.error && r.status === 0;
 }
 function trackedAt(base, cwd) {
-  return git4(["ls-tree", "-r", "-z", "--name-only", base], cwd).split("\0").filter(Boolean);
+  return git5(["ls-tree", "-r", "-z", "--name-only", base], cwd).split("\0").filter(Boolean);
 }
 function materializeBase(base, cwd, dest) {
   const archive = spawnSync5("git", ["archive", "--format=tar", base], {
@@ -18542,8 +19068,8 @@ function materializeBase(base, cwd, dest) {
       `tar extraction failed${untar.stderr?.length ? `: ${String(untar.stderr).trim()}` : ""}`
     );
   }
-  const hostModules = join22(cwd, "node_modules");
-  const tracedModules = join22(dest, "node_modules");
+  const hostModules = join23(cwd, "node_modules");
+  const tracedModules = join23(dest, "node_modules");
   if (existsSync16(hostModules) && !existsSync16(tracedModules)) {
     symlinkSync2(resolve12(hostModules), tracedModules, "dir");
   }
@@ -18551,7 +19077,7 @@ function materializeBase(base, cwd, dest) {
 function traceFiles(prefix) {
   const dir = resolve12(prefix, "..");
   const base = prefix.split(sep5).at(-1) ?? prefix;
-  return readdirSync6(dir).filter((name) => name === base || name.startsWith(base + ".")).map((name) => join22(dir, name)).sort();
+  return readdirSync6(dir).filter((name) => name === base || name.startsWith(base + ".")).map((name) => join23(dir, name)).sort();
 }
 function rewriteTraceRoot(accesses, actualRoot) {
   return accesses.map((item) => {
@@ -18566,13 +19092,13 @@ function rewriteTraceRoot(accesses, actualRoot) {
       if (!inside3(actualRoot, real)) return { ...item, path: real };
     } catch {
     }
-    return { ...item, path: join22(TRACE_ROOT, ...rel.split("/")) };
+    return { ...item, path: join23(TRACE_ROOT, ...rel.split("/")) };
   });
 }
 function straceOnce(root, command, budget) {
-  const traceDir = mkdtempSync5(join22(tmpdir6(), "tw-trace-log-"));
+  const traceDir = mkdtempSync5(join23(tmpdir6(), "tw-trace-log-"));
   try {
-    const prefix = join22(traceDir, "trace");
+    const prefix = join23(traceDir, "trace");
     const traced = spawnSync5(
       "strace",
       [
@@ -18601,7 +19127,7 @@ function straceOnce(root, command, budget) {
       }
     );
     const logs = traced.error ? [] : traceFiles(prefix);
-    const accesses = logs.flatMap((path) => parseStraceFileAccess(readFileSync19(path, "utf8"), TRACE_ROOT));
+    const accesses = logs.flatMap((path) => parseStraceFileAccess(readFileSync20(path, "utf8"), TRACE_ROOT));
     const raw = {
       spawnError: traced.error ? traced.error.message : null,
       status: traced.status,
@@ -18612,26 +19138,26 @@ function straceOnce(root, command, budget) {
     };
     return { raw, accesses };
   } finally {
-    rmSync9(traceDir, { recursive: true, force: true });
+    rmSync10(traceDir, { recursive: true, force: true });
   }
 }
 function runOneTrace(cwd, base, command, budget) {
-  const root = mkdtempSync5(join22(tmpdir6(), "tw-trace-base-"));
+  const root = mkdtempSync5(join23(tmpdir6(), "tw-trace-base-"));
   try {
     materializeBase(base, cwd, root);
     const { raw, accesses } = straceOnce(root, command, budget);
     return { outcome: classifyTraceRun(raw), accesses: rewriteTraceRoot(accesses, root) };
   } finally {
-    rmSync9(root, { recursive: true, force: true });
+    rmSync10(root, { recursive: true, force: true });
   }
 }
 function tracerPreflight(budget = 10) {
-  const probeRoot = mkdtempSync5(join22(tmpdir6(), "tw-trace-probe-"));
+  const probeRoot = mkdtempSync5(join23(tmpdir6(), "tw-trace-probe-"));
   try {
     const { raw } = straceOnce(probeRoot, "true", Math.max(1, Math.min(budget, 10)));
     return classifyTraceRun(raw);
   } finally {
-    rmSync9(probeRoot, { recursive: true, force: true });
+    rmSync10(probeRoot, { recursive: true, force: true });
   }
 }
 function renderText2(report2) {
@@ -18696,7 +19222,7 @@ function runTraceVerify(opts = {}) {
   let base;
   try {
     const baseArg = assertRev(requestedBase);
-    base = git4(["rev-parse", "--verify", `${baseArg}^{commit}`], cwd).trim();
+    base = git5(["rev-parse", "--verify", `${baseArg}^{commit}`], cwd).trim();
   } catch (e) {
     process.stderr.write(`tamperward trace-verify: cannot resolve trusted base ${JSON.stringify(requestedBase)} (${e instanceof Error ? e.message : String(e)}).
 `);
@@ -18833,26 +19359,26 @@ var init_trace_verify = __esm({
 });
 
 // src/runtimes.ts
-import { existsSync as existsSync17, readFileSync as readFileSync20 } from "node:fs";
-import { join as join23 } from "node:path";
-function isRecord4(x) {
+import { existsSync as existsSync17, readFileSync as readFileSync21 } from "node:fs";
+import { join as join24 } from "node:path";
+function isRecord5(x) {
   return typeof x === "object" && x !== null && !Array.isArray(x);
 }
 function hooksBeyondTamperward(hooks) {
-  if (!isRecord4(hooks)) return hooks != null;
+  if (!isRecord5(hooks)) return hooks != null;
   for (const entries of Object.values(hooks)) {
     if (!Array.isArray(entries)) {
       if (entries != null) return true;
       continue;
     }
     for (const entry of entries) {
-      const hs = isRecord4(entry) ? entry.hooks : null;
+      const hs = isRecord5(entry) ? entry.hooks : null;
       if (!Array.isArray(hs)) {
         if (hs != null) return true;
         continue;
       }
       for (const h of hs) {
-        const cmd = isRecord4(h) ? String(h.command ?? "") : "";
+        const cmd = isRecord5(h) ? String(h.command ?? "") : "";
         if (!/tamperward/.test(cmd)) return true;
       }
     }
@@ -18860,11 +19386,11 @@ function hooksBeyondTamperward(hooks) {
   return false;
 }
 function claudeSettingsBeyondTamperward(cwd) {
-  const path = join23(cwd, ".claude", "settings.json");
+  const path = join24(cwd, ".claude", "settings.json");
   let raw;
   try {
     if (!existsSync17(path)) return false;
-    raw = readFileSync20(path, "utf8");
+    raw = readFileSync21(path, "utf8");
   } catch {
     return false;
   }
@@ -18874,7 +19400,7 @@ function claudeSettingsBeyondTamperward(cwd) {
   } catch {
     return raw.trim().length > 0;
   }
-  if (!isRecord4(parsed)) return raw.trim().length > 0;
+  if (!isRecord5(parsed)) return raw.trim().length > 0;
   for (const [key2, value] of Object.entries(parsed)) {
     if (key2 === "disableAllHooks") continue;
     if (key2 === "hooks") {
@@ -18890,7 +19416,7 @@ function detectRuntimes(cwd) {
   for (const rt of KNOWN_RUNTIMES) {
     const marker = rt.markers.find((m) => {
       try {
-        return existsSync17(join23(cwd, m));
+        return existsSync17(join24(cwd, m));
       } catch {
         return false;
       }
@@ -18970,10 +19496,10 @@ var init_runtimes = __esm({
 });
 
 // src/cli/onboard.ts
-import { execFileSync as execFileSync12 } from "node:child_process";
-import { lstatSync as lstatSync10, mkdtempSync as mkdtempSync6, readFileSync as readFileSync21, realpathSync as realpathSync10, rmSync as rmSync10 } from "node:fs";
+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 { tmpdir as tmpdir7 } from "node:os";
-import { join as join24, relative as relative8, resolve as resolve13, sep as sep6 } from "node:path";
+import { join as join25, relative as relative8, resolve as resolve13, sep as sep6 } from "node:path";
 import { createInterface } from "node:readline";
 import { parseDocument } from "yaml";
 function readlineAsker(input, output) {
@@ -19017,9 +19543,9 @@ function platformLabel(platform) {
   if (platform === "linux") return "Linux";
   return platform;
 }
-function git5(cwd, args) {
+function git6(cwd, args) {
   try {
-    return execFileSync12("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return execFileSync13("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
   } catch {
     return null;
   }
@@ -19038,13 +19564,13 @@ function explainVerdict(v, code2) {
   }
 }
 function writeVerifyCommand(cwd, command) {
-  const path = join24(cwd, POLICY_FILE);
+  const path = join25(cwd, POLICY_FILE);
   const kind = writeTargetKind(path);
   if (kind === "symlink" || kind === "irregular") {
     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" ? readFileSync21(path, "utf8") : null;
+  const original = kind === "file" ? readFileSync22(path, "utf8") : null;
   let next;
   try {
     const doc = parseDocument(original && original.trim() ? original : "version: 1\n");
@@ -19061,7 +19587,7 @@ function writeVerifyCommand(cwd, command) {
     if (loaded2.verify?.command !== command) throw new Error("verify.command did not round-trip");
     return null;
   } catch (e) {
-    if (original === null) rmSync10(path, { force: true });
+    if (original === null) rmSync11(path, { force: true });
     else atomicReplaceFile(path, original, mode);
     return `the updated ${POLICY_FILE} does not load (${errorMessage(e)}); restored the previous file`;
   }
@@ -19096,7 +19622,7 @@ async function runOnboard(opts, io = {}) {
     rawErr("or run `tamperward init` for the deterministic wiring step only.");
     return 2;
   }
-  const rootText = git5(requestedCwd, ["rev-parse", "--show-toplevel"])?.trim() ?? "";
+  const rootText = git6(requestedCwd, ["rev-parse", "--show-toplevel"])?.trim() ?? "";
   if (!rootText) {
     fail(requestedCwd + " is not inside a Git repository. Run `git init` first.");
     return 2;
@@ -19162,8 +19688,8 @@ async function runOnboard(opts, io = {}) {
     } else {
       status("LIMITED", platformLabel(platform) + ": check works here; local verify and `run` are unavailable. Use the container verifier for final verification.", "warn");
     }
-    const head = git5(cwd, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"])?.trim() ?? null;
-    const treeStatus = git5(cwd, ["status", "--porcelain", "--untracked-files=all"]) ?? "";
+    const head = git6(cwd, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"])?.trim() ?? null;
+    const treeStatus = git6(cwd, ["status", "--porcelain", "--untracked-files=all"]) ?? "";
     const dirty = treeStatus.split("\n").filter(Boolean).map((line2) => line2.slice(3).split(" -> ").at(-1) ?? "");
     if (!head) {
       const count = dirty.length;
@@ -19411,7 +19937,7 @@ function postureOf(outcome) {
   return "READY";
 }
 function runDemo(cwd, head, runners, out3) {
-  const files = (git5(cwd, ["ls-tree", "-r", "-z", head]) ?? "").split("\0").filter(Boolean).flatMap((row) => {
+  const files = (git6(cwd, ["ls-tree", "-r", "-z", head]) ?? "").split("\0").filter(Boolean).flatMap((row) => {
     const tab = row.indexOf("	");
     if (tab < 0) return [];
     const mode = row.slice(0, tab).split(" ")[0];
@@ -19420,7 +19946,7 @@ function runDemo(cwd, head, runners, out3) {
   });
   let target = null;
   for (const path of files) {
-    const before2 = git5(cwd, ["show", `${head}:${path}`]);
+    const before2 = git6(cwd, ["show", `${head}:${path}`]);
     if (before2 === null || !JS_TEST_BLOCK.test(before2)) continue;
     target = { path, before: before2, after: before2.replace(JS_TEST_BLOCK, "$1$2.skip$3") };
     break;
@@ -19431,13 +19957,13 @@ function runDemo(cwd, head, runners, out3) {
   }
   const before = treeFingerprint(cwd);
   out3(`working tree fingerprint before: ${before.slice(0, 16)}`);
-  const wt = mkdtempSync6(join24(tmpdir7(), "tw-onboard-demo-"));
+  const wt = mkdtempSync6(join25(tmpdir7(), "tw-onboard-demo-"));
   try {
-    if (git5(cwd, ["worktree", "add", "--detach", wt, head]) === null) {
+    if (git6(cwd, ["worktree", "add", "--detach", wt, head]) === null) {
       out3("Demo skipped: could not create a temporary worktree (git worktree add failed).");
       return;
     }
-    const targetPath = join24(wt, target.path);
+    const targetPath = join25(wt, target.path);
     const targetStat = lstatSync10(targetPath, { throwIfNoEntry: false });
     if (!targetStat || !targetStat.isFile() || targetStat.isSymbolicLink()) {
       out3("Demo skipped: the selected test is not a regular file in the disposable worktree.");
@@ -19466,9 +19992,9 @@ function runDemo(cwd, head, runners, out3) {
     out3("");
     out3(`check exited ${code2}: ${code2 === 1 ? "a blocking finding, which is what the hook, pre-commit and CI would all report" : "no blocking finding was reported"}.`);
   } finally {
-    git5(cwd, ["worktree", "remove", "--force", wt]);
-    git5(cwd, ["worktree", "prune"]);
-    rmSync10(wt, { recursive: true, force: true });
+    git6(cwd, ["worktree", "remove", "--force", wt]);
+    git6(cwd, ["worktree", "prune"]);
+    rmSync11(wt, { recursive: true, force: true });
   }
   const after = treeFingerprint(cwd);
   out3(`working tree fingerprint after:  ${after.slice(0, 16)}`);
@@ -19655,9 +20181,9 @@ var init_capture = __esm({
 });
 
 // src/research/manifest.ts
-import { createHash as createHash13 } from "node:crypto";
-import { readFileSync as readFileSync22 } from "node:fs";
-import { dirname as dirname10, resolve as resolve15 } from "node:path";
+import { createHash as createHash14 } from "node:crypto";
+import { readFileSync as readFileSync23 } from "node:fs";
+import { dirname as dirname11, resolve as resolve15 } from "node:path";
 function taskFrom(raw, index, manifestDir) {
   const where = `task #${index + 1}`;
   if (!isRecord(raw)) throw new ResearchError(`task manifest: ${where} is not an object`);
@@ -19690,7 +20216,7 @@ function readManifest(path) {
   const abs = resolve15(path);
   let bytes;
   try {
-    bytes = readFileSync22(abs);
+    bytes = readFileSync23(abs);
   } catch (e) {
     throw new ResearchError(`cannot read task manifest ${abs}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -19707,13 +20233,13 @@ function readManifest(path) {
   if (!Array.isArray(raw.tasks) || raw.tasks.length === 0) {
     throw new ResearchError(`task manifest ${abs}: no tasks (tasks must be a non-empty array)`);
   }
-  const tasks = raw.tasks.map((t, i) => taskFrom(t, i, dirname10(abs)));
+  const tasks = raw.tasks.map((t, i) => taskFrom(t, i, dirname11(abs)));
   const seen = /* @__PURE__ */ new Set();
   for (const t of tasks) {
     if (seen.has(t.id)) throw new ResearchError(`task manifest ${abs}: duplicate task id "${t.id}"`);
     seen.add(t.id);
   }
-  return { path: abs, sha256: createHash13("sha256").update(bytes).digest("hex"), tasks };
+  return { path: abs, sha256: createHash14("sha256").update(bytes).digest("hex"), tasks };
 }
 var MANIFEST_VERSION;
 var init_manifest = __esm({
@@ -19987,22 +20513,22 @@ var init_record = __esm({
 
 // src/research/run.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { execFileSync as execFileSync13 } from "node:child_process";
-import { closeSync as closeSync3, existsSync as existsSync18, linkSync, mkdirSync as mkdirSync9, openSync as openSync3, readFileSync as readFileSync23, renameSync as renameSync4, rmSync as rmSync11, unlinkSync, writeFileSync as writeFileSync11, writeSync } from "node:fs";
+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 { hostname } from "node:os";
-import { join as join25, resolve as resolve16 } from "node:path";
-function git6(args, cwd) {
-  return execFileSync13("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+import { join as join26, resolve as resolve16 } from "node:path";
+function git7(args, cwd) {
+  return execFileSync14("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
 }
 function pairRecordPath(ledger, task, pair) {
-  return join25(ledger, "pairs", `${task}--${pair}.json`);
+  return join26(ledger, "pairs", `${task}--${pair}.json`);
 }
 function researchLockPath(ledger) {
-  return join25(ledger, "run.lock");
+  return join26(ledger, "run.lock");
 }
 function readLockOwner(path) {
   try {
-    const parsed = JSON.parse(readFileSync23(path, "utf8"));
+    const parsed = JSON.parse(readFileSync24(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 };
@@ -20023,7 +20549,7 @@ function lockHolder(path) {
   return owner ? `pid ${owner.pid} on ${owner.host}, started ${owner.started_at}` : "an unreadable lock file";
 }
 function acquireResearchLock(ledger, breakStaleLock = false) {
-  mkdirSync9(ledger, { recursive: true });
+  mkdirSync10(ledger, { recursive: true });
   const path = researchLockPath(ledger);
   if (breakStaleLock && existsSync18(path)) {
     const owner2 = readLockOwner(path);
@@ -20087,7 +20613,7 @@ function acquireResearchLock(ledger, breakStaleLock = false) {
       if (released) return;
       released = true;
       try {
-        if (readFileSync23(path, "utf8") === text) unlinkSync(path);
+        if (readFileSync24(path, "utf8") === text) unlinkSync(path);
       } catch {
       }
     }
@@ -20096,7 +20622,7 @@ function acquireResearchLock(ledger, breakStaleLock = false) {
 function resumableRecord(path, expected) {
   let raw;
   try {
-    raw = JSON.parse(readFileSync23(path, "utf8"));
+    raw = JSON.parse(readFileSync24(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`);
   }
@@ -20133,28 +20659,28 @@ function resumableRecord(path, expected) {
 }
 function writeRecordAtomically(path, text) {
   const tmp = `${path}.${process.pid}.tmp`;
-  writeFileSync11(tmp, text);
+  writeFileSync12(tmp, text);
   renameSync4(tmp, path);
 }
 function cloneArgs(repo, ws3) {
   return ["-c", "protocol.ext.allow=never", "clone", "-q", "--no-hardlinks", "--", repo, ws3];
 }
 function freshWorkspace(ledger, task, pair, arm, sourceBase) {
-  const ws3 = join25(ledger, "workspaces", `${task.id}--${pair}--${arm}`);
-  rmSync11(ws3, { recursive: true, force: true });
-  mkdirSync9(join25(ledger, "workspaces"), { recursive: true });
+  const ws3 = join26(ledger, "workspaces", `${task.id}--${pair}--${arm}`);
+  rmSync12(ws3, { recursive: true, force: true });
+  mkdirSync10(join26(ledger, "workspaces"), { recursive: true });
   try {
-    execFileSync13("git", cloneArgs(task.repo, ws3), { stdio: ["ignore", "ignore", "pipe"], encoding: "utf8" });
+    execFileSync14("git", cloneArgs(task.repo, ws3), { stdio: ["ignore", "ignore", "pipe"], encoding: "utf8" });
   } catch (e) {
     throw new ResearchError(`task "${task.id}": cannot clone ${task.repo}: ${errorMessage(e).split("\n")[0]}`);
   }
-  git6(["config", "user.name", "tamperward-research"], ws3);
-  git6(["config", "user.email", "research@tamperward.invalid"], ws3);
+  git7(["config", "user.name", "tamperward-research"], ws3);
+  git7(["config", "user.email", "research@tamperward.invalid"], ws3);
   const requestedBase = sourceBase ?? task.base;
   const candidates = sourceBase !== void 0 ? [sourceBase] : task.base === "HEAD" ? ["HEAD"] : [task.base, `origin/${task.base}`];
   for (const rev2 of candidates) {
     try {
-      git6(["checkout", "-q", "--detach", rev2], ws3);
+      git7(["checkout", "-q", "--detach", rev2], ws3);
       return ws3;
     } catch {
     }
@@ -20308,15 +20834,15 @@ function observeOutcome(ws3, base, head, task, trusted) {
 }
 function runTrajectory(ledger, task, pair, arm, adapter, opts, sourceBase) {
   const ws3 = freshWorkspace(ledger, task, pair, arm, sourceBase);
-  const prep = { id: task.id, prompt: task.prompt, cwd: ws3, base: git6(["rev-parse", "HEAD"], ws3), arm, model: opts.model };
+  const prep = { id: task.id, prompt: task.prompt, cwd: ws3, base: git7(["rev-parse", "HEAD"], ws3), arm, model: opts.model };
   if (arm === "gated" && adapter.prepareGated) {
     captureStdout(() => adapter.prepareGated?.(prep));
-    if (git6(["status", "--porcelain"], ws3)) {
-      git6(["add", "-A"], ws3);
-      git6(["commit", "-qm", "tamperward research: wire enforcement (gated arm)"], ws3);
+    if (git7(["status", "--porcelain"], ws3)) {
+      git7(["add", "-A"], ws3);
+      git7(["commit", "-qm", "tamperward research: wire enforcement (gated arm)"], ws3);
     }
   }
-  const base = git6(["rev-parse", "HEAD"], ws3);
+  const base = git7(["rev-parse", "HEAD"], ws3);
   const launch2 = adapter.launch({ ...prep, base });
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   let agent;
@@ -20329,7 +20855,7 @@ function runTrajectory(ledger, task, pair, arm, adapter, opts, sourceBase) {
     agent = runUngated(ws3, launch2.argv, launch2.env, opts.agentBudget);
   }
   const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const head = git6(["rev-parse", "HEAD"], ws3);
+  const head = git7(["rev-parse", "HEAD"], ws3);
   const trustedSurface = trustedProtectedOnly(base, ws3);
   const fingerprintBefore = treeFingerprint(ws3, trustedSurface.protectedOnly);
   const observed = observeOutcome(ws3, base, head, task, trustedSurface.trusted);
@@ -20391,7 +20917,7 @@ function runResearch(opts) {
   }
   try {
     const pairs = opts.pairs ?? 1;
-    mkdirSync9(join25(ledger, "pairs"), { recursive: true });
+    mkdirSync10(join26(ledger, "pairs"), { recursive: true });
     for (const task of tasks) {
       const existingRecords = /* @__PURE__ */ new Map();
       let sourceBase = null;
@@ -20518,10 +21044,10 @@ var init_run2 = __esm({
 });
 
 // src/research/summarize.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync24 } from "node:fs";
-import { join as join26, resolve as resolve17 } from "node:path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync25 } from "node:fs";
+import { join as join27, resolve as resolve17 } from "node:path";
 function readLedger2(dir) {
-  const pairsDir = join26(resolve17(dir), "pairs");
+  const pairsDir = join27(resolve17(dir), "pairs");
   let names;
   try {
     names = readdirSync7(pairsDir).filter((n2) => n2.endsWith(".json")).sort();
@@ -20530,10 +21056,10 @@ function readLedger2(dir) {
   }
   if (names.length === 0) throw new ResearchError(`ledger ${pairsDir} holds no pair records`);
   return names.map((n2) => {
-    const path = join26(pairsDir, n2);
+    const path = join27(pairsDir, n2);
     let raw;
     try {
-      raw = JSON.parse(readFileSync24(path, "utf8"));
+      raw = JSON.parse(readFileSync25(path, "utf8"));
     } catch (e) {
       throw new ResearchError(`ledger record ${path} is not valid JSON: ${errorMessage(e)}`);
     }
@@ -20664,9 +21190,9 @@ var init_summarize = __esm({
 });
 
 // src/research/init.ts
-import { createHash as createHash14 } from "node:crypto";
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync25, writeFileSync as writeFileSync12 } from "node:fs";
-import { basename as basename5, dirname as dirname11, resolve as resolve18 } from "node:path";
+import { createHash as createHash15 } from "node:crypto";
+import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync26, 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";
   return (basename5(clean, ".git").replace(/[^A-Za-z0-9._-]+/g, "-") || "task").slice(0, 80);
@@ -20694,8 +21220,8 @@ function createResearchManifest(opts) {
     }]
   };
   const text = JSON.stringify(doc, null, 2) + "\n";
-  mkdirSync10(dirname11(out3), { recursive: true });
-  writeFileSync12(out3, text, { flag: "wx", mode: 384 });
+  mkdirSync11(dirname12(out3), { recursive: true });
+  writeFileSync13(out3, text, { flag: "wx", mode: 384 });
   const parsed = readManifest(out3);
   if (parsed.tasks.length !== 1 || parsed.tasks[0].id !== id) throw new ResearchError(`research init wrote an invalid manifest ${out3}`);
   return out3;
@@ -20717,7 +21243,7 @@ function runResearchInit(opts) {
   }
 }
 function requireHash(path) {
-  return createHash14("sha256").update(readFileSync25(path)).digest("hex");
+  return createHash15("sha256").update(readFileSync26(path)).digest("hex");
 }
 var init_init2 = __esm({
   "src/research/init.ts"() {
@@ -20782,10 +21308,10 @@ var init_report2 = __esm({
 });
 
 // src/research/bundle.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import { gzipSync, gunzipSync } from "node:zlib";
-import { existsSync as existsSync20, mkdirSync as mkdirSync11, readdirSync as readdirSync8, readFileSync as readFileSync26, statSync as statSync6, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname12, join as join27, resolve as resolve19 } from "node:path";
+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";
 function octal(value, width) {
   return value.toString(8).padStart(width - 1, "0") + "\0";
 }
@@ -20831,14 +21357,14 @@ function parseTar(bytes) {
 }
 function walkLedger(ledger) {
   const entries = [];
-  const pairs = join27(ledger, "pairs");
+  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 = join27(pairs, name);
+    const path = join28(pairs, name);
     if (!statSync6(path).isFile()) continue;
-    entries.push({ name: `ledger/pairs/${name}`, bytes: readFileSync26(path) });
+    entries.push({ name: `ledger/pairs/${name}`, bytes: readFileSync27(path) });
   }
   return entries;
 }
@@ -20848,7 +21374,7 @@ function jsonBytes(value) {
 function validateResearchBundle(path) {
   let files;
   try {
-    files = parseTar(gunzipSync(readFileSync26(resolve19(path))));
+    files = parseTar(gunzipSync(readFileSync27(resolve19(path))));
   } catch (e) {
     throw new ResearchError(`cannot read research bundle ${path}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -20871,7 +21397,7 @@ function validateResearchBundle(path) {
   if (p.manifest_included !== Boolean(manifest) || p.prompts_included !== Boolean(manifest)) {
     throw new ResearchError("research bundle manifest inclusion metadata is inconsistent");
   }
-  if (manifest && createHash15("sha256").update(manifest).digest("hex") !== p.manifest_sha256) {
+  if (manifest && createHash16("sha256").update(manifest).digest("hex") !== p.manifest_sha256) {
     throw new ResearchError("research bundle manifest does not match its recorded sha256");
   }
   const parsedSummary = summary;
@@ -20902,8 +21428,8 @@ function createResearchBundle(opts) {
   const summary = summarizeLedger(ledger);
   const entries = walkLedger(ledger);
   if (opts.manifest) {
-    const manifest = readFileSync26(resolve19(opts.manifest));
-    const sha3 = createHash15("sha256").update(manifest).digest("hex");
+    const manifest = readFileSync27(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 });
   }
@@ -20925,8 +21451,8 @@ function createResearchBundle(opts) {
   entries.push({ name: "report.txt", bytes: Buffer.from(renderResearchReport(summary), "utf8") });
   entries.push({ name: "provenance.json", bytes: jsonBytes(provenance) });
   const out3 = resolve19(opts.out);
-  mkdirSync11(dirname12(out3), { recursive: true });
-  writeFileSync13(out3, gzipSync(makeTar(entries)), { flag: "wx", mode: 384 });
+  mkdirSync12(dirname13(out3), { recursive: true });
+  writeFileSync14(out3, gzipSync(makeTar(entries)), { flag: "wx", mode: 384 });
   return out3;
 }
 function runResearchBundle(opts) {
@@ -21145,6 +21671,15 @@ function parseDoctor(args) {
   }
   return o;
 }
+function parseStatus(args) {
+  const o = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--json") o.json = true;
+    else if (a === "--cwd") o.cwd = args[++i];
+  }
+  return o;
+}
 function parseStats(args) {
   const o = {};
   for (let i = 0; i < args.length; i++) {
@@ -21353,6 +21888,12 @@ function validateCliArgs(cmd, args) {
       }
     }).error;
   }
+  if (cmd === "status") {
+    return validateFlatArgs(args, {
+      flags: ["--json"],
+      values: { "--cwd": "string" }
+    }).error;
+  }
   if (cmd === "onboard") {
     const parsed = validateFlatArgs(args, {
       flags: ["--yes", "--skip-demo", "--demo", "--no-github"],
@@ -21598,6 +22139,16 @@ Formats:
                                             every tool the gate must see.
                                             --force-workflow replaces a workflow it
                                             did not write, or one you have edited.
+  tamperward status [--json] [--cwd D]      verification posture in three distinct
+                                            lanes \u2014 Authority (repository/final
+                                            adjudication), Intervention (runtime
+                                            steering), and Verification: whether the
+                                            last successful verify still applies to
+                                            the EXACT current state (CURRENT / STALE /
+                                            VERIFYING / BROKEN / UNVERIFIED). --json
+                                            emits the versioned status document for
+                                            editors, CI and dashboards. Local CURRENT
+                                            is posture, never repository/CI authority.
   tamperward doctor [--base R]              report installation + authority posture
              [--workflow F] [--cwd D]       and validate the CI verifier's outer-time
              [--json]                       envelope against the trusted policy.
@@ -21650,6 +22201,8 @@ function main(argv) {
       return runDoctor(parseDoctor(rest));
     case "stats":
       return runStats(parseStats(rest));
+    case "status":
+      return runStatus(parseStatus(rest));
     case "onboard":
       return runOnboard(parseOnboard(rest));
     case "watch":
@@ -21705,6 +22258,7 @@ var init_main = __esm({
     init_allow();
     init_init();
     init_doctor();
+    init_status2();
     init_verify();
     init_trace_verify();
     init_run();
@@ -21719,7 +22273,7 @@ var init_main = __esm({
 // src/cli/index.ts
 init_hook_client();
 init_exit();
-import { readFileSync as readFileSync27 } from "node:fs";
+import { readFileSync as readFileSync28 } from "node:fs";
 function loadMain() {
   return Promise.resolve().then(() => (init_main(), main_exports));
 }
@@ -21732,7 +22286,7 @@ async function launch(argv) {
   if (kind && hookServiceEnabled()) {
     let raw = null;
     try {
-      raw = readFileSync27(0, "utf8");
+      raw = readFileSync28(0, "utf8");
     } catch {
       raw = null;
     }