tamperward 2.23.4 → 2.23.6

package/dist/cli/index.js

@@ -206,7 +206,7 @@ function forwardedEnv(env) {
   return out3;
 }
 function exchange(paths, req2, timeoutMs) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     let done = false;
     let handedOff = false;
     let accepted = false;
@@ -217,7 +217,7 @@ function exchange(paths, req2, timeoutMs) {
       done = true;
       clearTimeout(timer);
       sock.destroy();
-      resolve15(value);
+      resolve16(value);
     };
     const sock = createConnection(paths.socket);
     const timer = setTimeout(() => finish(handedOff ? acceptedFailure("timeout") : null), timeoutMs);
@@ -603,12 +603,12 @@ function irregularName(st) {
 function meta(st) {
   return { mode: st.mode, size: st.size, mtimeMs: st.mtimeMs };
 }
-function readRegular(abs2, st) {
+function readRegular(abs, st) {
   let fd;
   try {
-    fd = openSync(abs2, O_READ);
+    fd = openSync(abs, O_READ);
   } catch (e) {
-    if (errCode(e) === "ELOOP") return inspectOnce(abs2);
+    if (errCode(e) === "ELOOP") return inspectOnce(abs);
     return { kind: "unreadable", content: null, ...meta(st), detail: errText(e) };
   }
   try {
@@ -629,10 +629,10 @@ function readRegular(abs2, st) {
     closeSync(fd);
   }
 }
-function classify(abs2, st) {
+function classify(abs, st) {
   if (st.isSymbolicLink()) {
     try {
-      const target = readlinkSync(abs2);
+      const target = readlinkSync(abs);
       return { kind: "symlink", content: Buffer.from(target, "utf8"), ...meta(st), detail: target };
     } catch (e) {
       return { kind: "unreadable", content: null, ...meta(st), detail: errText(e) };
@@ -641,38 +641,38 @@ function classify(abs2, st) {
   if (st.isDirectory()) return { kind: "directory", content: null, ...meta(st), detail: "directory" };
   if (!st.isFile()) return { kind: "irregular", content: null, ...meta(st), detail: irregularName(st) };
   if (st.size > READ_CAP) return { kind: "oversize", content: null, ...meta(st), detail: `${st.size} bytes` };
-  return readRegular(abs2, st);
+  return readRegular(abs, st);
 }
-function inspectOnce(abs2) {
+function inspectOnce(abs) {
   let st;
   try {
-    st = lstatSync2(abs2);
+    st = lstatSync2(abs);
   } catch (e) {
     const code2 = errCode(e);
     if (code2 === "ENOENT" || code2 === "ENOTDIR") return { kind: "absent", content: null, ...NO_META, detail: "" };
     return { kind: "unreadable", content: null, ...NO_META, detail: errText(e) };
   }
-  if (st.isSymbolicLink() || !st.isFile()) return classify(abs2, st);
+  if (st.isSymbolicLink() || !st.isFile()) return classify(abs, st);
   return { kind: "unreadable", content: null, ...meta(st), detail: "the path changed shape while it was being read" };
 }
-function inspectPath(abs2) {
+function inspectPath(abs) {
   let st;
   try {
-    st = lstatSync2(abs2);
+    st = lstatSync2(abs);
   } catch (e) {
     const code2 = errCode(e);
     if (code2 === "ENOENT" || code2 === "ENOTDIR") return { kind: "absent", content: null, ...NO_META, detail: "" };
     return { kind: "unreadable", content: null, ...NO_META, detail: errText(e) };
   }
-  return classify(abs2, st);
+  return classify(abs, st);
 }
 function inspectRel(cwd, rel) {
   return inspectPath(join3(cwd, rel));
 }
-function inspectResolved(abs2) {
+function inspectResolved(abs) {
   let real;
   try {
-    real = realpathSync2(abs2);
+    real = realpathSync2(abs);
   } catch (e) {
     const code2 = errCode(e);
     if (code2 === "ENOENT" || code2 === "ENOTDIR") return { kind: "absent", content: null, ...NO_META, detail: "" };
@@ -1021,11 +1021,55 @@ var init_trusted = __esm({
   }
 });
 
-// src/git/build.ts
+// src/repo-context.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { isAbsolute as isAbsolute3, resolve } from "node:path";
+function rev(cwd, flag) {
+  try {
+    const out3 = execFileSync2("git", ["rev-parse", flag], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    return out3 ? isAbsolute3(out3) ? out3 : resolve(cwd, out3) : null;
+  } catch {
+    return null;
+  }
+}
+function repoContext(cwd) {
+  const key2 = resolve(cwd);
+  const hit = cache.get(key2);
+  if (hit && existsSync2(hit.gitDir) && existsSync2(hit.root)) return hit;
+  cache.delete(key2);
+  const root = rev(key2, "--show-toplevel");
+  const gitDir3 = root ? rev(key2, "--absolute-git-dir") : null;
+  if (!root || !gitDir3) return null;
+  const ctx = { root, gitDir: gitDir3 };
+  if (cache.size >= CACHE_MAX) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  cache.set(key2, ctx);
+  return ctx;
+}
+function repoRoot(cwd) {
+  return repoContext(cwd)?.root ?? cwd;
+}
+var cache, CACHE_MAX;
+var init_repo_context = __esm({
+  "src/repo-context.ts"() {
+    "use strict";
+    cache = /* @__PURE__ */ new Map();
+    CACHE_MAX = 256;
+  }
+});
+
+// src/git/build.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
 function git(args, cwd) {
   try {
-    return execFileSync2("git", args, {
+    return execFileSync3("git", args, {
       cwd,
       encoding: "utf8",
       // 256 MiB, matching the hook adapter. Every diff below runs with `--text`, so a
@@ -1047,15 +1091,15 @@ function git(args, cwd) {
     throw new Error(detail ? `git ${args[0]}: ${detail}` : failure.message || `git ${args[0]} failed`);
   }
 }
-function blobAt(rev, path, cwd) {
+function blobAt(rev2, path, cwd) {
   try {
-    return git(["show", `${rev}:${path}`], cwd);
+    return git(["show", `${rev2}:${path}`], cwd);
   } catch {
     return null;
   }
 }
 function fromDisk(path, cwd) {
-  return textOf2(inspectRel(cwd ?? process.cwd(), path));
+  return textOf2(inspectRel(repoRoot(cwd ?? process.cwd()), path));
 }
 function enrich(c, beforeReader, afterReader) {
   if (c.kind !== "file") return c;
@@ -1063,9 +1107,9 @@ function enrich(c, beforeReader, afterReader) {
   const after = c.op !== "delete" ? afterReader(c.path) : null;
   return { ...c, before, after };
 }
-function assertRev(rev) {
-  if (rev.startsWith("-")) throw new Error(`refusing a revision that git would read as an option: ${rev}`);
-  return rev;
+function assertRev(rev2) {
+  if (rev2.startsWith("-")) throw new Error(`refusing a revision that git would read as an option: ${rev2}`);
+  return rev2;
 }
 function mergeBaseOf(base, head, opts = {}) {
   try {
@@ -1074,8 +1118,8 @@ function mergeBaseOf(base, head, opts = {}) {
     return base;
   }
 }
-function fileAt(rev, path, opts = {}) {
-  return blobAt(rev, path, opts.cwd);
+function fileAt(rev2, path, opts = {}) {
+  return blobAt(rev2, path, opts.cwd);
 }
 function fileOnDisk(path, opts = {}) {
   return fromDisk(path, opts.cwd);
@@ -1102,10 +1146,10 @@ function headSha(cwd) {
     return null;
   }
 }
-function diffSince(rev, opts = {}) {
-  const raw = git([...DIFF_ARGS, rev], opts.cwd);
+function diffSince(rev2, opts = {}) {
+  const raw = git([...DIFF_ARGS, rev2], opts.cwd);
   return parseDiff(raw).map(
-    (c) => enrich(c, (p) => blobAt(rev, p, opts.cwd), (p) => fromDisk(p, opts.cwd))
+    (c) => enrich(c, (p) => blobAt(rev2, p, opts.cwd), (p) => fromDisk(p, opts.cwd))
   );
 }
 function diffRange(base, head, opts = {}) {
@@ -1195,6 +1239,7 @@ var init_build = __esm({
     init_synth();
     init_trusted();
     init_narrow();
+    init_repo_context();
     DIFF_ARGS = ["diff", "--no-color", "--text", "-M"];
     SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".hg", ".svn"]);
     IGNORED_LS = ["ls-files", "--others", "--ignored", "--exclude-standard", "-z"];
@@ -1202,22 +1247,19 @@ var init_build = __esm({
 });
 
 // src/adapters/claude/changes.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import { writeFileSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { isAbsolute as isAbsolute3, join as join5, relative, resolve } from "node:path";
+import { isAbsolute as isAbsolute4, join as join5, relative, resolve as resolve2 } from "node:path";
 function asStr(v) {
   return typeof v === "string" ? v : "";
 }
 function readDisk(path) {
   return textOf2(inspectResolved(path));
 }
-function abs(path, cwd) {
-  return resolve(cwd, path);
-}
 function relForDisplay(path, cwd) {
   const rel = relative(cwd, path);
-  return rel && !rel.startsWith("..") && !isAbsolute3(rel) ? rel : path;
+  return rel && !rel.startsWith("..") && !isAbsolute4(rel) ? rel : path;
 }
 function applyEdit(content, oldStr, newStr) {
   if (content === null) return newStr;
@@ -1238,7 +1280,7 @@ function synthFileChange(displayPath, before, after) {
     writeFileSync(a, before ?? "");
     writeFileSync(b, after ?? "");
     try {
-      raw = execFileSync3("git", ["diff", "--no-index", "--no-color", "--text", a, b], {
+      raw = execFileSync4("git", ["diff", "--no-index", "--no-color", "--text", a, b], {
         encoding: "utf8",
         maxBuffer: 256 * 1024 * 1024
       });
@@ -1256,8 +1298,9 @@ function synthFileChange(displayPath, before, after) {
   const hunks = first && first.kind === "file" ? first.hunks : [];
   return [{ kind: "file", path: displayPath, oldPath: null, op, before, after, binary: false, hunks }];
 }
-function changesFromClaudeHook(input, cwd) {
+function changesFromClaudeHook(input, cwd, base = cwd) {
   const ti = input.tool_input ?? {};
+  const abs = (path) => resolve2(base, path);
   switch (input.tool_name) {
     case "Bash": {
       const raw = asStr(ti.command);
@@ -1266,33 +1309,33 @@ function changesFromClaudeHook(input, cwd) {
     case "Write": {
       const fp = asStr(ti.file_path);
       if (!fp) return [];
-      const before = readDisk(abs(fp, cwd));
-      return synthFileChange(relForDisplay(abs(fp, cwd), cwd), before, asStr(ti.content));
+      const before = readDisk(abs(fp));
+      return synthFileChange(relForDisplay(abs(fp), cwd), before, asStr(ti.content));
     }
     case "Edit": {
       const fp = asStr(ti.file_path);
       if (!fp) return [];
-      const before = readDisk(abs(fp, cwd));
+      const before = readDisk(abs(fp));
       const after = applyEdit(before, asStr(ti.old_string), asStr(ti.new_string));
-      return synthFileChange(relForDisplay(abs(fp, cwd), cwd), before, after);
+      return synthFileChange(relForDisplay(abs(fp), cwd), before, after);
     }
     case "MultiEdit": {
       const fp = asStr(ti.file_path);
       if (!fp) return [];
-      const before = readDisk(abs(fp, cwd));
+      const before = readDisk(abs(fp));
       let after = before;
       const edits = Array.isArray(ti.edits) ? ti.edits : [];
       for (const raw of edits) {
         const ed = isRecord(raw) ? raw : {};
         after = applyEdit(after, asStr(ed.old_string), asStr(ed.new_string));
       }
-      return synthFileChange(relForDisplay(abs(fp, cwd), cwd), before, after);
+      return synthFileChange(relForDisplay(abs(fp), cwd), before, after);
     }
     case "NotebookEdit": {
       const fp = asStr(ti.notebook_path);
       const src = asStr(ti.new_source);
       if (!fp || !src) return [];
-      return synthFileChange(relForDisplay(abs(fp, cwd), cwd), "", src);
+      return synthFileChange(relForDisplay(abs(fp), cwd), "", src);
     }
     default:
       return [];
@@ -2506,18 +2549,18 @@ var init_test_skip = __esm({
 });
 
 // src/detectors/repo.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
+import { execFileSync as execFileSync5 } from "node:child_process";
 import { readFileSync as readFileSync3 } from "node:fs";
 import { join as join6 } from "node:path";
 function trackedFiles(ctx) {
   if (!ctx) return null;
   if (ctx.trackedFiles) return ctx.trackedFiles;
   if (!ctx.cwd) return null;
-  const hit = cache.get(ctx.cwd);
+  const hit = cache2.get(ctx.cwd);
   if (hit !== void 0) return hit;
   let files = null;
   try {
-    files = execFileSync4("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    files = execFileSync5("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
       cwd: ctx.cwd,
       encoding: "utf8",
       maxBuffer: 64 * 1024 * 1024,
@@ -2526,7 +2569,7 @@ function trackedFiles(ctx) {
   } catch {
     files = null;
   }
-  cache.set(ctx.cwd, files);
+  cache2.set(ctx.cwd, files);
   return files;
 }
 function trackedContent(path, ctx) {
@@ -2551,7 +2594,7 @@ function branchRefs(ctx) {
   if (hit !== void 0) return hit;
   let refs = null;
   try {
-    const out3 = execFileSync4("git", ["for-each-ref", "--format=%(refname:short)", "refs/heads", "refs/remotes"], {
+    const out3 = execFileSync5("git", ["for-each-ref", "--format=%(refname:short)", "refs/heads", "refs/remotes"], {
       cwd: ctx.cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -2570,11 +2613,11 @@ function branchExists(name, ctx) {
   for (const r of refs) if (r.endsWith("/" + name)) return true;
   return false;
 }
-function revIsHead(rev, ctx) {
-  if (!ctx?.cwd || rev.startsWith("-")) return null;
+function revIsHead(rev2, ctx) {
+  if (!ctx?.cwd || rev2.startsWith("-")) return null;
   const parse = (r) => {
     try {
-      return execFileSync4("git", ["rev-parse", "--verify", "--quiet", "--end-of-options", `${r}^{commit}`], {
+      return execFileSync5("git", ["rev-parse", "--verify", "--quiet", "--end-of-options", `${r}^{commit}`], {
         cwd: ctx.cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "pipe"]
@@ -2584,7 +2627,7 @@ function revIsHead(rev, ctx) {
     }
   };
   const head = parse("HEAD");
-  const target = parse(rev);
+  const target = parse(rev2);
   if (!head || !target) return null;
   return head === target;
 }
@@ -2594,7 +2637,7 @@ function defaultBranch(ctx) {
   if (hit !== void 0) return hit;
   let name = null;
   try {
-    const ref = execFileSync4("git", ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"], {
+    const ref = execFileSync5("git", ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"], {
       cwd: ctx.cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -2619,12 +2662,12 @@ function containsProtected(token, policy, category, ctx, except) {
   const base = dir.split("/").pop() ?? "";
   return category === "tests" && /^(?:test|tests|__tests__|spec|specs)$/i.test(base);
 }
-var cache, contentCache, branchCache, refsCache, dirOf;
+var cache2, contentCache, branchCache, refsCache, dirOf;
 var init_repo = __esm({
   "src/detectors/repo.ts"() {
     "use strict";
     init_policy();
-    cache = /* @__PURE__ */ new Map();
+    cache2 = /* @__PURE__ */ new Map();
     contentCache = /* @__PURE__ */ new Map();
     branchCache = /* @__PURE__ */ new Map();
     refsCache = /* @__PURE__ */ new Map();
@@ -2645,8 +2688,8 @@ function numericOf(e) {
   }
   return void 0;
 }
-function metricsOf(expr, resolve15) {
-  const obj = resolve15(expr);
+function metricsOf(expr, resolve16) {
+  const obj = resolve16(expr);
   if (!ts.isObjectLiteralExpression(obj)) return void 0;
   const out3 = { values: {}, opaque: false };
   let any = false;
@@ -2660,7 +2703,7 @@ function metricsOf(expr, resolve15) {
     const k = keyName(p.name);
     if (k === null || !isMetric(k)) continue;
     any = true;
-    const n = numericOf(resolve15(p.initializer));
+    const n = numericOf(resolve16(p.initializer));
     if (n === void 0) out3.opaque = true;
     else out3.values[k] = n;
   }
@@ -2706,17 +2749,17 @@ function parseThresholds(src) {
   const res = { paths: /* @__PURE__ */ new Map(), present: false, opaque: false };
   try {
     const sf = sourceOf(src);
-    const resolve15 = resolverFor(sf);
+    const resolve16 = resolverFor(sf);
     const visit = (node) => {
       if (ts.isPropertyAssignment(node)) {
         const key2 = keyName(node.name);
         if (key2 === "coverageThreshold" || key2 === "thresholds" && underKey(node, "coverage")) {
           res.present = true;
-          const init = resolve15(node.initializer);
+          const init = resolve16(node.initializer);
           if (!ts.isObjectLiteralExpression(init)) {
             res.opaque = true;
           } else {
-            const flat = metricsOf(init, resolve15);
+            const flat = metricsOf(init, resolve16);
             if (flat) res.global = merge(res.global, flat);
             for (const p of init.properties) {
               if (ts.isSpreadAssignment(p)) {
@@ -2730,7 +2773,7 @@ function parseThresholds(src) {
                 res.global = merge(res.global, { values: { branches: 100, functions: 100, lines: 100, statements: 100 }, opaque: false });
                 continue;
               }
-              const m = metricsOf(p.initializer, resolve15);
+              const m = metricsOf(p.initializer, resolve16);
               if (!m) continue;
               if (k === "global") res.global = merge(res.global, m);
               else res.paths.set(norm(k), m);
@@ -2763,18 +2806,18 @@ function parseLists(src) {
   const res = { collectFrom: null, collectKey: "collectCoverageFrom", ignore: [], opaqueCollect: false, opaqueIgnore: false };
   try {
     const sf = sourceOf(src);
-    const resolve15 = resolverFor(sf);
+    const resolve16 = resolverFor(sf);
     const visit = (node) => {
       if (ts.isPropertyAssignment(node)) {
         const k = keyName(node.name);
         const vitestCoverage = ownerKey(node) === "coverage";
         if (k === "collectCoverageFrom" || k === "include" && vitestCoverage) {
-          const { items, opaque } = literals(resolve15(node.initializer));
+          const { items, opaque } = literals(resolve16(node.initializer));
           res.collectFrom = items;
           res.collectKey = k === "include" ? "coverage.include" : k;
           if (opaque) res.opaqueCollect = true;
         } else if (k === "coveragePathIgnorePatterns" || k === "exclude" && vitestCoverage) {
-          const { items, opaque } = literals(resolve15(node.initializer));
+          const { items, opaque } = literals(resolve16(node.initializer));
           res.ignore.push(...items);
           if (opaque) res.opaqueIgnore = true;
         }
@@ -4047,8 +4090,8 @@ var init_policy_diff = __esm({
 });
 
 // src/detectors/hook-wiring.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { isAbsolute as isAbsolute4, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { isAbsolute as isAbsolute5, resolve as resolve3 } from "node:path";
 function stripComment(line) {
   let single = false;
   let double = false;
@@ -5066,7 +5109,7 @@ function expandShellPath(t, env = process.env) {
 }
 function hookTests(policy, ctx) {
   const cwd = ctx?.cwd;
-  const diskCwd = cwd !== void 0 && existsSync2(cwd) ? cwd : void 0;
+  const diskCwd = cwd !== void 0 && existsSync3(cwd) ? cwd : void 0;
   const onDisk = diskCwd !== void 0;
   const root = diskCwd !== void 0 ? canonicalPath(diskCwd) : cwd;
   const memo = /* @__PURE__ */ new Map();
@@ -5074,10 +5117,10 @@ function hookTests(policy, ctx) {
     const hit = memo.get(t);
     if (hit !== void 0) return hit;
     let p = expandShellPath(t.replace(/^["']|["']$/g, ""));
-    const pathy = isAbsolute4(p) || p.includes("/") && !/^[-:]/.test(p);
-    const abs2 = isAbsolute4(p) ? p : diskCwd !== void 0 ? resolve2(diskCwd, p) : null;
-    if (pathy && abs2 !== null) {
-      p = canonicalPath(abs2);
+    const pathy = isAbsolute5(p) || p.includes("/") && !/^[-:]/.test(p);
+    const abs = isAbsolute5(p) ? p : diskCwd !== void 0 ? resolve3(diskCwd, p) : null;
+    if (pathy && abs !== null) {
+      p = canonicalPath(abs);
       if (root !== void 0) {
         if (p === root) p = ".";
         else if (p.startsWith(root + "/")) p = p.slice(root.length + 1);
@@ -5350,8 +5393,8 @@ var init_hook_wiring = __esm({
 });
 
 // src/detectors/hook-tampering.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join7, relative as relative2 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { isAbsolute as isAbsolute6, join as join7, relative as relative2 } from "node:path";
 function parseSettings(src) {
   try {
     const v = JSON.parse(src);
@@ -5723,7 +5766,7 @@ function lefthookBase(c, changes, ctx) {
   for (const n of names) {
     try {
       const p = join7(ctx.cwd, n);
-      if (existsSync3(p)) return parseDoc(readFileSync4(p, "utf8"));
+      if (existsSync4(p)) return parseDoc(readFileSync4(p, "utf8"));
     } catch {
     }
   }
@@ -5793,9 +5836,9 @@ function updateIndexHiding(toks, policy) {
   return null;
 }
 function repoRelative(path, ctx) {
-  if (!ctx?.cwd || !isAbsolute5(path)) return path;
+  if (!ctx?.cwd || !isAbsolute6(path)) return path;
   const rel = relative2(ctx.cwd, path);
-  return rel && !rel.startsWith("..") && !isAbsolute5(rel) ? rel : path;
+  return rel && !rel.startsWith("..") && !isAbsolute6(rel) ? rel : path;
 }
 function huskyRuntimeWrite(path, content, ctx) {
   const m = path.match(/(?:^|\/)\.husky\/_\/([^/]+)$/);
@@ -6133,7 +6176,7 @@ They WILL FAIL in v10.0.0
               if (why) {
                 const target = shellHookTarget(seg, toks, policy, ctx) ?? shellHookTarget("", fed, policy, ctx);
                 const file = target ? repoRelative(target, ctx) : void 0;
-                const outside = file !== void 0 && (isAbsolute5(file) || /^[A-Za-z]:\//.test(file)) && isClaudeSettings(file) ? ` \u2014 ${file} is a Claude Code settings file the runtime reads hooks from` : "";
+                const outside = file !== void 0 && (isAbsolute6(file) || /^[A-Za-z]:\//.test(file)) && isClaudeSettings(file) ? ` \u2014 ${file} is a Claude Code settings file the runtime reads hooks from` : "";
                 out3.push(
                   makeFinding(RULE7, policy, {
                     ...file !== void 0 ? { file } : {},
@@ -6941,8 +6984,8 @@ var init_test_deletion = __esm({
               const gitRestoresOld = cmd === "git" && /^git\s+(?:checkout|restore)\b/.test(seg) && (() => {
                 const src = seg.match(/--source[= ]\s*(\S+)/)?.[1];
                 const revIdx = toks.findIndex((t, i) => i >= 2 && !t.startsWith("-") && !named.includes(t) && t !== "--");
-                const rev = src ?? (revIdx >= 0 ? toks[revIdx] : void 0);
-                if (!rev || rev === "HEAD" || rev === "@" || revIsHead(rev, ctx) === true) return false;
+                const rev2 = src ?? (revIdx >= 0 ? toks[revIdx] : void 0);
+                if (!rev2 || rev2 === "HEAD" || rev2 === "@" || revIsHead(rev2, ctx) === true) return false;
                 if (src || seg.includes(" -- ")) return true;
                 return revIdx >= 0 && toks.some((t, i) => i > revIdx && named.includes(t));
               })();
@@ -7556,8 +7599,8 @@ var init_engine = __esm({
 });
 
 // src/policy-load.ts
-import { readFileSync as readFileSync5, existsSync as existsSync4 } from "node:fs";
-import { isAbsolute as isAbsolute6, join as join8, posix as posix2 } from "node:path";
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "node:fs";
+import { isAbsolute as isAbsolute7, join as join8, posix as posix2 } from "node:path";
 function normalizeVersion(v, where = POLICY_FILE) {
   if (v === void 0 || v === null) return 1;
   if (typeof v !== "number" || !Number.isInteger(v) || v < 1) {
@@ -7566,7 +7609,7 @@ function normalizeVersion(v, where = POLICY_FILE) {
   return v;
 }
 function ledgerInsideRepo(ledger) {
-  if (!ledger.trim() || isAbsolute6(ledger) || /^[A-Za-z]:[\\/]/.test(ledger)) return false;
+  if (!ledger.trim() || isAbsolute7(ledger) || /^[A-Za-z]:[\\/]/.test(ledger)) return false;
   const norm2 = posix2.normalize(ledger.replace(/\\/g, "/"));
   return norm2 !== ".." && !norm2.startsWith("../") && !norm2.startsWith("/");
 }
@@ -7717,14 +7760,14 @@ function parseOrThrow(src, where) {
   return parsePolicy(raw, where);
 }
 function loadPolicy(cwd = process.cwd()) {
-  const path = join8(cwd, POLICY_FILE);
-  if (!existsSync4(path)) return defaultPolicy();
+  const path = join8(repoRoot(cwd), POLICY_FILE);
+  if (!existsSync5(path)) return defaultPolicy();
   return parseOrThrow(readFileSync5(path, "utf8"), POLICY_FILE);
 }
-function loadPolicyAt(rev, cwd) {
-  const src = fileAt(rev, POLICY_FILE, { cwd });
+function loadPolicyAt(rev2, cwd) {
+  const src = fileAt(rev2, POLICY_FILE, { cwd: cwd === void 0 ? void 0 : repoRoot(cwd) });
   if (src == null) return null;
-  return parseOrThrow(src, `${POLICY_FILE} at ${rev}`);
+  return parseOrThrow(src, `${POLICY_FILE} at ${rev2}`);
 }
 var PolicyError, SEVERITIES, isSeverity, isStringList, isMapping, TOP_LEVEL_KEYS;
 var init_policy_load = __esm({
@@ -7734,6 +7777,7 @@ var init_policy_load = __esm({
     init_policy();
     init_build();
     init_narrow();
+    init_repo_context();
     PolicyError = class extends Error {
     };
     SEVERITIES = ["block", "warn"];
@@ -7746,7 +7790,7 @@ var init_policy_load = __esm({
 
 // src/signoff.ts
 import { createHash as createHash2 } from "node:crypto";
-import { appendFileSync, mkdirSync, readFileSync as readFileSync6, existsSync as existsSync5 } from "node:fs";
+import { appendFileSync, mkdirSync, readFileSync as readFileSync6, existsSync as existsSync6 } from "node:fs";
 import { dirname as dirname2, join as join9 } from "node:path";
 function ledgerEntryFrom(value) {
   if (!isRecord(value)) return null;
@@ -7768,7 +7812,7 @@ function ledgerPath(cwd, policy) {
 }
 function readLedger(cwd, policy) {
   const p = ledgerPath(cwd, policy);
-  if (!existsSync5(p)) return [];
+  if (!existsSync6(p)) return [];
   const out3 = [];
   for (const line of readFileSync6(p, "utf8").split("\n")) {
     if (!line.trim()) continue;
@@ -8131,27 +8175,28 @@ var init_report = __esm({
 
 // src/cli/check.ts
 function check(opts) {
-  const cwd = opts.cwd ?? process.cwd();
-  if (!isGitRepo(cwd)) {
-    process.stderr.write(`tamperward: ${cwd} is not inside a git repository \u2014 nothing to check
+  const requested = opts.cwd ?? process.cwd();
+  if (!isGitRepo(requested)) {
+    process.stderr.write(`tamperward: ${requested} is not inside a git repository \u2014 nothing to check
 `);
     return 2;
   }
-  let policy = opts.policyOverride ?? loadPolicy(opts.cwd);
+  const cwd = repoRoot(requested);
+  let policy = opts.policyOverride ?? loadPolicy(cwd);
   let changes;
   let layer;
   let view;
   if (opts.staged) {
-    changes = diffStaged({ cwd: opts.cwd });
+    changes = diffStaged({ cwd });
     layer = "local";
     view = "staged";
   } else if (opts.worktree) {
     const p = policy;
-    changes = opts.includeUntracked ? diffWorktreeWithUntracked({ cwd: opts.cwd }, (rel) => isProtected(rel, p)) : diffWorktree({ cwd: opts.cwd });
+    changes = opts.includeUntracked ? diffWorktreeWithUntracked({ cwd }, (rel) => isProtected(rel, p)) : diffWorktree({ cwd });
     const seen = new Set(changes.filter((c) => c.kind === "file").map((c) => c.path));
-    for (const rel of hiddenTrackedPaths({ cwd: opts.cwd })) {
+    for (const rel of hiddenTrackedPaths({ cwd })) {
       if (seen.has(rel) || !isProtected(rel, p)) continue;
-      changes.push(...synthFileChange(rel, fileAt("HEAD", rel, { cwd: opts.cwd }), fileOnDisk(rel, { cwd: opts.cwd })));
+      changes.push(...synthFileChange(rel, fileAt("HEAD", rel, { cwd }), fileOnDisk(rel, { cwd })));
     }
     layer = opts.ciLayer ? "ci" : "local";
     view = "worktree";
@@ -8163,7 +8208,7 @@ function check(opts) {
 `);
       return 2;
     }
-    changes = diffRange(base, head, { cwd: opts.cwd });
+    changes = diffRange(base, head, { cwd });
     if (changes.length === 0) {
       process.stderr.write(
         `tamperward: note: the range ${base}...${head} contains no changes \u2014 if this is not an empty pull request, check that the range resolves to the intended commits
@@ -8172,7 +8217,7 @@ function check(opts) {
     }
     layer = "ci";
     view = "range";
-    policy = opts.policyOverride ?? loadPolicyAt(mergeBaseOf(base, head, { cwd: opts.cwd }), opts.cwd) ?? defaultPolicy();
+    policy = opts.policyOverride ?? loadPolicyAt(mergeBaseOf(base, head, { cwd }), cwd) ?? defaultPolicy();
   } else {
     process.stderr.write("tamperward: specify --staged, --worktree, or --diff <base>...<head>\n");
     return 2;
@@ -8215,6 +8260,7 @@ var init_check = __esm({
     init_disk();
     init_signoff();
     init_report();
+    init_repo_context();
   }
 });
 
@@ -8244,7 +8290,7 @@ var init_deny = __esm({
 });
 
 // src/session.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname3, join as join10 } from "node:path";
 function baselinePath(cwd, sessionId) {
   const gd = gitDir(cwd);
@@ -8256,7 +8302,7 @@ function turnBaseline(cwd, sessionId) {
   try {
     const p = baselinePath(cwd, sessionId);
     if (!p) return null;
-    if (existsSync6(p)) {
+    if (existsSync7(p)) {
       const v = readFileSync7(p, "utf8").trim();
       if (SHA.test(v)) return v;
     }
@@ -8292,9 +8338,8 @@ var init_session = __esm({
 
 // src/effect.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync7, lstatSync as lstatSync3, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync8, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { isAbsolute as isAbsolute7, join as join11 } from "node:path";
-import { execFileSync as execFileSync5 } from "node:child_process";
+import { existsSync as existsSync8, lstatSync as lstatSync3, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync8, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join11 } from "node:path";
 function ptreeFrom(value) {
   if (!isRecord(value)) return null;
   const out3 = {};
@@ -8307,17 +8352,7 @@ function ptreeFrom(value) {
   return out3;
 }
 function gitDir2(cwd) {
-  try {
-    const d = execFileSync5("git", ["rev-parse", "--git-dir"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    }).trim();
-    if (!d) return null;
-    return isAbsolute7(d) ? d : join11(cwd, d);
-  } catch {
-    return null;
-  }
+  return repoContext(cwd)?.gitDir ?? null;
 }
 function statePath(cwd, sessionId, kind) {
   if (!sessionId) return null;
@@ -8339,10 +8374,11 @@ function entryOf(e) {
   const hash = e.content != null ? sha(e.content) : e.kind === "unreadable" ? "unreadable" : `${e.kind}:${e.detail}`;
   return { hash, mode: e.mode, size: e.size, mtimeMs: e.mtimeMs };
 }
-function snapshotProtected(cwd, policy, prev, cache2) {
+function snapshotProtected(cwd, policy, prev, cache3) {
   void prev;
-  cache2?.beginSnapshot();
-  const entryAt = (rel) => cache2 ? cache2.entry(cwd, rel, () => entryOf(inspectRel(cwd, rel))) : entryOf(inspectRel(cwd, rel));
+  cwd = repoRoot(cwd);
+  cache3?.beginSnapshot();
+  const entryAt = (rel) => cache3 ? cache3.entry(cwd, rel, () => entryOf(inspectRel(cwd, rel))) : entryOf(inspectRel(cwd, rel));
   const out3 = {};
   const keep = (rel) => isProtected(rel, policy);
   let pruned = /* @__PURE__ */ new Set();
@@ -8354,10 +8390,10 @@ function snapshotProtected(cwd, policy, prev, cache2) {
   } catch {
   }
   const walk2 = (rel) => {
-    const abs2 = rel ? join11(cwd, rel) : cwd;
+    const abs = rel ? join11(cwd, rel) : cwd;
     let names;
     try {
-      names = readdirSync(abs2);
+      names = readdirSync(abs);
     } catch {
       return;
     }
@@ -8394,7 +8430,7 @@ function driftBetween(expected, current) {
   return { changed, deleted, added };
 }
 function loadTree(p) {
-  if (!p || !existsSync7(p)) return null;
+  if (!p || !existsSync8(p)) return null;
   try {
     return ptreeFrom(JSON.parse(readFileSync8(p, "utf8")));
   } catch {
@@ -8437,6 +8473,7 @@ var UNSAFE2, SKIP_DIRS2, sha;
 var init_effect = __esm({
   "src/effect.ts"() {
     "use strict";
+    init_repo_context();
     init_policy();
     init_disk();
     init_build();
@@ -8451,8 +8488,8 @@ var init_effect = __esm({
 import { appendFileSync as appendFileSync3, lstatSync as lstatSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync9, readdirSync as readdirSync2, watch, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join12 } from "node:path";
 import { createHash as createHash4 } from "node:crypto";
-function snap(abs2) {
-  const e = inspectPath(abs2);
+function snap(abs) {
+  const e = inspectPath(abs);
   if (e.kind === "absent" || e.kind === "unreadable") return { mode: null, size: null, hash: null };
   if (e.kind !== "file" || e.content == null) return { mode: e.mode, size: null, hash: null };
   const hash = createHash4("sha256").update(e.content).digest("hex").slice(0, 16);
@@ -8968,10 +9005,10 @@ var init_fs_events = __esm({
 });
 
 // src/cli/hook.ts
-import { readFileSync as readFileSync10, appendFileSync as appendFileSync4, writeFileSync as writeFileSync5, existsSync as existsSync8 } from "node:fs";
+import { readFileSync as readFileSync10, appendFileSync as appendFileSync4, writeFileSync as writeFileSync5, existsSync as existsSync9 } from "node:fs";
 import { createHash as createHash5 } from "node:crypto";
-function setSnapshotCache(cache2) {
-  snapshotCache = cache2;
+function setSnapshotCache(cache3) {
+  snapshotCache = cache3;
 }
 function readStdin() {
   try {
@@ -9101,8 +9138,8 @@ function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree)
     }
     const want = expected[rel]?.hash;
     let before = null;
-    for (const rev of candidates) {
-      const blob = fileAt(rev, rel, { cwd });
+    for (const rev2 of candidates) {
+      const blob = fileAt(rev2, rel, { cwd });
       if (blob != null && contentHash(blob) === want) {
         before = blob;
         break;
@@ -9213,12 +9250,13 @@ function sanctionPredictedWrites(cwd, sessionId, policy, changes) {
 }
 function preToolUseVerdict(input, defaultCwd) {
   try {
-    const cwd = input.cwd ?? defaultCwd ?? process.cwd();
+    const sessionCwd = input.cwd ?? defaultCwd ?? process.cwd();
+    const cwd = repoRoot(sessionCwd);
     turnBaseline(cwd, input.session_id);
     const policy = loadPolicy(cwd);
     const driftBlocks = effectDriftBlocks(cwd, input.session_id, policy);
     if (driftBlocks) return verdict(driftBlocks, "PreToolUse");
-    const changes = changesFromClaudeHook(input, cwd);
+    const changes = changesFromClaudeHook(input, cwd, sessionCwd);
     const blocks2 = evaluate(changes, policy, void 0, "tool-call", { cwd }).filter((f) => f.severity === "block");
     if (blocks2.length === 0) sanctionPredictedWrites(cwd, input.session_id, policy, changes);
     return verdict(blocks2, "PreToolUse");
@@ -9250,9 +9288,9 @@ function turnTransientBlocks(cwd, sessionId, policy, changes) {
     recordObserverHealth(telemetry.state, telemetry.reason);
   }
   const cp = cursorPath(cwd, sessionId);
-  if (!existsSync8(log)) return none;
+  if (!existsSync9(log)) return none;
   let offset = 0;
-  if (cp && existsSync8(cp)) {
+  if (cp && existsSync9(cp)) {
     const n = Number(readFileSync10(cp, "utf8"));
     offset = Number.isFinite(n) ? n : 0;
   }
@@ -9321,8 +9359,9 @@ function recordObserverHealth(state, reason) {
 }
 function stopVerdict(input, defaultCwd) {
   if (input.stop_hook_active) return { exitCode: 0, stdout: "" };
-  const cwd = input.cwd ?? defaultCwd ?? process.cwd();
-  if (!isGitRepo(cwd)) return { exitCode: 0, stdout: "" };
+  const sessionCwd = input.cwd ?? defaultCwd ?? process.cwd();
+  if (!isGitRepo(sessionCwd)) return { exitCode: 0, stdout: "" };
+  const cwd = repoRoot(sessionCwd);
   let blocks2;
   let commitCursor = () => {
   };
@@ -9410,6 +9449,7 @@ var init_hook = __esm({
     init_policy();
     init_disk();
     init_narrow();
+    init_repo_context();
     snapshotCache = null;
     HookInputError = class extends Error {
     };
@@ -9468,22 +9508,22 @@ var init_ptree_cache = __esm({
        * time, the way the in-process path treats them.
        */
       entry(cwd, rel, compute) {
-        const abs2 = join13(cwd, rel);
+        const abs = join13(cwd, rel);
         let st;
         try {
-          st = lstatSync5(abs2, { bigint: true });
+          st = lstatSync5(abs, { bigint: true });
         } catch {
-          this.map.delete(abs2);
+          this.map.delete(abs);
           this.stats.misses++;
           return compute();
         }
         if (!st.isFile()) {
-          this.map.delete(abs2);
+          this.map.delete(abs);
           this.stats.misses++;
           return compute();
         }
         const key2 = keyOf(st);
-        const hit = this.map.get(abs2);
+        const hit = this.map.get(abs);
         if (hit && hit.key === key2 && hit.recordedAtNs - hit.ctimeNs >= this.racyMarginNs) {
           this.stats.hits++;
           return hit.entry;
@@ -9493,17 +9533,17 @@ var init_ptree_cache = __esm({
         const entry = compute();
         let after;
         try {
-          after = lstatSync5(abs2, { bigint: true });
+          after = lstatSync5(abs, { bigint: true });
         } catch {
-          this.map.delete(abs2);
+          this.map.delete(abs);
           return entry;
         }
         if (!after.isFile() || keyOf(after) !== key2) {
-          this.map.delete(abs2);
+          this.map.delete(abs);
           return entry;
         }
         if (this.map.size >= this.maxEntries) this.clear();
-        this.map.set(abs2, { key: key2, ctimeNs: st.ctimeNs, recordedAtNs, entry });
+        this.map.set(abs, { key: key2, ctimeNs: st.ctimeNs, recordedAtNs, entry });
         return entry;
       }
     };
@@ -9511,7 +9551,7 @@ var init_ptree_cache = __esm({
 });
 
 // src/cli/hook-service.ts
-import { chmodSync, existsSync as existsSync9, lstatSync as lstatSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { chmodSync, existsSync as existsSync10, lstatSync as lstatSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync11, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { createConnection as createConnection2, createServer } from "node:net";
 import { realpathSync as realpathSync3 } from "node:fs";
 import { sep } from "node:path";
@@ -9536,12 +9576,12 @@ function pidAlive2(pid) {
   }
 }
 function listening(socket) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     const sock = createConnection2(socket);
     const done = (v) => {
       clearTimeout(timer);
       sock.destroy();
-      resolve15(v);
+      resolve16(v);
     };
     const timer = setTimeout(() => done(false), 1e3);
     sock.once("connect", () => done(true));
@@ -9599,7 +9639,7 @@ function removeQuietly(p) {
   }
 }
 function ensurePrivateDir(dir, uid) {
-  if (!existsSync9(dir)) mkdirSync5(dir, { recursive: true, mode: 448 });
+  if (!existsSync10(dir)) mkdirSync5(dir, { recursive: true, mode: 448 });
   const st = lstatSync6(dir);
   if (!st.isDirectory()) throw new Error(`${dir} is not a directory`);
   if (st.uid !== uid) throw new Error(`${dir} is owned by uid ${st.uid}, not ${uid}; refusing to serve from it`);
@@ -9616,7 +9656,7 @@ async function startHookService(opts) {
   if (uid === void 0) throw new Error("no uid on this platform; refusing to start");
   let root;
   try {
-    root = realpathSync3(opts.root);
+    root = realpathSync3(repoRoot(realpathSync3(opts.root)));
   } catch {
     throw new Error(`cannot resolve ${opts.root}`);
   }
@@ -9627,7 +9667,7 @@ async function startHookService(opts) {
   }
   removeQuietly(paths.socket);
   removeQuietly(paths.state);
-  const cache2 = opts.cache ?? new SnapshotCache();
+  const cache3 = opts.cache ?? new SnapshotCache();
   let served = 0;
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const respond = (sock, body) => {
@@ -9653,7 +9693,7 @@ async function startHookService(opts) {
         root,
         started_at: startedAt,
         served,
-        cache: { hits: cache2.stats.hits, misses: cache2.stats.misses, size: cache2.size }
+        cache: { hits: cache3.stats.hits, misses: cache3.stats.misses, size: cache3.size }
       });
     }
     if (!within(root, req2.cwd)) return respond(sock, { refused: "cwd outside the bound repository" });
@@ -9694,11 +9734,11 @@ async function startHookService(opts) {
   });
   const umask = process.umask(63);
   try {
-    await new Promise((resolve15, reject) => {
+    await new Promise((resolve16, reject) => {
       server.once("error", reject);
       server.listen(paths.socket, () => {
         server.off("error", reject);
-        resolve15();
+        resolve16();
       });
     });
   } finally {
@@ -9707,7 +9747,7 @@ async function startHookService(opts) {
   chmodSync(paths.socket, 384);
   const state = { pid: process.pid, version: TW_VERSION, root, started_at: startedAt };
   writeFileSync6(paths.state, JSON.stringify(state) + "\n", { mode: 384 });
-  setSnapshotCache(cache2);
+  setSnapshotCache(cache3);
   let closed = false;
   return {
     paths,
@@ -9715,14 +9755,14 @@ async function startHookService(opts) {
     get served() {
       return served;
     },
-    close: () => new Promise((resolve15) => {
-      if (closed) return resolve15();
+    close: () => new Promise((resolve16) => {
+      if (closed) return resolve16();
       closed = true;
       setSnapshotCache(null);
       server.close(() => {
         removeQuietly(paths.socket);
         removeQuietly(paths.state);
-        resolve15();
+        resolve16();
       });
     })
   };
@@ -9751,7 +9791,7 @@ async function stopHookService(paths) {
       process.kill(state.pid, "SIGTERM");
     } catch {
     }
-    const gone = () => !pidAlive2(state.pid) || !existsSync9(paths.socket);
+    const gone = () => !pidAlive2(state.pid) || !existsSync10(paths.socket);
     const until = Date.now() + STOP_WAIT_MS;
     while (!gone() && Date.now() < until) sleepSync(50);
     if (!gone()) throw new Error(`hook service pid ${state.pid} did not exit within ${STOP_WAIT_MS / 1e3}s`);
@@ -9819,9 +9859,9 @@ function runHookService(args) {
 `);
       process.exit(0);
     }
-    const cache2 = isRecord(res.cache) ? res.cache : {};
+    const cache3 = isRecord(res.cache) ? res.cache : {};
     process.stdout.write(
-      `tamperward hook-service: running (pid ${state.pid}, tamperward@${state.version}, root ${state.root}, since ${state.started_at}); served: ${res.served}; snapshot cache hits/misses/entries: ${String(cache2.hits ?? 0)}/${String(cache2.misses ?? 0)}/${String(cache2.size ?? 0)}; ${optIn}
+      `tamperward hook-service: running (pid ${state.pid}, tamperward@${state.version}, root ${state.root}, since ${state.started_at}); served: ${res.served}; snapshot cache hits/misses/entries: ${String(cache3.hits ?? 0)}/${String(cache3.misses ?? 0)}/${String(cache3.size ?? 0)}; ${optIn}
 `
     );
     process.exit(0);
@@ -9835,6 +9875,7 @@ var init_hook_service = __esm({
     init_narrow();
     init_wiring();
     init_ptree_cache();
+    init_repo_context();
     init_hook();
     init_hook_client();
     MAX_REQUEST_BYTES = 64 * 1024 * 1024;
@@ -9852,7 +9893,7 @@ function runAllow(opts) {
     process.stderr.write("tamperward: a --reason is required \u2014 sign-offs must be justified.\n");
     return 2;
   }
-  const cwd = opts.cwd ?? process.cwd();
+  const cwd = repoRoot(opts.cwd ?? process.cwd());
   const policy = loadPolicy(cwd);
   let findings;
   try {
@@ -9894,6 +9935,7 @@ var init_allow = __esm({
     init_engine();
     init_policy_load();
     init_signoff();
+    init_repo_context();
   }
 });
 
@@ -9934,8 +9976,8 @@ var init_verifier_limits = __esm({
 // src/cli/init.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync10, lstatSync as lstatSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync7, chmodSync as chmodSync2, statSync as statSync2 } from "node:fs";
-import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute8, join as join14, relative as relative3, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync11, lstatSync as lstatSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync12, realpathSync as realpathSync4, writeFileSync as writeFileSync7, chmodSync as chmodSync2, statSync as statSync2 } from "node:fs";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute8, join as join14, relative as relative3, resolve as resolve4 } from "node:path";
 function gitConfig(cwd, key2) {
   try {
     return execFileSync6("git", ["config", "--get", key2], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
@@ -10038,7 +10080,7 @@ function verifierCandidates(cwd) {
     if (/^\s*\[tool\.pytest(?:\.ini_options)?\]\s*$/m.test(pyproject)) add("pytest");
   } catch {
   }
-  if (existsSync10(join14(cwd, "pytest.ini"))) add("pytest");
+  if (existsSync11(join14(cwd, "pytest.ini"))) add("pytest");
   try {
     const setupCfg = readFileSync12(join14(cwd, "setup.cfg"), "utf8");
     if (/^\s*\[tool:pytest\]\s*$/m.test(setupCfg)) add("pytest");
@@ -10096,7 +10138,7 @@ function verifierSetupMessage(cwd) {
 }
 function planPolicy(cwd) {
   const path = join14(cwd, POLICY_FILE);
-  if (existsSync10(path)) {
+  if (existsSync11(path)) {
     try {
       loadPolicy(cwd);
     } catch (e) {
@@ -10115,9 +10157,9 @@ function planPolicy(cwd) {
 function planGitignore(cwd) {
   const rel = ".gitignore";
   const path = join14(cwd, rel);
-  if (!existsSync10(join14(cwd, "node_modules"))) return null;
+  if (!existsSync11(join14(cwd, "node_modules"))) return null;
   let existing = "";
-  if (existsSync10(path)) {
+  if (existsSync11(path)) {
     let st;
     try {
       st = lstatSync7(path);
@@ -10166,7 +10208,7 @@ function planGitignore(cwd) {
   return {
     item: "gitignore",
     path: rel,
-    status: existsSync10(path) ? "update" : "create",
+    status: existsSync11(path) ? "update" : "create",
     detail: "exclude installed Node dependencies from repository diffs",
     apply: () => writeFileSync7(path, next)
   };
@@ -10175,7 +10217,7 @@ function planClaudeHooks(cwd) {
   const rel = ".claude/settings.json";
   const path = join14(cwd, rel);
   let settings = {};
-  if (existsSync10(path)) {
+  if (existsSync11(path)) {
     let parsed;
     try {
       parsed = JSON.parse(readFileSync12(path, "utf8"));
@@ -10213,7 +10255,7 @@ function planClaudeHooks(cwd) {
   return {
     item: "agent",
     path: rel,
-    status: existsSync10(path) ? "update" : "create",
+    status: existsSync11(path) ? "update" : "create",
     detail: [
       needPre && "wire PreToolUse deny",
       needStop && "wire Stop sweep",
@@ -10247,10 +10289,10 @@ function planClaudeHooks(cwd) {
 function hooksDir(cwd) {
   try {
     const out3 = execFileSync6("git", ["rev-parse", "--git-path", "hooks"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-    if (out3) return resolve3(cwd, out3);
+    if (out3) return resolve4(cwd, out3);
   } catch {
   }
-  return existsSync10(join14(cwd, ".git")) ? join14(cwd, ".git", "hooks") : null;
+  return existsSync11(join14(cwd, ".git")) ? join14(cwd, ".git", "hooks") : null;
 }
 function display(cwd, path) {
   const rel = relative3(cwd, path);
@@ -10277,11 +10319,11 @@ function planPreCommit(cwd) {
   const skip = (detail) => ({ item: "pre-commit", path: "(none)", status: "skip", detail });
   let path;
   let note;
-  if (existsSync10(join14(cwd, ".husky"))) {
+  if (existsSync11(join14(cwd, ".husky"))) {
     path = join14(cwd, ".husky", "pre-commit");
     note = "husky";
   } else {
-    const managed = MANAGED_HOOKS.find((m) => m.configs.some((c) => existsSync10(join14(cwd, c))));
+    const managed = MANAGED_HOOKS.find((m) => m.configs.some((c) => existsSync11(join14(cwd, c))));
     if (managed) {
       return skip(`${managed.name} manages this repository's hooks and regenerates them on install, so a line in the hooks directory would not last \u2014 ${managed.hint}`);
     }
@@ -10297,10 +10339,10 @@ function planPreCommit(cwd) {
     }
   }
   const rel = display(cwd, path);
-  if (existsSync10(path) && !statSync2(path).isFile()) {
+  if (existsSync11(path) && !statSync2(path).isFile()) {
     return { item: "pre-commit", path: rel, status: "error", detail: "exists but is not a regular file \u2014 refusing to write" };
   }
-  const existing = existsSync10(path) ? readFileSync12(path, "utf8") : null;
+  const existing = existsSync11(path) ? readFileSync12(path, "utf8") : null;
   if (existing === null) {
     return {
       item: "pre-commit",
@@ -10389,7 +10431,7 @@ ${block.join("\n")}
 function planCodeowners(cwd) {
   const rel = ".github/CODEOWNERS";
   const existingRel = [".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"].find(
-    (r) => existsSync10(join14(cwd, r))
+    (r) => existsSync11(join14(cwd, r))
   );
   const path = join14(cwd, existingRel ?? rel);
   const existing = existingRel ? readFileSync12(path, "utf8") : null;
@@ -10430,7 +10472,7 @@ function planWorkflow(cwd, force) {
     mkdirSync6(dirname4(path), { recursive: true });
     writeFileSync7(path, workflowFile(WORKFLOW_CONTENT));
   };
-  if (!existsSync10(path)) {
+  if (!existsSync11(path)) {
     return {
       item: "ci",
       path: rel,
@@ -10482,6 +10524,13 @@ function planned(item, path, plan) {
     return { item, path, status: "error", detail: `cannot plan this item \u2014 ${errText3(e)}` };
   }
 }
+function sameDir(a, b) {
+  try {
+    return realpathSync4(a) === realpathSync4(b);
+  } catch {
+    return false;
+  }
+}
 function planInit(cwd, opts = {}) {
   requireShippedVersion();
   const gitignore = planGitignore(cwd);
@@ -10495,9 +10544,14 @@ function planInit(cwd, opts = {}) {
   ];
 }
 function runInit(opts) {
-  const cwd = opts.cwd ?? process.cwd();
-  const plan = planInit(cwd, { forceWorkflow: opts.forceWorkflow });
+  const requested = resolve4(opts.cwd ?? process.cwd());
+  const cwd = repoRoot(requested);
   const w = opts.quiet ? { write: (_text) => true } : process.stdout;
+  if (cwd !== requested && !sameDir(cwd, requested)) {
+    process.stderr.write(`tamperward init: ${requested} is inside the repository rooted at ${cwd}; wiring the root.
+`);
+  }
+  const plan = planInit(cwd, { forceWorkflow: opts.forceWorkflow });
   let applied = 0;
   for (const a of plan) {
     if (!opts.dryRun && a.apply) {
@@ -10552,6 +10606,7 @@ var init_init = __esm({
     init_verifier_limits();
     init_wiring();
     init_narrow();
+    init_repo_context();
     errText3 = (e) => (e instanceof Error ? e.message : String(e)).replace(/\s+/g, " ").trim();
     isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
     HOOK_RE = /\btamperward(?:@\S+)?\s+hook\s+claude\b/;
@@ -10720,12 +10775,12 @@ var init_fingerprint = __esm({
 // src/dependency-env.ts
 import { createHash as createHash8 } from "node:crypto";
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   lstatSync as lstatSync8,
   readdirSync as readdirSync3,
   readFileSync as readFileSync13,
   readlinkSync as readlinkSync2,
-  realpathSync as realpathSync4,
+  realpathSync as realpathSync5,
   statSync as statSync3
 } from "node:fs";
 import {
@@ -10735,14 +10790,14 @@ import {
   isAbsolute as isAbsolute9,
   join as join15,
   relative as relative4,
-  resolve as resolve4,
+  resolve as resolve5,
   sep as sep2
 } from "node:path";
 function metricsFor(descriptor) {
   return descriptor.metrics ??= { fullSnapshots: 0, reusedSnapshots: 0, totalMs: 0 };
 }
 function inside(root, candidate) {
-  const rel = relative4(resolve4(root), resolve4(candidate));
+  const rel = relative4(resolve5(root), resolve5(candidate));
   return rel === "" || rel !== ".." && !rel.startsWith(".." + sep2) && !isAbsolute9(rel);
 }
 function modeKind(path) {
@@ -10757,7 +10812,7 @@ function fingerprintRoot(root, cwd, h) {
   let currentReal;
   try {
     rootStat = lstatSync8(root.path);
-    currentReal = realpathSync4(root.path);
+    currentReal = realpathSync5(root.path);
   } catch (e) {
     throw new Unattestable(
       root.kind + " root " + JSON.stringify(root.path) + " can no longer be resolved (" + (e instanceof Error ? e.message : String(e)) + ")"
@@ -10773,7 +10828,7 @@ function fingerprintRoot(root, cwd, h) {
   }
   h.update("root\0" + root.kind + "\0" + root.path + "\0" + root.realPath + "\0" + String(rootStat.mode) + "\0");
   if (rootStat.isSymbolicLink()) h.update(readlinkSync2(root.path) + "\0");
-  const cwdReal = realpathSync4(cwd);
+  const cwdReal = realpathSync5(cwd);
   const visited = /* @__PURE__ */ new Set();
   const hashFile = (path, label) => {
     let st;
@@ -10790,7 +10845,7 @@ function fingerprintRoot(root, cwd, h) {
     }
   };
   const walk2 = (dir, namespace) => {
-    const realDir = realpathSync4(dir);
+    const realDir = realpathSync5(dir);
     if (visited.has(realDir)) return;
     visited.add(realDir);
     let entries;
@@ -10840,7 +10895,7 @@ function fingerprintRoot(root, cwd, h) {
         h.update(target + "\0");
         let resolved;
         try {
-          resolved = realpathSync4(path);
+          resolved = realpathSync5(path);
         } catch {
           continue;
         }
@@ -10874,7 +10929,7 @@ function snapshot(roots, probes, cwd) {
   const h = createHash8("sha256");
   for (const probe of probes) {
     h.update(
-      "probe\0" + probe.kind + "\0" + probe.path + "\0" + (existsSync11(probe.path) ? "present" : "absent") + "\0"
+      "probe\0" + probe.kind + "\0" + probe.path + "\0" + (existsSync12(probe.path) ? "present" : "absent") + "\0"
     );
   }
   for (const root of roots) fingerprintRoot(root, cwd, h);
@@ -10895,7 +10950,7 @@ function freezeRoot(kind, path) {
     if (!statSync3(path).isDirectory()) {
       throw new Error("not a directory");
     }
-    return { kind, path: resolve4(path), realPath: realpathSync4(path) };
+    return { kind, path: resolve5(path), realPath: realpathSync5(path) };
   } catch (e) {
     throw new Unattestable(
       kind + " root " + JSON.stringify(path) + " is not resolvable (" + (e instanceof Error ? e.message : String(e)) + ")"
@@ -10931,17 +10986,17 @@ function firstExecutable(command) {
 function resolveExecutable(token, cwd, env) {
   if (!token) return null;
   if (token.includes("/") || token.includes("\\")) {
-    const path = isAbsolute9(token) ? token : resolve4(cwd, token);
+    const path = isAbsolute9(token) ? token : resolve5(cwd, token);
     try {
-      return existsSync11(path) ? realpathSync4(path) : null;
+      return existsSync12(path) ? realpathSync5(path) : null;
     } catch {
       return null;
     }
   }
   for (const entry of (env.PATH ?? "").split(delimiter).filter(Boolean)) {
-    const candidate = resolve4(entry, token);
+    const candidate = resolve5(entry, token);
     try {
-      if (existsSync11(candidate) && statSync3(candidate).isFile()) return realpathSync4(candidate);
+      if (existsSync12(candidate) && statSync3(candidate).isFile()) return realpathSync5(candidate);
     } catch {
     }
   }
@@ -10958,13 +11013,13 @@ function looksPython(command, executable, token) {
 }
 function inferredVenvFromToken(token, cwd) {
   if (!token || !token.includes("/") && !token.includes("\\")) return null;
-  const path = isAbsolute9(token) ? token : resolve4(cwd, token);
+  const path = isAbsolute9(token) ? token : resolve5(cwd, token);
   if (!pythonName(basename3(path))) return null;
   const parent = dirname5(path);
   const parentName = basename3(parent).toLowerCase();
   if (parentName !== "bin" && parentName !== "scripts") return null;
   const root = dirname5(parent);
-  return existsSync11(join15(root, "pyvenv.cfg")) ? root : null;
+  return existsSync12(join15(root, "pyvenv.cfg")) ? root : null;
 }
 function unsupportedEcosystem(command, token) {
   const name = token ? basename3(token).toLowerCase() : "";
@@ -10980,11 +11035,11 @@ function inferredVenv(executable) {
   const parentName = basename3(parent).toLowerCase();
   if (parentName !== "bin" && parentName !== "scripts") return null;
   const root = dirname5(parent);
-  return existsSync11(join15(root, "pyvenv.cfg")) ? root : null;
+  return existsSync12(join15(root, "pyvenv.cfg")) ? root : null;
 }
 function venvProblem(root) {
   const cfg = join15(root, "pyvenv.cfg");
-  if (!existsSync11(cfg)) return "VIRTUAL_ENV " + JSON.stringify(root) + " has no pyvenv.cfg";
+  if (!existsSync12(cfg)) return "VIRTUAL_ENV " + JSON.stringify(root) + " has no pyvenv.cfg";
   try {
     const body = readFileSync13(cfg, "utf8");
     if (/^\s*include-system-site-packages\s*=\s*true\s*$/im.test(body)) {
@@ -10996,7 +11051,7 @@ function venvProblem(root) {
   return null;
 }
 function discoverDependencyEnvironment(cwdInput, command, env = process.env) {
-  const cwd = resolve4(cwdInput);
+  const cwd = resolve5(cwdInput);
   const roots = [];
   const probes = [];
   const seen = /* @__PURE__ */ new Set();
@@ -11011,7 +11066,7 @@ function discoverDependencyEnvironment(cwdInput, command, env = process.env) {
   };
   try {
     const nodeModules = join15(cwd, "node_modules");
-    if (existsSync11(nodeModules)) addRoot("node_modules", nodeModules);
+    if (existsSync12(nodeModules)) addRoot("node_modules", nodeModules);
     else probes.push({ kind: "node_modules", path: nodeModules });
     const token = firstExecutable(command);
     const executable = resolveExecutable(token, cwd, env);
@@ -11020,10 +11075,10 @@ function discoverDependencyEnvironment(cwdInput, command, env = process.env) {
       if (!isAbsolute9(env.VIRTUAL_ENV)) {
         throw new Unattestable("VIRTUAL_ENV is relative (" + JSON.stringify(env.VIRTUAL_ENV) + ")");
       }
-      venv = resolve4(env.VIRTUAL_ENV);
+      venv = resolve5(env.VIRTUAL_ENV);
     } else {
       venv = inferredVenv(executable) ?? inferredVenvFromToken(token, cwd);
-      if (!venv && /(?:^|\s)uv\s+run(?:\s|$)/.test(command) && existsSync11(join15(cwd, ".venv", "pyvenv.cfg"))) {
+      if (!venv && /(?:^|\s)uv\s+run(?:\s|$)/.test(command) && existsSync12(join15(cwd, ".venv", "pyvenv.cfg"))) {
         venv = join15(cwd, ".venv");
       }
     }
@@ -11060,7 +11115,7 @@ function checkDependencyEnvironment(cwdInput, descriptor) {
     const fingerprint2 = measuredSnapshot(
       descriptor.roots,
       descriptor.probes,
-      resolve4(cwdInput),
+      resolve5(cwdInput),
       metricsFor(descriptor)
     );
     if (fingerprint2 !== descriptor.fingerprint) {
@@ -11073,7 +11128,7 @@ function checkDependencyEnvironment(cwdInput, descriptor) {
 }
 function attestDependencyEnvironment(cwdInput, descriptor) {
   const attestation = {
-    cwd: resolve4(cwdInput),
+    cwd: resolve5(cwdInput),
     descriptor,
     check: checkDependencyEnvironment(cwdInput, descriptor)
   };
@@ -11081,7 +11136,7 @@ function attestDependencyEnvironment(cwdInput, descriptor) {
   return attestation;
 }
 function reuseDependencyEnvironmentAttestation(cwdInput, descriptor, attestation) {
-  if (!attestation || !issuedAttestations.has(attestation) || attestation.descriptor !== descriptor || attestation.cwd !== resolve4(cwdInput)) return null;
+  if (!attestation || !issuedAttestations.has(attestation) || attestation.descriptor !== descriptor || attestation.cwd !== resolve5(cwdInput)) return null;
   metricsFor(descriptor).reusedSnapshots += 1;
   return attestation.check;
 }
@@ -11447,8 +11502,8 @@ if (child) {
 // src/verifier-backend.ts
 import { createHash as createHash9, randomUUID } from "node:crypto";
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { accessSync, constants as constants2, readFileSync as readFileSync15, realpathSync as realpathSync5, statSync as statSync4 } from "node:fs";
-import { delimiter as delimiter2, dirname as dirname6, join as join17, resolve as resolve5 } from "node:path";
+import { accessSync, constants as constants2, readFileSync as readFileSync15, realpathSync as realpathSync6, statSync as statSync4 } from "node:fs";
+import { delimiter as delimiter2, dirname as dirname6, join as join17, resolve as resolve6 } from "node:path";
 function identity() {
   const uid = typeof process.getuid === "function" ? process.getuid() : null;
   const groups = typeof process.getgroups === "function" ? process.getgroups() : [];
@@ -11468,7 +11523,7 @@ function writableByCaller(path) {
   }
 }
 function replaceableByCaller(path) {
-  let current = resolve5(path);
+  let current = resolve6(path);
   if (writableByCaller(current)) return true;
   current = dirname6(current);
   while (true) {
@@ -11485,7 +11540,7 @@ function findExecutable(name) {
     const candidate = join17(raw, name);
     try {
       accessSync(candidate, constants2.X_OK);
-      return realpathSync5(candidate);
+      return realpathSync6(candidate);
     } catch {
     }
   }
@@ -11560,7 +11615,7 @@ function inspectImageMetadata(enginePath, host, image) {
 function engineStable(backend) {
   if (!backend.enginePath || !backend.engineSha256) return false;
   try {
-    if (realpathSync5(backend.enginePath) !== backend.enginePath) return false;
+    if (realpathSync6(backend.enginePath) !== backend.enginePath) return false;
     if (replaceableByCaller(backend.enginePath)) return false;
     return fileSha256(backend.enginePath) === backend.engineSha256;
   } catch {
@@ -11814,7 +11869,7 @@ function runContainerStage(backend, dir, command, budgetSecs) {
   const args = containerRunArgs({
     image: backend.image,
     name,
-    workspace: resolve5(dir),
+    workspace: resolve6(dir),
     command,
     uid,
     gid,
@@ -11926,9 +11981,9 @@ var init_verifier_backend = __esm({
 // src/cli/verify.ts
 import { execFileSync as execFileSync8, spawnSync as spawnSync3 } from "node:child_process";
 import { createHash as createHash10 } from "node:crypto";
-import { chmodSync as chmodSync3, cpSync, lstatSync as lstatSync9, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, readlinkSync as readlinkSync3, rmSync as rmSync5, symlinkSync, writeFileSync as writeFileSync9 } from "node:fs";
+import { chmodSync as chmodSync3, cpSync, lstatSync as lstatSync9, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, readlinkSync as readlinkSync3, rmSync as rmSync5, symlinkSync, writeFileSync as writeFileSync9, existsSync as existsSync13 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname7, isAbsolute as isAbsolute10, join as join18, relative as relative5, resolve as resolve6, sep as sep3 } from "node:path";
+import { dirname as dirname7, isAbsolute as isAbsolute10, join as join18, relative as relative5, resolve as resolve7, sep as sep3 } from "node:path";
 function oracleAssuranceReport() {
   return {
     level: "suite-exit-only",
@@ -11942,11 +11997,11 @@ function git2(args, cwd) {
 }
 function resolveBase(base, cwd) {
   assertRev(base);
-  const rev = git2(["rev-parse", "--verify", `${base}^{commit}`], cwd).trim();
+  const rev2 = git2(["rev-parse", "--verify", `${base}^{commit}`], cwd).trim();
   try {
-    return git2(["merge-base", rev, "HEAD"], cwd).trim();
+    return git2(["merge-base", rev2, "HEAD"], cwd).trim();
   } catch {
-    return rev;
+    return rev2;
   }
 }
 function baseIsAncestorOfHead(base, cwd) {
@@ -11954,7 +12009,7 @@ function baseIsAncestorOfHead(base, cwd) {
   return r.status === 0;
 }
 function inside2(root, path) {
-  const rel = relative5(resolve6(root), resolve6(path));
+  const rel = relative5(resolve7(root), resolve7(path));
   return rel === "" || rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute10(rel);
 }
 function linkParts(path) {
@@ -11971,7 +12026,7 @@ function rootedLinkTarget(target) {
   return isAbsolute10(target) || driveRelativeLinkTarget(target);
 }
 function safeSymlink(target, out3, root, label) {
-  if (rootedLinkTarget(target) || !inside2(root, resolve6(dirname7(out3), target))) {
+  if (rootedLinkTarget(target) || !inside2(root, resolve7(dirname7(out3), target))) {
     throw linkEscape(label, target);
   }
   rmSync5(out3, { force: true });
@@ -12022,7 +12077,7 @@ function validateSymlinkGraph(target, out3, root, dependencyRoot, label) {
         throw linkEscape(label, target);
       }
       stack = [];
-      pending.unshift(...linkParts(relative5(dependencyRoot, resolve6(next))));
+      pending.unshift(...linkParts(relative5(dependencyRoot, resolve7(next))));
     } else {
       pending.unshift(...linkParts(next));
     }
@@ -12045,7 +12100,7 @@ function rejectLinkedParent(cwd, rel) {
   }
 }
 function materialize(cwd, dest, dependencyRoot) {
-  const listed = git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
+  const listed = workingTreePaths(cwd);
   const links = [];
   for (const rel of listed) {
     const src = join18(cwd, rel);
@@ -12075,6 +12130,32 @@ function materialize(cwd, dest, dependencyRoot) {
   }
   if (dependencyRoot) symlinkSync(dependencyRoot, join18(dest, "node_modules"), "dir");
 }
+function workingTreePaths(cwd) {
+  return git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
+}
+function probeFilesystemCaseSensitivity(dir) {
+  const upper = join18(dir, ".tw-case-probe-A");
+  const lower = join18(dir, ".tw-case-probe-a");
+  try {
+    writeFileSync9(upper, "", { flag: "wx" });
+    return !existsSync13(lower);
+  } finally {
+    rmSync5(upper, { force: true });
+  }
+}
+function foldCase(p) {
+  return p.toLowerCase();
+}
+function caseFoldCollision(paths) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const key2 = foldCase(p);
+    const prior = seen.get(key2);
+    if (prior !== void 0 && prior !== p) return [prior, p];
+    if (prior === void 0) seen.set(key2, p);
+  }
+  return null;
+}
 function dropSymlink(p) {
   try {
     if (lstatSync9(p).isSymbolicLink()) rmSync5(p, { force: true });
@@ -12129,21 +12210,24 @@ function overlayDigest(dest, paths) {
   }
   return h.digest("hex");
 }
-function overlayPristine(cwd, base, dest, policy, cmd, dependencyRoot) {
+function overlayPristine(cwd, base, dest, policy, cmd, dependencyRoot, caseSensitive) {
   const entries = baseEntries(base, cwd);
   const atBase = entries.map((e) => e.path);
+  const fold = caseSensitive ? (p) => p : foldCase;
   const verifierGlobs = policy.verify?.inputs ?? [];
   const coveredBaseInputs = verifierCoveredInputs(cmd, atBase, policy);
-  const isOverlay = (p) => coveredBaseInputs.has(p) || // Candidate-added files do not exist in atBase and therefore cannot appear
+  const isOverlayExact = (p) => coveredBaseInputs.has(p) || // Candidate-added files do not exist in atBase and therefore cannot appear
   // in the precomputed set. They still must be removed when they land on a
   // protected class or the built-in verification surface.
   OVERLAY_CLASSES.some((category) => isProtected(p, policy, category)) || matchesAny(p, VERIFICATION_SURFACE) || verifierGlobs.length > 0 && matchesAny(p, verifierGlobs);
+  const coveredFolded = new Set(caseSensitive ? [] : [...coveredBaseInputs].map(foldCase));
+  const isOverlay = caseSensitive ? isOverlayExact : (p) => isOverlayExact(p) || isOverlayExact(foldCase(p)) || coveredFolded.has(foldCase(p));
   const restored = [];
   const restoredLinks = [];
   const baseProtected = /* @__PURE__ */ new Set();
   for (const e of entries) {
     if (!isOverlay(e.path)) continue;
-    baseProtected.add(e.path);
+    baseProtected.add(fold(e.path));
     if (e.type === "commit") {
       throw new Error(`the base's ${e.path} is a submodule; the pristine copy cannot reproduce it`);
     }
@@ -12162,9 +12246,9 @@ function overlayPristine(cwd, base, dest, policy, cmd, dependencyRoot) {
     restored.push(e.path);
   }
   let removed = 0;
-  const inCopy = git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
+  const inCopy = workingTreePaths(cwd);
   for (const rel of inCopy) {
-    if (!isOverlay(rel) || baseProtected.has(rel)) continue;
+    if (!isOverlay(rel) || baseProtected.has(fold(rel))) continue;
     rmSync5(join18(dest, rel), { force: true });
     removed++;
   }
@@ -12285,6 +12369,8 @@ function runVerify(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const out3 = opts.silent ? (_s) => {
   } : (s) => void process.stdout.write(s + "\n");
+  let filesystemCaseSensitive;
+  const caseReport = () => filesystemCaseSensitive === void 0 ? {} : { filesystem_case_sensitive: filesystemCaseSensitive };
   const cannotVerify = (reason, detail, extra = {}) => {
     opts.onVerdict?.({ verdict: "CANNOT_VERIFY", reason, ...detail ? { detail } : {} });
     if (opts.json) {
@@ -12293,6 +12379,7 @@ function runVerify(opts) {
         verdict: "CANNOT_VERIFY",
         reason,
         ...detail ? { detail } : {},
+        ...caseReport(),
         ...extra
       }));
     } else if (detail) {
@@ -12404,6 +12491,26 @@ function runVerify(opts) {
     if (opts.keep) return;
     for (const d of dirs) rmSync5(d, { recursive: true, force: true });
   };
+  filesystemCaseSensitive = (opts.probeCaseSensitivity ?? probeFilesystemCaseSensitivity)(visRoot);
+  if (!filesystemCaseSensitive) {
+    const present = (rel) => {
+      try {
+        lstatSync9(join18(cwd, rel));
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const collision = caseFoldCollision(workingTreePaths(cwd).filter(present)) ?? caseFoldCollision(baseEntries(base, cwd).map((e) => e.path));
+    if (collision) {
+      cleanup([visRoot]);
+      return cannotVerify(
+        "PATH_CASE_COLLISION",
+        `${collision[0]} and ${collision[1]} are distinct paths that the case-insensitive filesystem the copies are materialised on cannot tell apart; the copy could not be the tree under verification`,
+        { verifier_backend: backendReport(), dependency_environment: dependencyReport(), oracle_assurance: oracleAssuranceReport() }
+      );
+    }
+  }
   const protectedIgnored = (rel) => isProtected(rel, policy);
   const treeBefore = treeFingerprint(cwd, protectedIgnored);
   const dependencyAtEntry = dependencyEnvironment ? reuseDependencyEnvironmentAttestation(
@@ -12441,6 +12548,7 @@ function runVerify(opts) {
         verdict: "CANNOT_VERIFY",
         reason: exhausted ? "VERIFIER_RESOURCE_EXHAUSTED" : "VERIFIER_BACKEND_RUNTIME_FAILURE",
         stage: "visible",
+        ...caseReport(),
         ...visible.resource ? { resource: visible.resource } : {},
         detail: visible.reason,
         diagnostics: diagnosticsJson(visible.diagnostics, true),
@@ -12486,7 +12594,8 @@ function runVerify(opts) {
       priDir,
       policy,
       cmd,
-      frozenNodeModules
+      frozenNodeModules,
+      filesystemCaseSensitive
     ));
   } catch (e) {
     cleanup([visRoot, priRoot]);
@@ -12508,6 +12617,7 @@ function runVerify(opts) {
         verdict: "CANNOT_VERIFY",
         reason: exhausted ? "VERIFIER_RESOURCE_EXHAUSTED" : "VERIFIER_BACKEND_RUNTIME_FAILURE",
         stage: "pristine",
+        ...caseReport(),
         ...pristine.resource ? { resource: pristine.resource } : {},
         detail: pristine.reason,
         diagnostics: diagnosticsJson(pristine.diagnostics, true),
@@ -12572,6 +12682,7 @@ function runVerify(opts) {
         pristine: stageJson(pristine),
         protected_restored: restored.length,
         added_protected_removed: removedAdded,
+        filesystem_case_sensitive: filesystemCaseSensitive,
         verifier_backend: backendReport(),
         dependency_environment: dependencyReport(),
         oracle_assurance: oracleAssuranceReport(),
@@ -12745,9 +12856,9 @@ var init_verify = __esm({
 // src/cli/run.ts
 import { execFileSync as execFileSync9, spawn, spawnSync as spawnSync4 } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { accessSync as accessSync2, constants as fsConstants, mkdtempSync as mkdtempSync4, readdirSync as readdirSync4, readFileSync as readFileSync17, readlinkSync as readlinkSync4, realpathSync as realpathSync7, rmSync as rmSync6, statSync as statSync5, writeFileSync as writeFileSync10 } from "node:fs";
+import { accessSync as accessSync2, constants as fsConstants, mkdtempSync as mkdtempSync4, readdirSync as readdirSync4, readFileSync as readFileSync17, readlinkSync as readlinkSync4, realpathSync as realpathSync8, rmSync as rmSync6, statSync as statSync5, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { dirname as dirname8, join as join19, resolve as resolve7 } from "node:path";
+import { dirname as dirname8, join as join19, resolve as resolve8 } from "node:path";
 function authoritativeRunLifecyclePlatform(platform = process.platform) {
   return platform === "linux";
 }
@@ -12800,7 +12911,7 @@ function trustedLinuxPython(candidates = DEFAULT_TRUSTED_PYTHON_CANDIDATES) {
   }
   for (const candidate of candidates) {
     try {
-      const real = realpathSync7(candidate);
+      const real = realpathSync8(candidate);
       const st = statSync5(real);
       if (!st.isFile() || writableByCaller2(real)) continue;
       const probe = spawnSync4(
@@ -12966,7 +13077,7 @@ function startSupervisedObserver(cwd, base, entry) {
   try {
     child = spawn(
       process.execPath,
-      [resolve7(cliEntry), "watch", "--dir", cwd, "--log", log, "--base", base],
+      [resolve8(cliEntry), "watch", "--dir", cwd, "--log", log, "--base", base],
       {
         cwd,
         stdio: ["ignore", "ignore", "inherit"],
@@ -13074,7 +13185,7 @@ function survivorsHoldingTree(cwd, spawnedAfterTicks) {
   const out3 = [];
   let real;
   try {
-    real = realpathSync7(cwd);
+    real = realpathSync8(cwd);
   } catch {
     return out3;
   }
@@ -13103,7 +13214,7 @@ function survivorsHoldingTree(cwd, spawnedAfterTicks) {
     for (const link of procLinks) {
       try {
         const raw = readlinkSync4(link).replace(/ \(deleted\)$/, "");
-        const held = raw.startsWith("/") ? resolve7(raw) : raw;
+        const held = raw.startsWith("/") ? resolve8(raw) : raw;
         if (held === real || held.startsWith(real + "/")) {
           holds = true;
           break;
@@ -13116,7 +13227,7 @@ function survivorsHoldingTree(cwd, spawnedAfterTicks) {
   return out3;
 }
 function runEnvelope(opts) {
-  const cwd = resolve7(opts.cwd ?? process.cwd());
+  const cwd = resolve8(opts.cwd ?? process.cwd());
   const say = opts.json ? (_s) => {
   } : out;
   if (!opts.argv.length) {
@@ -13660,8 +13771,8 @@ raise SystemExit(0)
 
 // src/cli/doctor.ts
 import { execFileSync as execFileSync10 } from "node:child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync18, readdirSync as readdirSync5 } from "node:fs";
-import { join as join20, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync18, readdirSync as readdirSync5 } from "node:fs";
+import { join as join20, resolve as resolve9 } from "node:path";
 function lifecyclePlatformCheck(platform = process.platform, linuxPython = platform === "linux" ? trustedLinuxPython() : null) {
   if (platform === "linux") {
     if (linuxPython?.path) {
@@ -13716,7 +13827,7 @@ function wiringState(status, authority) {
   return authority ? "BROKEN" : "WARN";
 }
 function pinsInFile(path) {
-  if (!existsSync13(path)) return [];
+  if (!existsSync14(path)) return [];
   let src = "";
   try {
     src = readFileSync18(path, "utf8");
@@ -13739,8 +13850,8 @@ function workflowPermissionCheck(cwd, workflowRels = [".github/workflows/tamperw
   const broken = [];
   const warnings = [];
   for (const rel of workflowRels) {
-    const path = resolve8(cwd, rel);
-    if (!existsSync13(path)) {
+    const path = resolve9(cwd, rel);
+    if (!existsSync14(path)) {
       broken.push(`${rel} is missing`);
       continue;
     }
@@ -14086,7 +14197,7 @@ function verifyJobs(doc) {
   return found;
 }
 function diagnose(opts = {}) {
-  const cwd = resolve8(opts.cwd ?? process.cwd());
+  const cwd = repoRoot(resolve9(opts.cwd ?? process.cwd()));
   let policy;
   try {
     policy = policyFor(opts, cwd);
@@ -14110,8 +14221,8 @@ function diagnose(opts = {}) {
     workflowRels.push(opts.workflow);
   } else {
     const workflowDirRel = ".github/workflows";
-    const workflowDir = resolve8(cwd, workflowDirRel);
-    if (!existsSync13(workflowDir)) {
+    const workflowDir = resolve9(cwd, workflowDirRel);
+    if (!existsSync14(workflowDir)) {
       return fail("ci-verifier", `${workflowDirRel}: workflow directory does not exist`);
     }
     let entries;
@@ -14130,8 +14241,8 @@ function diagnose(opts = {}) {
   let verifyJobCount = 0;
   const authorityWorkflows = [];
   for (const workflowRel of workflowRels) {
-    const workflowPath = resolve8(cwd, workflowRel);
-    if (!existsSync13(workflowPath)) {
+    const workflowPath = resolve9(cwd, workflowRel);
+    if (!existsSync14(workflowPath)) {
       return fail("ci-verifier", `${workflowRel}: workflow does not exist`);
     }
     let doc;
@@ -14273,6 +14384,7 @@ var init_doctor = __esm({
     init_run();
     init_machine_output();
     init_narrow();
+    init_repo_context();
     VERIFY_COMMAND = /\btamperward(?:@\S+)?\s+verify\b/;
     GITHUB_API_SCRIPT = [
       "const endpoint = process.argv[1];",
@@ -14291,16 +14403,16 @@ var init_doctor = __esm({
 // src/cli/trace-verify.ts
 import { execFileSync as execFileSync11, spawnSync as spawnSync5 } from "node:child_process";
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   mkdtempSync as mkdtempSync5,
   readFileSync as readFileSync19,
   readdirSync as readdirSync6,
-  realpathSync as realpathSync8,
+  realpathSync as realpathSync9,
   rmSync as rmSync7,
   symlinkSync as symlinkSync2
 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
-import { isAbsolute as isAbsolute11, join as join21, relative as relative6, resolve as resolve9, sep as sep4 } from "node:path";
+import { isAbsolute as isAbsolute11, join as join21, relative as relative6, resolve as resolve10, sep as sep4 } 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, "\\");
 }
@@ -14325,13 +14437,13 @@ function parseStraceFileAccess(raw) {
   return out3;
 }
 function inside3(root, path) {
-  const rel = relative6(resolve9(root), resolve9(path));
+  const rel = relative6(resolve10(root), resolve10(path));
   return rel === "" || rel !== ".." && !rel.startsWith(`..${sep4}`) && !isAbsolute11(rel);
 }
 function normalRepoPath(root, raw) {
-  const abs2 = isAbsolute11(raw) ? resolve9(raw) : resolve9(root, raw);
-  if (!inside3(root, abs2)) return null;
-  const rel = relative6(root, abs2).split(sep4).join("/");
+  const abs = isAbsolute11(raw) ? resolve10(raw) : resolve10(root, raw);
+  if (!inside3(root, abs)) return null;
+  const rel = relative6(root, abs).split(sep4).join("/");
   return rel && rel !== ".." ? rel : null;
 }
 function likelyConfig(path) {
@@ -14349,7 +14461,7 @@ function summarizeTraceRuns(opts) {
     for (const item of run) {
       const rel = normalRepoPath(opts.root, item.path);
       const isTracked = rel !== null && opts.tracked.has(rel);
-      const keyPath = rel !== null ? opts.tracked.has(rel) ? rel : null : resolve9(opts.root, item.path);
+      const keyPath = rel !== null ? opts.tracked.has(rel) ? rel : null : resolve10(opts.root, item.path);
       if (keyPath === null) continue;
       const target = isTracked ? repo : external;
       const key2 = `${isTracked ? "repo" : "external"}\0${keyPath}`;
@@ -14428,22 +14540,22 @@ function materializeBase(base, cwd, dest) {
   }
   const hostModules = join21(cwd, "node_modules");
   const tracedModules = join21(dest, "node_modules");
-  if (existsSync14(hostModules) && !existsSync14(tracedModules)) {
-    symlinkSync2(resolve9(hostModules), tracedModules, "dir");
+  if (existsSync15(hostModules) && !existsSync15(tracedModules)) {
+    symlinkSync2(resolve10(hostModules), tracedModules, "dir");
   }
 }
 function traceFiles(prefix) {
-  const dir = resolve9(prefix, "..");
+  const dir = resolve10(prefix, "..");
   const base = prefix.split(sep4).at(-1) ?? prefix;
   return readdirSync6(dir).filter((name) => name === base || name.startsWith(base + ".")).map((name) => join21(dir, name)).sort();
 }
 function rewriteTraceRoot(accesses, actualRoot) {
   return accesses.map((item) => {
-    const abs2 = isAbsolute11(item.path) ? resolve9(item.path) : resolve9(actualRoot, item.path);
-    if (!inside3(actualRoot, abs2)) return { ...item, path: abs2 };
-    const rel = relative6(actualRoot, abs2).split(sep4).join("/");
+    const abs = isAbsolute11(item.path) ? resolve10(item.path) : resolve10(actualRoot, item.path);
+    if (!inside3(actualRoot, abs)) return { ...item, path: abs };
+    const rel = relative6(actualRoot, abs).split(sep4).join("/");
     try {
-      const real = resolve9(realpathSync8(abs2));
+      const real = resolve10(realpathSync9(abs));
       if (!inside3(actualRoot, real)) return { ...item, path: real };
     } catch {
     }
@@ -14532,7 +14644,7 @@ function renderText2(report2) {
   for (const note of report2.notes) out3(`note: ${note}`);
 }
 function runTraceVerify(opts = {}) {
-  const cwd = resolve9(opts.cwd ?? process.cwd());
+  const cwd = resolve10(opts.cwd ?? process.cwd());
   if (process.platform !== "linux") {
     process.stderr.write("tamperward trace-verify: Linux only in this release; unsupported platform \u2014 no parity is implied.\n");
     return 2;
@@ -14680,9 +14792,9 @@ var init_trace_verify = __esm({
 // src/cli/onboard.ts
 import { execFileSync as execFileSync12 } from "node:child_process";
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { lstatSync as lstatSync10, mkdtempSync as mkdtempSync6, readFileSync as readFileSync20, realpathSync as realpathSync9, renameSync as renameSync2, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
+import { lstatSync as lstatSync10, mkdtempSync as mkdtempSync6, readFileSync as readFileSync20, realpathSync as realpathSync10, renameSync as renameSync2, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
 import { tmpdir as tmpdir7 } from "node:os";
-import { join as join22, relative as relative7, resolve as resolve10, sep as sep5 } from "node:path";
+import { join as join22, relative as relative7, resolve as resolve11, sep as sep5 } from "node:path";
 import { createInterface } from "node:readline";
 import { parseDocument } from "yaml";
 function readlineAsker(input, output) {
@@ -14691,9 +14803,9 @@ function readlineAsker(input, output) {
   let pending = null;
   rl.on("close", () => {
     closed = true;
-    const resolve15 = pending;
+    const resolve16 = pending;
     pending = null;
-    resolve15?.(null);
+    resolve16?.(null);
   });
   rl.on("SIGINT", () => rl.close());
   const ask = (question) => new Promise((resolvePromise) => {
@@ -14719,7 +14831,7 @@ function terminalText(text) {
   return stripControl(text).replace(/\s+/g, " ").trim();
 }
 function committableSetupPath(cwd, path) {
-  const rel = relative7(cwd, resolve10(cwd, path));
+  const rel = relative7(cwd, resolve11(cwd, path));
   if (!rel || rel === ".." || rel.startsWith(".." + sep5)) return false;
   return rel !== ".git" && !rel.startsWith(".git" + sep5);
 }
@@ -14788,7 +14900,7 @@ function writeVerifyCommand(cwd, command) {
   }
 }
 async function runOnboard(opts, io = {}) {
-  const requestedCwd = resolve10(opts.cwd ?? process.cwd());
+  const requestedCwd = resolve11(opts.cwd ?? process.cwd());
   const out3 = io.out ?? ((line) => void process.stdout.write(line + "\n"));
   const rawErr = (line) => void process.stderr.write(terminalText(line) + "\n");
   const platform = io.platform ?? process.platform;
@@ -14824,10 +14936,10 @@ async function runOnboard(opts, io = {}) {
     fail(requestedCwd + " is not inside a Git repository. Run `git init` first.");
     return 2;
   }
-  const cwd = resolve10(rootText);
+  const cwd = resolve11(rootText);
   let sameRoot = cwd === requestedCwd;
   try {
-    sameRoot = realpathSync9(cwd) === realpathSync9(requestedCwd);
+    sameRoot = realpathSync10(cwd) === realpathSync10(requestedCwd);
   } catch {
   }
   if (!sameRoot) {
@@ -15160,8 +15272,8 @@ function runDemo(cwd, head, runners, out3) {
     let worktreeRoot;
     let realTarget;
     try {
-      worktreeRoot = realpathSync9(wt);
-      realTarget = realpathSync9(targetPath);
+      worktreeRoot = realpathSync10(wt);
+      realTarget = realpathSync10(targetPath);
     } catch {
       out3("Demo skipped: the selected test could not be resolved safely inside the disposable worktree.");
       return;
@@ -15235,7 +15347,7 @@ var init_onboard = __esm({
 });
 
 // src/research/adapter.ts
-import { isAbsolute as isAbsolute12, resolve as resolve11 } from "node:path";
+import { isAbsolute as isAbsolute12, resolve as resolve12 } from "node:path";
 function taskEnv(task) {
   return {
     TAMPERWARD_RESEARCH_TASK: task.id,
@@ -15251,7 +15363,7 @@ function normalizeCommandArgv(argv, cwd = process.cwd()) {
     throw new ResearchError('the command adapter needs an agent command after "--"');
   }
   const head = argv[0];
-  return head.includes("/") && !isAbsolute12(head) ? [resolve11(cwd, head), ...argv.slice(1)] : [...argv];
+  return head.includes("/") && !isAbsolute12(head) ? [resolve12(cwd, head), ...argv.slice(1)] : [...argv];
 }
 function commandAdapter(argv, cwd = process.cwd()) {
   const anchored = normalizeCommandArgv(argv, cwd);
@@ -15352,7 +15464,7 @@ var init_capture = __esm({
 // src/research/manifest.ts
 import { createHash as createHash12 } from "node:crypto";
 import { readFileSync as readFileSync21 } from "node:fs";
-import { dirname as dirname9, resolve as resolve12 } from "node:path";
+import { dirname as dirname9, resolve as resolve13 } 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`);
@@ -15375,40 +15487,40 @@ function taskFrom(raw, index, manifestDir) {
   const isUrl = /^[a-z][a-z0-9+.-]*:\/\//i.test(repo) || /^[^/]+@[^:]+:/.test(repo);
   return {
     id,
-    repo: isUrl ? repo : resolve12(manifestDir, repo),
+    repo: isUrl ? repo : resolve13(manifestDir, repo),
     base: base ?? "HEAD",
     prompt,
     verify: { command: verify.command, ...budget !== void 0 ? { budget } : {} }
   };
 }
 function readManifest(path) {
-  const abs2 = resolve12(path);
+  const abs = resolve13(path);
   let bytes;
   try {
-    bytes = readFileSync21(abs2);
+    bytes = readFileSync21(abs);
   } catch (e) {
-    throw new ResearchError(`cannot read task manifest ${abs2}: ${e instanceof Error ? e.message : String(e)}`);
+    throw new ResearchError(`cannot read task manifest ${abs}: ${e instanceof Error ? e.message : String(e)}`);
   }
   let raw;
   try {
     raw = JSON.parse(bytes.toString("utf8"));
   } catch {
-    throw new ResearchError(`task manifest ${abs2} is not valid JSON`);
+    throw new ResearchError(`task manifest ${abs} is not valid JSON`);
   }
-  if (!isRecord(raw)) throw new ResearchError(`task manifest ${abs2}: top level must be an object`);
+  if (!isRecord(raw)) throw new ResearchError(`task manifest ${abs}: top level must be an object`);
   if (raw.version !== MANIFEST_VERSION) {
-    throw new ResearchError(`task manifest ${abs2}: version must be ${MANIFEST_VERSION} (got ${JSON.stringify(raw.version)})`);
+    throw new ResearchError(`task manifest ${abs}: version must be ${MANIFEST_VERSION} (got ${JSON.stringify(raw.version)})`);
   }
   if (!Array.isArray(raw.tasks) || raw.tasks.length === 0) {
-    throw new ResearchError(`task manifest ${abs2}: no tasks (tasks must be a non-empty array)`);
+    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, dirname9(abs2)));
+  const tasks = raw.tasks.map((t, i) => taskFrom(t, i, dirname9(abs)));
   const seen = /* @__PURE__ */ new Set();
   for (const t of tasks) {
-    if (seen.has(t.id)) throw new ResearchError(`task manifest ${abs2}: duplicate task id "${t.id}"`);
+    if (seen.has(t.id)) throw new ResearchError(`task manifest ${abs}: duplicate task id "${t.id}"`);
     seen.add(t.id);
   }
-  return { path: abs2, sha256: createHash12("sha256").update(bytes).digest("hex"), tasks };
+  return { path: abs, sha256: createHash12("sha256").update(bytes).digest("hex"), tasks };
 }
 var MANIFEST_VERSION;
 var init_manifest = __esm({
@@ -15597,8 +15709,8 @@ var init_record = __esm({
 
 // src/research/run.ts
 import { execFileSync as execFileSync13 } from "node:child_process";
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync22, renameSync as renameSync3, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join23, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync22, renameSync as renameSync3, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join23, resolve as resolve14 } from "node:path";
 function git6(args, cwd) {
   return execFileSync13("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
 }
@@ -15661,9 +15773,9 @@ function freshWorkspace(ledger, task, pair, arm, sourceBase) {
   git6(["config", "user.email", "research@tamperward.invalid"], ws2);
   const requestedBase = sourceBase ?? task.base;
   const candidates = sourceBase !== void 0 ? [sourceBase] : task.base === "HEAD" ? ["HEAD"] : [task.base, `origin/${task.base}`];
-  for (const rev of candidates) {
+  for (const rev2 of candidates) {
     try {
-      git6(["checkout", "-q", "--detach", rev], ws2);
+      git6(["checkout", "-q", "--detach", rev2], ws2);
       return ws2;
     } catch {
     }
@@ -15897,7 +16009,7 @@ function runResearch(opts) {
     err2("tamperward research: the gated arm cannot start here (see `tamperward doctor`); run as a non-root user on Linux.");
     return 2;
   }
-  const ledger = resolve13(opts.out);
+  const ledger = resolve14(opts.out);
   const pairs = opts.pairs ?? 1;
   mkdirSync8(join23(ledger, "pairs"), { recursive: true });
   for (const task of tasks) {
@@ -15906,7 +16018,7 @@ function runResearch(opts) {
     try {
       for (let pair = 1; pair <= pairs; pair++) {
         const path = pairRecordPath(ledger, task.id, pair);
-        if (!existsSync15(path)) continue;
+        if (!existsSync16(path)) continue;
         const existing = resumableRecord(path, {
           task: task.id,
           pair,
@@ -16032,9 +16144,9 @@ var init_run2 = __esm({
 
 // src/research/summarize.ts
 import { readdirSync as readdirSync7, readFileSync as readFileSync23 } from "node:fs";
-import { join as join24, resolve as resolve14 } from "node:path";
+import { join as join24, resolve as resolve15 } from "node:path";
 function readLedger2(dir) {
-  const pairsDir = join24(resolve14(dir), "pairs");
+  const pairsDir = join24(resolve15(dir), "pairs");
   let names;
   try {
     names = readdirSync7(pairsDir).filter((n) => n.endsWith(".json")).sort();