tamperward 2.5.0 → 2.5.1

package/dist/cli/index.js

@@ -330,26 +330,52 @@ function diffWorktree(opts = {}) {
     (c) => enrich(c, (p) => blobAt("HEAD", p, opts.cwd), (p) => fromDisk(p, opts.cwd))
   );
 }
+function addOf(rel, cwd) {
+  const after = fromDisk(rel, cwd);
+  return {
+    kind: "file",
+    path: rel,
+    oldPath: null,
+    op: "add",
+    before: null,
+    after,
+    binary: false,
+    hunks: after == null ? [] : addHunks(after)
+  };
+}
 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)
-    };
-  });
+  return others.filter((rel) => !exclude?.has(rel) && (!keep || keep(rel))).map((rel) => addOf(rel, opts.cwd));
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".hg", ".svn"]);
+var IGNORED_LS = ["ls-files", "--others", "--ignored", "--exclude-standard", "-z"];
+function underSkippedDir(rel) {
+  return rel.split("/").some((seg) => SKIP_DIRS.has(seg));
 }
-function diffWorktreeWithUntracked(opts = {}) {
+function ignoredPaths(opts = {}, keep) {
+  const files = [];
+  const dirs = [];
+  for (const entry of git([...IGNORED_LS, "--directory"], opts.cwd).split("\0").filter(Boolean)) {
+    if (underSkippedDir(entry)) continue;
+    if (entry.endsWith("/")) dirs.push(entry);
+    else files.push(entry);
+  }
+  if (dirs.length > 0) {
+    const expanded = git([...IGNORED_LS, "--", ...dirs.map((d) => `:(literal)${d}`)], opts.cwd).split("\0").filter(Boolean);
+    for (const rel of expanded) if (!underSkippedDir(rel)) files.push(rel);
+  }
+  return files.filter(keep);
+}
+function ignoredAdds(opts = {}, keep, exclude) {
+  return ignoredPaths(opts, keep).filter((rel) => !exclude?.has(rel)).map((rel) => addOf(rel, opts.cwd));
+}
+function diffWorktreeWithUntracked(opts = {}, keepIgnored) {
   const tracked = diffWorktree(opts);
   const seen = new Set(tracked.filter((c) => c.kind === "file").map((c) => c.path));
-  return [...tracked, ...untrackedAdds(opts, void 0, seen)];
+  const untracked = untrackedAdds(opts, void 0, seen);
+  for (const c of untracked) if (c.kind === "file") seen.add(c.path);
+  const ignored = keepIgnored ? ignoredAdds(opts, keepIgnored, seen) : [];
+  return [...tracked, ...untracked, ...ignored];
 }
 function hiddenTrackedPaths(opts = {}) {
   const out2 = [];
@@ -1985,7 +2011,7 @@ var ciTampering = {
 
 // src/detectors/hook-tampering.ts
 import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { isAbsolute, join as join2, relative } from "node:path";
 
 // src/detectors/policy-diff.ts
 import { parse } from "yaml";
@@ -2495,9 +2521,22 @@ function chmodDropsExec(toks) {
   return false;
 }
 var WRAPPERS = /^(?:sudo|command|exec|time|nice|env|[A-Za-z_][A-Za-z0-9_]*=\S*)$/;
+var REDIRECT_TARGET = /(?:^|\s)\d*>{1,2}\|?\s*(\S+)/g;
+var hookPath = (t) => t.replace(/^["']|["']$/g, "").replace(/^\.\//, "");
+function shellHookTarget(seg, toks, policy) {
+  for (const m of seg.matchAll(REDIRECT_TARGET)) {
+    const t = hookPath(m[1]);
+    if (isProtected(t, policy, "hooks")) return t;
+  }
+  for (const tok of toks) {
+    const t = hookPath(tok.replace(/^of=/, ""));
+    if (isProtected(t, policy, "hooks")) return t;
+  }
+  return null;
+}
 function shellWritesHook(seg, toks, policy) {
   const hook = (t) => isProtected(t.replace(/^\.\//, ""), policy, "hooks");
-  for (const m of seg.matchAll(/(?:^|\s)\d*>{1,2}\|?\s*(\S+)/g)) {
+  for (const m of seg.matchAll(REDIRECT_TARGET)) {
     if (hook(m[1].replace(/^["']|["']$/g, ""))) return "a redirect empties or rewrites a protected hook";
   }
   let at = 0;
@@ -2708,14 +2747,24 @@ function configFindings(c, policy) {
 function updateIndexHiding(toks, policy) {
   if (!toks.some((t) => t === "git" || t.endsWith("/git")) || !toks.includes("update-index")) return null;
   const hide = toks.find((t) => /^--(?:skip-worktree|assume-unchanged)$/.test(t));
-  if (hide && toks.some((t) => isProtected(t, policy))) {
-    return `git update-index ${hide} hides a protected file from every git diff \u2014 edits to it no longer reach the sweep or the pre-commit gate`;
+  const hidden = hide ? toks.find((t) => isProtected(t, policy)) : void 0;
+  if (hide && hidden) {
+    return {
+      reason: `git update-index ${hide} hides a protected file from every git diff \u2014 edits to it no longer reach the sweep or the pre-commit gate`,
+      file: hidden
+    };
   }
-  if (toks.some((t) => /^--chmod=-x$/.test(t)) && toks.some((t) => isProtected(t, policy, "hooks"))) {
-    return "git update-index --chmod=-x clears the execute bit on a protected hook through the index, which disables it";
+  const hook = toks.some((t) => /^--chmod=-x$/.test(t)) ? toks.find((t) => isProtected(t, policy, "hooks")) : void 0;
+  if (hook) {
+    return { reason: "git update-index --chmod=-x clears the execute bit on a protected hook through the index, which disables it", file: hook };
   }
   return null;
 }
+function repoRelative(path, ctx) {
+  if (!ctx?.cwd || !isAbsolute(path)) return path;
+  const rel = relative(ctx.cwd, path);
+  return rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : path;
+}
 var hookTampering = {
   id: RULE6,
   surface: ["file", "command"],
@@ -2865,7 +2914,8 @@ var hookTampering = {
           if (hiding) {
             out2.push(
               makeFinding(RULE6, policy, {
-                message: `Hook tampering via shell: ${hiding}.`,
+                file: repoRelative(hiding.file, ctx),
+                message: `Hook tampering via shell: ${hiding.reason}.`,
                 evidence: seg,
                 remediation: "Leave protected files visible to git. Hiding one from the diff hides it from the gate, which is the tamper \u2014 use `--no-skip-worktree` / `--no-assume-unchanged` to undo it."
               })
@@ -2874,8 +2924,10 @@ var hookTampering = {
           }
           const why = shellWritesHook(seg, toks, policy);
           if (why) {
+            const target = shellHookTarget(seg, toks, policy);
             out2.push(
               makeFinding(RULE6, policy, {
+                ...target ? { file: repoRelative(target, ctx) } : {},
                 message: `Hook tampering via shell: ${why}.`,
                 evidence: seg,
                 remediation: "Leave the hooks in place. Mutating them from the shell is still tampering."
@@ -3572,7 +3624,7 @@ function hasBlocking(findings) {
 
 // src/policy-load.ts
 import { readFileSync as readFileSync3, existsSync as existsSync2 } from "node:fs";
-import { isAbsolute, join as join3, posix } from "node:path";
+import { isAbsolute as isAbsolute2, join as join3, posix } from "node:path";
 import { parse as parse2 } from "yaml";
 var PolicyError = class extends Error {
 };
@@ -3589,7 +3641,7 @@ var isStringList = (v) => Array.isArray(v) && v.every((s) => typeof s === "strin
 var isMapping = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["version", "protected", "rules", "ignore", "signoff", "verify"]);
 function ledgerInsideRepo(ledger) {
-  if (!ledger.trim() || isAbsolute(ledger) || /^[A-Za-z]:[\\/]/.test(ledger)) return false;
+  if (!ledger.trim() || isAbsolute2(ledger) || /^[A-Za-z]:[\\/]/.test(ledger)) return false;
   const norm2 = posix.normalize(ledger.replace(/\\/g, "/"));
   return norm2 !== ".." && !norm2.startsWith("../") && !norm2.startsWith("/");
 }
@@ -4043,7 +4095,8 @@ function check(opts) {
     layer = "local";
     view = "staged";
   } else if (opts.worktree) {
-    changes = opts.includeUntracked ? diffWorktreeWithUntracked({ cwd: opts.cwd }) : diffWorktree({ cwd: opts.cwd });
+    const p = policy;
+    changes = opts.includeUntracked ? diffWorktreeWithUntracked({ cwd: opts.cwd }, (rel) => isProtected(rel, p)) : diffWorktree({ cwd: opts.cwd });
     layer = opts.ciLayer ? "ci" : "local";
     view = "worktree";
   } else if (opts.diff) {
@@ -4102,7 +4155,7 @@ import { join as join9 } from "node:path";
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { readFileSync as readFileSync5, existsSync as existsSync4, writeFileSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { isAbsolute as isAbsolute2, join as join5, relative, resolve } from "node:path";
+import { isAbsolute as isAbsolute3, join as join5, relative as relative2, resolve } from "node:path";
 function asStr(v) {
   return typeof v === "string" ? v : "";
 }
@@ -4117,8 +4170,8 @@ function abs(path, cwd) {
   return resolve(cwd, path);
 }
 function relForDisplay(path, cwd) {
-  const rel = relative(cwd, path);
-  return rel && !rel.startsWith("..") && !isAbsolute2(rel) ? rel : path;
+  const rel = relative2(cwd, path);
+  return rel && !rel.startsWith("..") && !isAbsolute3(rel) ? rel : path;
 }
 function applyEdit(content, oldStr, newStr) {
   if (content === null) return newStr;
@@ -4261,11 +4314,11 @@ function advanceTurnBaseline(cwd, sessionId) {
 
 // src/effect.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync7, statSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join7 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync7, renameSync, rmSync as rmSync2, statSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { isAbsolute as isAbsolute4, join as join7 } from "node:path";
 import { execFileSync as execFileSync4 } from "node:child_process";
 var UNSAFE2 = /[^A-Za-z0-9._-]/g;
-var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".hg", ".svn"]);
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([".git", "node_modules", ".hg", ".svn"]);
 function gitDir2(cwd) {
   try {
     const d = execFileSync4("git", ["rev-parse", "--git-dir"], {
@@ -4274,7 +4327,7 @@ function gitDir2(cwd) {
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
     if (!d) return null;
-    return isAbsolute3(d) ? d : join7(cwd, d);
+    return isAbsolute4(d) ? d : join7(cwd, d);
   } catch {
     return null;
   }
@@ -4307,7 +4360,7 @@ function snapshotProtected(cwd, policy, prev) {
       return;
     }
     for (const name of names) {
-      if (SKIP_DIRS.has(name)) continue;
+      if (SKIP_DIRS2.has(name)) continue;
       const r = rel ? `${rel}/${name}` : name;
       let st;
       try {
@@ -4333,12 +4386,16 @@ function snapshotProtected(cwd, policy, prev) {
 function driftBetween(expected, current) {
   const changed = [];
   const deleted = [];
+  const added = [];
   for (const [path, e] of Object.entries(expected)) {
     const c = current[path];
     if (!c) deleted.push(path);
     else if (c.hash !== e.hash || c.mode !== e.mode) changed.push(path);
   }
-  return { changed, deleted };
+  for (const path of Object.keys(current)) {
+    if (!expected[path]) added.push(path);
+  }
+  return { changed, deleted, added };
 }
 function loadTree(p) {
   if (!p || !existsSync6(p)) return null;
@@ -4352,7 +4409,16 @@ function saveTree(p, tree) {
   if (!p) return;
   try {
     mkdirSync3(join7(p, ".."), { recursive: true });
-    writeFileSync3(p, JSON.stringify(tree));
+    const tmp = `${p}.${process.pid}.tmp`;
+    writeFileSync3(tmp, JSON.stringify(tree));
+    renameSync(tmp, p);
+  } catch {
+  }
+}
+function dropTree(p) {
+  if (!p) return;
+  try {
+    rmSync2(p, { force: true });
   } catch {
   }
 }
@@ -4368,6 +4434,9 @@ function loadTurnTree(cwd, sessionId) {
 function saveTurnTree(cwd, sessionId, tree) {
   saveTree(turnTreePath(cwd, sessionId), tree);
 }
+function dropTurnTree(cwd, sessionId) {
+  dropTree(turnTreePath(cwd, sessionId));
+}
 
 // src/cli/watch.ts
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync8, statSync as statSync2, watch } from "node:fs";
@@ -4612,17 +4681,26 @@ function turnView(cwd, sessionId, policy, base) {
     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)
-  );
+  const ptree = loadPtree(cwd, sessionId);
+  const keep = (rel) => isProtected(rel, policy);
+  const untouched = (rel, disk) => disk != null && turnTree?.[rel]?.hash === disk && ptree?.[rel]?.hash === disk;
+  const untracked = untrackedAdds({ cwd }, keep, seen).filter((c) => c.kind !== "file" || !untouched(c.path, hashOnDisk(cwd, c.path)));
   for (const c of fileChanges(untracked)) seen.add(c.path);
+  const ignored = ignoredAdds({ cwd }, keep, seen).filter((c) => {
+    if (c.kind !== "file") return false;
+    const disk = hashOnDisk(cwd, c.path);
+    if (untouched(c.path, disk)) return false;
+    const sanctioned = ptree?.[c.path];
+    return !(sanctioned && disk != null && sanctioned.hash !== disk);
+  });
+  for (const c of fileChanges(ignored)) 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];
+  return [...tracked, ...untracked, ...ignored, ...hidden];
 }
 function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree) {
   const d = driftBetween(expected, current);
@@ -4640,7 +4718,7 @@ function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree)
     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;
+    const atTurnStart = current[rel] != null && expected[rel]?.mtimeMs === -1 && turnTree?.[rel]?.hash === current[rel].hash;
     if ((atGitState || atTurnStart) && current[rel] && expected[rel] && current[rel].mode === expected[rel].mode) {
       continue;
     }
@@ -4683,6 +4761,23 @@ function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree)
       });
     }
   }
+  for (const rel of d.added) {
+    if (seen.has(rel)) continue;
+    const after = fileOnDisk(rel, { cwd });
+    if (after == null) {
+      blocks.push({
+        rule: "hidden-drift",
+        severity: "block",
+        file: rel,
+        message: `Protected file ${rel} appeared outside git's view and cannot be read to judge it.`,
+        evidence: rel,
+        remediation: "Remove the file, or make it readable and bring it into git's view; create protected files through a tool call the gate can see.",
+        signoff: { required: true, command: `tamperward allow hidden-drift --file ${rel} --reason "..."` }
+      });
+      continue;
+    }
+    changes.push(...synthFileChange(rel, null, after));
+  }
   return { changes, blocks };
 }
 function effectDriftBlocks(cwd, sessionId, policy) {
@@ -4691,17 +4786,18 @@ function effectDriftBlocks(cwd, sessionId, policy) {
   const current = snapshotProtected(cwd, policy, expected ?? void 0);
   if (!expected) {
     savePtree(cwd, sessionId, current);
-    if (!loadTurnTree(cwd, sessionId)) saveTurnTree(cwd, sessionId, current);
+    if (loadTurnTree(cwd, sessionId)) dropTurnTree(cwd, sessionId);
+    else saveTurnTree(cwd, sessionId, current);
     return null;
   }
   const d = driftBetween(expected, current);
-  if (d.changed.length === 0 && d.deleted.length === 0) {
+  if (d.changed.length === 0 && d.deleted.length === 0 && d.added.length === 0) {
     savePtree(cwd, sessionId, current);
     return null;
   }
   const base = turnBaseline(cwd, sessionId);
   const all = turnView(cwd, sessionId, policy, base);
-  const drifted = /* @__PURE__ */ new Set([...d.changed, ...d.deleted]);
+  const drifted = /* @__PURE__ */ new Set([...d.changed, ...d.deleted, ...d.added]);
   const scoped = all.filter(
     (c) => c.kind === "file" && (drifted.has(c.path) || c.oldPath != null && drifted.has(c.oldPath))
   );
@@ -4916,7 +5012,7 @@ Honored at LOCAL pre-commit only. The agent-layer hook ignores this file; CI req
 import { execFileSync as execFileSync5 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5, chmodSync, statSync as statSync5 } from "node:fs";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute4, join as join10, relative as relative2, resolve as resolve2 } from "node:path";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute5, join as join10, relative as relative3, 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);
@@ -5234,8 +5330,8 @@ function hooksDir(cwd) {
   return existsSync8(join10(cwd, ".git")) ? join10(cwd, ".git", "hooks") : null;
 }
 function display(cwd, path) {
-  const rel = relative2(cwd, path);
-  return rel && !rel.startsWith("..") && !isAbsolute4(rel) ? rel : path;
+  const rel = relative3(cwd, path);
+  return rel && !rel.startsWith("..") && !isAbsolute5(rel) ? rel : path;
 }
 function unconditionalExitAt(lines) {
   let depth = 0;
@@ -5521,7 +5617,7 @@ tamperward init: ${changed} change(s) applied. Commit them so the gate travels w
 // src/cli/verify.ts
 import { execFileSync as execFileSync8, 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 readFileSync14, readlinkSync as readlinkSync2, rmSync as rmSync2, statSync as statSync7, symlinkSync, writeFileSync as writeFileSync6, existsSync as existsSync10 } from "node:fs";
+import { chmodSync as chmodSync2, cpSync, lstatSync, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync2, readFileSync as readFileSync14, readlinkSync as readlinkSync2, rmSync as rmSync3, statSync as statSync7, symlinkSync, writeFileSync as writeFileSync6, existsSync as existsSync10 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { dirname as dirname4, join as join13, resolve as resolve3 } from "node:path";
 
@@ -5529,7 +5625,7 @@ import { dirname as dirname4, join as join13, resolve as resolve3 } from "node:p
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync9, readFileSync as readFileSync12 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join11 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join11 } from "node:path";
 function trustedGitEnv() {
   return { ...process.env, GIT_NO_REPLACE_OBJECTS: "1" };
 }
@@ -5542,7 +5638,7 @@ function gitDirOf(cwd) {
       env: trustedGitEnv()
     }).trim();
     if (!d) return null;
-    return isAbsolute5(d) ? d : join11(cwd, d);
+    return isAbsolute6(d) ? d : join11(cwd, d);
   } catch {
     return null;
   }
@@ -5756,7 +5852,7 @@ function materialize(cwd, dest) {
 }
 function dropSymlink(p) {
   try {
-    if (lstatSync(p).isSymbolicLink()) rmSync2(p, { force: true });
+    if (lstatSync(p).isSymbolicLink()) rmSync3(p, { force: true });
   } catch {
   }
 }
@@ -5814,7 +5910,7 @@ function overlayPristine(cwd, base, dest, policy, cmd) {
     const content = execFileSync8("git", ["show", `${base}:${e.path}`], { cwd, maxBuffer: 1 << 28, env: trustedGitEnv() });
     const out2 = join13(dest, e.path);
     mkdirSync6(dirname4(out2), { recursive: true });
-    rmSync2(out2, { force: true });
+    rmSync3(out2, { force: true });
     if (e.mode === "120000") {
       symlinkSync(content.toString("utf8"), out2);
     } else {
@@ -5827,7 +5923,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(join13(dest, rel), { force: true });
+    rmSync3(join13(dest, rel), { force: true });
     removed++;
   }
   return { restored, removed };
@@ -5902,7 +5998,7 @@ function runSuite(dir, cmd, budgetSecs) {
     if (r.exit === null || r.exit === void 0) return { exit: null, secs };
     return { exit: r.exit, secs };
   } finally {
-    rmSync2(outDir, { recursive: true, force: true });
+    rmSync3(outDir, { recursive: true, force: true });
   }
 }
 function runVerify(opts) {
@@ -5949,7 +6045,7 @@ function runVerify(opts) {
   const visDir = join13(visRoot, "t");
   const cleanup = (dirs) => {
     if (opts.keep) return;
-    for (const d of dirs) rmSync2(d, { recursive: true, force: true });
+    for (const d of dirs) rmSync3(d, { recursive: true, force: true });
   };
   const treeBefore = treeFingerprint(cwd);
   const depsBefore = depsFingerprint(cwd);

package/package.json

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