tamperward 2.3.0 → 2.4.0

package/dist/cli/index.js

@@ -202,6 +202,27 @@ function parseHunk(lines, start) {
   return { hunk: { oldStart, oldLines, newStart, newLines, lines: out2 }, next: i };
 }
 
+// src/diff/synth.ts
+function linesOf(content) {
+  if (content === "") return [];
+  const lines = content.split("\n");
+  if (content.endsWith("\n")) lines.pop();
+  return lines;
+}
+function addHunks(content) {
+  const lines = linesOf(content);
+  if (lines.length === 0) return [];
+  return [
+    {
+      oldStart: 0,
+      oldLines: 0,
+      newStart: 1,
+      newLines: lines.length,
+      lines: lines.map((l, i) => ({ type: "add", content: l, oldLine: null, newLine: i + 1 }))
+    }
+  ];
+}
+
 // src/git/build.ts
 function git(args, cwd) {
   try {
@@ -256,6 +277,9 @@ function mergeBaseOf(base, head, opts = {}) {
 function fileAt(rev, path, opts = {}) {
   return blobAt(rev, path, opts.cwd);
 }
+function fileOnDisk(path, opts = {}) {
+  return fromDisk(path, opts.cwd);
+}
 function isGitRepo(cwd) {
   try {
     git(["rev-parse", "--git-dir"], cwd);
@@ -306,18 +330,35 @@ function diffWorktree(opts = {}) {
     (c) => enrich(c, (p) => blobAt("HEAD", p, opts.cwd), (p) => fromDisk(p, opts.cwd))
   );
 }
+function untrackedAdds(opts = {}, keep, exclude) {
+  const others = git(["ls-files", "--others", "--exclude-standard", "-z"], opts.cwd).split("\0").filter(Boolean);
+  return others.filter((rel) => !exclude?.has(rel) && (!keep || keep(rel))).map((rel) => {
+    const after = fromDisk(rel, opts.cwd);
+    return {
+      kind: "file",
+      path: rel,
+      oldPath: null,
+      op: "add",
+      before: null,
+      after,
+      binary: false,
+      hunks: after == null ? [] : addHunks(after)
+    };
+  });
+}
 function diffWorktreeWithUntracked(opts = {}) {
   const tracked = diffWorktree(opts);
-  const others = git(["ls-files", "--others", "--exclude-standard", "-z"], opts.cwd).split("\0").filter(Boolean);
   const seen = new Set(tracked.filter((c) => c.kind === "file").map((c) => c.path));
-  const untracked = others.filter((rel) => !seen.has(rel)).map(
-    (rel) => enrich(
-      { kind: "file", path: rel, oldPath: null, op: "add", before: null, after: null, binary: false, hunks: [] },
-      () => null,
-      (p) => fromDisk(p, opts.cwd)
-    )
-  );
-  return [...tracked, ...untracked];
+  return [...tracked, ...untrackedAdds(opts, void 0, seen)];
+}
+function hiddenTrackedPaths(opts = {}) {
+  const out2 = [];
+  for (const entry of git(["ls-files", "-v", "-z"], opts.cwd).split("\0")) {
+    if (entry.length < 3 || entry[1] !== " ") continue;
+    const tag = entry[0];
+    if (tag === "S" || tag !== tag.toUpperCase()) out2.push(entry.slice(2));
+  }
+  return out2;
 }
 
 // src/detectors/finding.ts
@@ -947,8 +988,20 @@ var PATTERNS2 = {
   py: [
     // `import pytest as pt` makes the decorator `@pt.mark.skip`; the module alias is free.
     { re: /@\w+\.mark\.(?:skip|skipif|xfail)\b/, why: "a pytest skip/skipif/xfail marker" },
+    // `from pytest import mark` makes it `@mark.skip`; `marks=pytest.mark.skip` is the
+    // parametrize form. Both carry the same marker without the `@<module>.` shape.
+    { re: /@mark\.(?:skip|skipif|xfail)\b/, why: "a pytest skip/skipif/xfail marker (from pytest import mark)" },
+    { re: /\bmarks\s*=\s*(?:\w+\.)?mark\.(?:skip|skipif|xfail)\b/, why: "a parametrize marks= skip/skipif/xfail marker" },
     { re: /\bpytestmark\s*=.*\.mark\.(?:skip|skipif|xfail)\b/, why: "a module-level pytestmark skip (every test in the file is skipped)" },
-    { re: /\bpytest\.(?:skip|xfail|importorskip)\(/, why: "a runtime pytest.skip()/xfail() call" },
+    { re: /\bpytest\.(?:skip|xfail|importorskip)\(/, why: "a runtime pytest.skip()/xfail()/importorskip() call" },
+    // Collection-time drops. A conftest.py is protected as a test file, and these
+    // are how pytest is told never to collect a test in the first place — no
+    // marker ever appears in the test itself. `collect_ignore` / `collect_ignore_glob`
+    // are conftest globals (pytest docs, "Customizing test collection");
+    // `pytest_ignore_collect` is the hook whose only job is to say "skip this path";
+    // `__test__ = False` de-collects a class or function.
+    { re: /\bcollect_ignore(?:_glob)?\s*(?:=|\+=|\.(?:append|extend)\()/, why: "a collect_ignore / collect_ignore_glob entry (the files are never collected)" },
+    { re: /\bdef\s+pytest_ignore_collect\s*\(/, why: "a pytest_ignore_collect hook (paths are dropped at collection)" },
     // `from unittest import skip` makes the decorator bare `@skip`.
     { re: /@(?:unittest\.)?(?:skip|skipIf|skipUnless|expectedFailure)\b/, why: "a unittest skip/expectedFailure decorator" },
     { re: /\bself\.skipTest\(/, why: "a runtime self.skipTest() call" },
@@ -1162,12 +1215,12 @@ var coverageLowering = {
         );
       }
       for (const l of added) {
-        if (/--passWithNoTests\b/.test(l.content)) {
+        if (/--passWithNoTests\b/.test(l.content) || /\bpassWithNoTests\s*:\s*true\b/.test(l.content)) {
           out2.push(
             makeFinding(RULE4, policy, {
               file: c.path,
               line: l.newLine ?? void 0,
-              message: "--passWithNoTests added \u2014 the suite can now pass with zero tests.",
+              message: "passWithNoTests added \u2014 the suite can now pass with zero tests.",
               evidence: l.content.trim(),
               remediation: "Remove --passWithNoTests; an empty suite must not be a green check."
             })
@@ -2476,6 +2529,7 @@ function runCheck(opts) {
 // src/cli/hook.ts
 import { readFileSync as readFileSync9, appendFileSync as appendFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync6, statSync as statSync4 } from "node:fs";
 import { createHash as createHash4 } from "node:crypto";
+import { join as join8 } from "node:path";
 
 // src/adapters/claude/changes.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
@@ -2658,14 +2712,23 @@ function gitDir2(cwd) {
     return null;
   }
 }
-function ptreePath(cwd, sessionId) {
+function statePath(cwd, sessionId, kind) {
   if (!sessionId) return null;
   const gd = gitDir2(cwd);
   if (!gd) return null;
   const dir = join6(gd, "tamperward");
-  return join6(dir, `ptree-${sessionId.replace(UNSAFE2, "")}.json`);
+  return join6(dir, `${kind}-${sessionId.replace(UNSAFE2, "")}.json`);
+}
+function ptreePath(cwd, sessionId) {
+  return statePath(cwd, sessionId, "ptree");
+}
+function turnTreePath(cwd, sessionId) {
+  return statePath(cwd, sessionId, "turntree");
 }
 var sha = (buf) => createHash2("sha256").update(buf).digest("hex").slice(0, 16);
+function contentHash(content) {
+  return sha(Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8"));
+}
 function snapshotProtected(cwd, policy, prev) {
   const out2 = {};
   const walk = (rel) => {
@@ -2710,8 +2773,7 @@ function driftBetween(expected, current) {
   }
   return { changed, deleted };
 }
-function loadPtree(cwd, sessionId) {
-  const p = ptreePath(cwd, sessionId);
+function loadTree(p) {
   if (!p || !existsSync5(p)) return null;
   try {
     return JSON.parse(readFileSync6(p, "utf8"));
@@ -2719,8 +2781,7 @@ function loadPtree(cwd, sessionId) {
     return null;
   }
 }
-function savePtree(cwd, sessionId, tree) {
-  const p = ptreePath(cwd, sessionId);
+function saveTree(p, tree) {
   if (!p) return;
   try {
     mkdirSync3(join6(p, ".."), { recursive: true });
@@ -2728,6 +2789,18 @@ function savePtree(cwd, sessionId, tree) {
   } catch {
   }
 }
+function loadPtree(cwd, sessionId) {
+  return loadTree(ptreePath(cwd, sessionId));
+}
+function savePtree(cwd, sessionId, tree) {
+  saveTree(ptreePath(cwd, sessionId), tree);
+}
+function loadTurnTree(cwd, sessionId) {
+  return loadTree(turnTreePath(cwd, sessionId));
+}
+function saveTurnTree(cwd, sessionId, tree) {
+  saveTree(turnTreePath(cwd, sessionId), tree);
+}
 
 // src/cli/watch.ts
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2, watch } from "node:fs";
@@ -2951,12 +3024,107 @@ function verdict(blocks, kind) {
   } : { decision: "block", reason };
   return { exitCode: 0, stdout: JSON.stringify(payload) + "\n" };
 }
+function fileChanges(changes) {
+  return changes.filter((c) => c.kind === "file");
+}
+function hashOnDisk(cwd, rel) {
+  try {
+    return contentHash(readFileSync9(join8(cwd, rel)));
+  } catch {
+    return null;
+  }
+}
+function gitMode(mode) {
+  return (mode & 64) !== 0 ? "100755" : "100644";
+}
+function turnView(cwd, sessionId, policy, base) {
+  const tracked = base ? diffSince(base, { cwd }) : diffWorktree({ cwd });
+  const seen = /* @__PURE__ */ new Set();
+  for (const c of fileChanges(tracked)) {
+    seen.add(c.path);
+    if (c.oldPath) seen.add(c.oldPath);
+  }
+  const turnTree = loadTurnTree(cwd, sessionId);
+  const untracked = untrackedAdds({ cwd }, (rel) => isProtected(rel, policy), seen).filter(
+    (c) => c.kind !== "file" || !turnTree || turnTree[c.path]?.hash !== hashOnDisk(cwd, c.path)
+  );
+  for (const c of fileChanges(untracked)) seen.add(c.path);
+  const trusted = base ?? "HEAD";
+  const hidden = [];
+  for (const rel of hiddenTrackedPaths({ cwd })) {
+    if (seen.has(rel) || !isProtected(rel, policy)) continue;
+    hidden.push(...synthFileChange(rel, fileAt(trusted, rel, { cwd }), fileOnDisk(rel, { cwd })));
+  }
+  return [...tracked, ...untracked, ...hidden];
+}
+function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree) {
+  const d = driftBetween(expected, current);
+  const seen = /* @__PURE__ */ new Set();
+  for (const c of fileChanges(covered)) {
+    seen.add(c.path);
+    if (c.oldPath) seen.add(c.oldPath);
+  }
+  const changes = [];
+  const blocks = [];
+  const trusted = base ?? "HEAD";
+  const candidates = base ? [base, "HEAD", ""] : ["HEAD", ""];
+  for (const rel of [...d.changed, ...d.deleted]) {
+    if (seen.has(rel)) continue;
+    const after = fileOnDisk(rel, { cwd });
+    const trustedBlob = fileAt(trusted, rel, { cwd });
+    const atGitState = after != null && trustedBlob != null && contentHash(after) === contentHash(trustedBlob);
+    const atTurnStart = current[rel] != null && turnTree?.[rel]?.hash === current[rel].hash;
+    if ((atGitState || atTurnStart) && current[rel] && expected[rel] && current[rel].mode === expected[rel].mode) {
+      continue;
+    }
+    const want = expected[rel]?.hash;
+    let before = null;
+    for (const rev of candidates) {
+      const blob = fileAt(rev, rel, { cwd });
+      if (blob != null && contentHash(blob) === want) {
+        before = blob;
+        break;
+      }
+    }
+    if (before == null) {
+      blocks.push({
+        rule: "hidden-drift",
+        severity: "block",
+        file: rel,
+        message: `Protected file ${rel} changed outside git's view, and its sanctioned content cannot be reconstructed to judge the change.`,
+        evidence: rel,
+        remediation: "Restore the file to its last sanctioned content (git restore, or undo the edit) and bring it back into git's view (git update-index --no-skip-worktree / --no-assume-unchanged); make the change through a tool call the gate can see.",
+        signoff: { required: true, command: `tamperward allow hidden-drift --file ${rel} --reason "..."` }
+      });
+      continue;
+    }
+    const synth = synthFileChange(rel, before, after);
+    if (synth.length > 0) {
+      changes.push(...synth);
+    } else if (after != null && current[rel] && expected[rel] && current[rel].mode !== expected[rel].mode) {
+      changes.push({
+        kind: "file",
+        path: rel,
+        oldPath: null,
+        op: "modify",
+        before,
+        after,
+        binary: false,
+        hunks: [],
+        oldMode: gitMode(expected[rel].mode),
+        newMode: gitMode(current[rel].mode)
+      });
+    }
+  }
+  return { changes, blocks };
+}
 function effectDriftBlocks(cwd, sessionId, policy) {
   if (!sessionId || !isGitRepo(cwd)) return null;
   const expected = loadPtree(cwd, sessionId);
   const current = snapshotProtected(cwd, policy, expected ?? void 0);
   if (!expected) {
     savePtree(cwd, sessionId, current);
+    if (!loadTurnTree(cwd, sessionId)) saveTurnTree(cwd, sessionId, current);
     return null;
   }
   const d = driftBetween(expected, current);
@@ -2965,12 +3133,13 @@ function effectDriftBlocks(cwd, sessionId, policy) {
     return null;
   }
   const base = turnBaseline(cwd, sessionId);
-  const all = base ? diffSince(base, { cwd }) : diffWorktree({ cwd });
+  const all = turnView(cwd, sessionId, policy, base);
   const drifted = /* @__PURE__ */ new Set([...d.changed, ...d.deleted]);
   const scoped = all.filter(
     (c) => c.kind === "file" && (drifted.has(c.path) || c.oldPath != null && drifted.has(c.oldPath))
   );
-  const blocks = evaluate(scoped, policy, void 0, "turn").filter((f) => f.severity === "block");
+  const gap = uncoveredDrift(cwd, policy, expected, current, scoped, base, loadTurnTree(cwd, sessionId));
+  const blocks = evaluate([...scoped, ...gap.changes], policy, void 0, "turn").filter((f) => f.severity === "block").concat(gap.blocks);
   if (blocks.length > 0) return blocks;
   savePtree(cwd, sessionId, current);
   return null;
@@ -3071,13 +3240,22 @@ function stopVerdict(input) {
   try {
     const policy = loadPolicy(cwd);
     const base = turnBaseline(cwd, input.session_id);
-    const changes = base ? diffSince(base, { cwd }) : diffWorktree({ cwd });
-    blocks = evaluate(changes, policy, void 0, "turn").filter((f) => f.severity === "block");
+    let changes = turnView(cwd, input.session_id, policy, base);
+    const expected = loadPtree(cwd, input.session_id);
+    const current = input.session_id ? snapshotProtected(cwd, policy, expected ?? void 0) : null;
+    let hiddenBlocks = [];
+    if (expected && current) {
+      const gap = uncoveredDrift(cwd, policy, expected, current, changes, base, loadTurnTree(cwd, input.session_id));
+      changes = changes.concat(gap.changes);
+      hiddenBlocks = gap.blocks;
+    }
+    blocks = evaluate(changes, policy, void 0, "turn").filter((f) => f.severity === "block").concat(hiddenBlocks);
     const transient = turnTransientBlocks(cwd, input.session_id, policy, changes);
     blocks = blocks.concat(transient.blocks);
     commitCursor = transient.commit;
-    if (blocks.length === 0 && input.session_id) {
-      savePtree(cwd, input.session_id, snapshotProtected(cwd, policy, loadPtree(cwd, input.session_id) ?? void 0));
+    if (blocks.length === 0 && input.session_id && current) {
+      savePtree(cwd, input.session_id, current);
+      saveTurnTree(cwd, input.session_id, current);
     }
   } catch (e) {
     return failClosed("Stop", errText(e));
@@ -3171,7 +3349,7 @@ Honored at LOCAL pre-commit only. The agent-layer hook ignores this file; CI req
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
 import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync5, chmodSync, statSync as statSync5 } from "node:fs";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute4, join as join8, relative as relative2, resolve as resolve2 } from "node:path";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute4, join as join9, relative as relative2, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var errText2 = (e) => (e instanceof Error ? e.message : String(e)).replace(/\s+/g, " ").trim();
 var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -3236,7 +3414,7 @@ function shippedVersion() {
     const here = dirname3(fileURLToPath(import.meta.url));
     for (const rel of ["../package.json", "../../package.json", "../../../package.json"]) {
       try {
-        const pkg = JSON.parse(readFileSync10(join8(here, rel), "utf8"));
+        const pkg = JSON.parse(readFileSync10(join9(here, rel), "utf8"));
         if (pkg.name === "tamperward" && pkg.version) return pkg.version;
       } catch {
       }
@@ -3369,7 +3547,7 @@ function hooksShapeError(hooks) {
   return null;
 }
 function planPolicy(cwd) {
-  const path = join8(cwd, POLICY_FILE);
+  const path = join9(cwd, POLICY_FILE);
   if (existsSync7(path)) {
     try {
       loadPolicy(cwd);
@@ -3388,7 +3566,7 @@ function planPolicy(cwd) {
 }
 function planClaudeHooks(cwd) {
   const rel = ".claude/settings.json";
-  const path = join8(cwd, rel);
+  const path = join9(cwd, rel);
   let settings = {};
   if (existsSync7(path)) {
     let parsed;
@@ -3486,7 +3664,7 @@ function hooksDir(cwd) {
     if (out2) return resolve2(cwd, out2);
   } catch {
   }
-  return existsSync7(join8(cwd, ".git")) ? join8(cwd, ".git", "hooks") : null;
+  return existsSync7(join9(cwd, ".git")) ? join9(cwd, ".git", "hooks") : null;
 }
 function display(cwd, path) {
   const rel = relative2(cwd, path);
@@ -3513,23 +3691,23 @@ function planPreCommit(cwd) {
   const skip = (detail) => ({ item: "pre-commit", path: "(none)", status: "skip", detail });
   let path;
   let note;
-  if (existsSync7(join8(cwd, ".husky"))) {
-    path = join8(cwd, ".husky", "pre-commit");
+  if (existsSync7(join9(cwd, ".husky"))) {
+    path = join9(cwd, ".husky", "pre-commit");
     note = "husky";
   } else {
-    const managed = MANAGED_HOOKS.find((m) => m.configs.some((c) => existsSync7(join8(cwd, c))));
+    const managed = MANAGED_HOOKS.find((m) => m.configs.some((c) => existsSync7(join9(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}`);
     }
     const dir = hooksDir(cwd);
     if (!dir) return skip("not a git repo and no .husky/ \u2014 nothing to wire");
     if (basename(dir) === "_" && basename(dirname3(dir)) === ".husky") {
-      path = join8(dirname3(dir), "pre-commit");
+      path = join9(dirname3(dir), "pre-commit");
       note = "husky";
     } else {
-      path = join8(dir, "pre-commit");
+      path = join9(dir, "pre-commit");
       const rel2 = display(cwd, dir);
-      note = rel2 === join8(".git", "hooks") ? "plain git hook (local-only: .git/hooks is not committed \u2014 consider husky to share it)" : `git hooks directory ${rel2} (core.hooksPath)`;
+      note = rel2 === join9(".git", "hooks") ? "plain git hook (local-only: .git/hooks is not committed \u2014 consider husky to share it)" : `git hooks directory ${rel2} (core.hooksPath)`;
     }
   }
   const rel = display(cwd, path);
@@ -3625,9 +3803,9 @@ ${block.join("\n")}
 function planCodeowners(cwd) {
   const rel = ".github/CODEOWNERS";
   const existingRel = [".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"].find(
-    (r) => existsSync7(join8(cwd, r))
+    (r) => existsSync7(join9(cwd, r))
   );
-  const path = join8(cwd, existingRel ?? rel);
+  const path = join9(cwd, existingRel ?? rel);
   const existing = existingRel ? readFileSync10(path, "utf8") : null;
   const missing = CODEOWNERS_PATHS.filter((p) => existing === null || !coveredBy(existing, p));
   if (missing.length === 0) {
@@ -3661,7 +3839,7 @@ ${CODEOWNERS_MARK}
 }
 function planWorkflow(cwd, force) {
   const rel = ".github/workflows/tamperward.yml";
-  const path = join8(cwd, rel);
+  const path = join9(cwd, rel);
   const write = () => {
     mkdirSync5(dirname3(path), { recursive: true });
     writeFileSync5(path, workflowFile(WORKFLOW_CONTENT));
@@ -3778,13 +3956,13 @@ import { execFileSync as execFileSync7, spawnSync } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
 import { chmodSync as chmodSync2, cpSync, lstatSync, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync2, readFileSync as readFileSync13, readlinkSync as readlinkSync2, rmSync as rmSync2, statSync as statSync7, symlinkSync, writeFileSync as writeFileSync6, existsSync as existsSync9 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname4, join as join11, resolve as resolve3 } from "node:path";
+import { dirname as dirname4, join as join12, resolve as resolve3 } from "node:path";
 
 // src/git/trusted.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync8, readFileSync as readFileSync11 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join9 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join10 } from "node:path";
 function trustedGitEnv() {
   return { ...process.env, GIT_NO_REPLACE_OBJECTS: "1" };
 }
@@ -3797,7 +3975,7 @@ function gitDirOf(cwd) {
       env: trustedGitEnv()
     }).trim();
     if (!d) return null;
-    return isAbsolute5(d) ? d : join9(cwd, d);
+    return isAbsolute5(d) ? d : join10(cwd, d);
   } catch {
     return null;
   }
@@ -3822,7 +4000,7 @@ function objectRewriteState(cwd) {
       parts.push(`${rel}:<no-git-dir>`);
       continue;
     }
-    const p = join9(dir, rel);
+    const p = join10(dir, rel);
     try {
       parts.push(`${rel}:` + (existsSync8(p) ? readFileSync11(p, "utf8").trim() : ""));
     } catch {
@@ -3836,7 +4014,7 @@ function objectRewriteState(cwd) {
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
 import { readdirSync as readdirSync3, readFileSync as readFileSync12, readlinkSync, statSync as statSync6 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function treeFingerprint(cwd) {
   const files = execFileSync6("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd,
@@ -3849,7 +4027,7 @@ function treeFingerprint(cwd) {
     h.update(rel);
     h.update("\0");
     try {
-      h.update(readFileSync12(join10(cwd, rel)));
+      h.update(readFileSync12(join11(cwd, rel)));
     } catch {
       h.update("<unreadable>");
     }
@@ -3858,7 +4036,7 @@ function treeFingerprint(cwd) {
   return h.digest("hex");
 }
 function depsFingerprint(cwd) {
-  const root = join10(cwd, "node_modules");
+  const root = join11(cwd, "node_modules");
   const h = createHash7("sha256");
   const walk = (dir) => {
     let entries;
@@ -3868,7 +4046,7 @@ function depsFingerprint(cwd) {
       return;
     }
     for (const e of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-      const p = join10(dir, e.name);
+      const p = join11(dir, e.name);
       if (e.isDirectory()) walk(p);
       else if (e.isFile()) {
         h.update(p);
@@ -3988,7 +4166,7 @@ function baseIsAncestorOfHead(base, cwd) {
 function materialize(cwd, dest) {
   const listed = git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
   for (const rel of listed) {
-    const src = join11(cwd, rel);
+    const src = join12(cwd, rel);
     let st;
     try {
       st = statSync7(src);
@@ -3996,7 +4174,7 @@ function materialize(cwd, dest) {
       continue;
     }
     if (!st.isFile()) continue;
-    const out2 = join11(dest, rel);
+    const out2 = join12(dest, rel);
     mkdirSync6(dirname4(out2), { recursive: true });
     dropSymlink(out2);
     if (lstatSync(src).isSymbolicLink()) {
@@ -4007,7 +4185,7 @@ function materialize(cwd, dest) {
     chmodSync2(out2, st.mode);
   }
   const nm = resolve3(cwd, "node_modules");
-  if (existsSync9(nm)) symlinkSync(nm, join11(dest, "node_modules"), "dir");
+  if (existsSync9(nm)) symlinkSync(nm, join12(dest, "node_modules"), "dir");
 }
 function dropSymlink(p) {
   try {
@@ -4040,7 +4218,7 @@ function overlayDigest(dest, paths) {
   for (const rel of [...paths].sort()) {
     h.update(rel);
     h.update("\0");
-    const p = join11(dest, rel);
+    const p = join12(dest, rel);
     try {
       const st = lstatSync(p);
       h.update(String(st.mode));
@@ -4067,7 +4245,7 @@ function overlayPristine(cwd, base, dest, policy, cmd) {
       throw new Error(`the base's ${e.path} is a submodule; the pristine copy cannot reproduce it`);
     }
     const content = execFileSync7("git", ["show", `${base}:${e.path}`], { cwd, maxBuffer: 1 << 28, env: trustedGitEnv() });
-    const out2 = join11(dest, e.path);
+    const out2 = join12(dest, e.path);
     mkdirSync6(dirname4(out2), { recursive: true });
     rmSync2(out2, { force: true });
     if (e.mode === "120000") {
@@ -4082,7 +4260,7 @@ function overlayPristine(cwd, base, dest, policy, cmd) {
   const inCopy = git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
   for (const rel of inCopy) {
     if (!isOverlay(rel) || baseProtected.has(rel)) continue;
-    rmSync2(join11(dest, rel), { force: true });
+    rmSync2(join12(dest, rel), { force: true });
     removed++;
   }
   return { restored, removed };
@@ -4124,8 +4302,8 @@ function suiteEnv(scratch) {
     if (DROPPED_ENV.has(k) || PINNED_NPM.test(k)) continue;
     env[k] = v;
   }
-  const userRc = join11(scratch, "npmrc-user");
-  const globalRc = join11(scratch, "npmrc-global");
+  const userRc = join12(scratch, "npmrc-user");
+  const globalRc = join12(scratch, "npmrc-global");
   for (const f of [userRc, globalRc]) writeFileSync6(f, "", { mode: 292 });
   env.npm_config_userconfig = userRc;
   env.npm_config_globalconfig = globalRc;
@@ -4135,8 +4313,8 @@ function suiteEnv(scratch) {
 }
 function runSuite(dir, cmd, budgetSecs) {
   const t0 = Date.now();
-  const outDir = mkdtempSync2(join11(tmpdir2(), "tw-verify-run-"));
-  const outFile = join11(outDir, "result.json");
+  const outDir = mkdtempSync2(join12(tmpdir2(), "tw-verify-run-"));
+  const outFile = join12(outDir, "result.json");
   try {
     spawnSync(process.execPath, ["-e", SUPERVISOR, cmd, String(budgetSecs * 1e3), outFile], {
       cwd: dir,
@@ -4200,8 +4378,8 @@ function runVerify(opts) {
     out2(`verify: cannot resolve base rev "${opts.base ?? "HEAD"}" \u2014 failing closed`);
     return 2;
   }
-  const visRoot = mkdtempSync2(join11(tmpdir2(), "tw-verify-vis-"));
-  const visDir = join11(visRoot, "t");
+  const visRoot = mkdtempSync2(join12(tmpdir2(), "tw-verify-vis-"));
+  const visDir = join12(visRoot, "t");
   const cleanup = (dirs) => {
     if (opts.keep) return;
     for (const d of dirs) rmSync2(d, { recursive: true, force: true });
@@ -4229,8 +4407,8 @@ function runVerify(opts) {
     out2("pristine run executes through it too. Failing closed, not open.");
     return 2;
   }
-  const priRoot = mkdtempSync2(join11(tmpdir2(), "tw-verify-pri-"));
-  const priDir = join11(priRoot, "t");
+  const priRoot = mkdtempSync2(join12(tmpdir2(), "tw-verify-pri-"));
+  const priDir = join12(priRoot, "t");
   let restored = [];
   let removedAdded = 0;
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",