tamperward 2.5.1 → 2.7.0

package/dist/cli/index.js

@@ -415,7 +415,41 @@ function makeFinding(rule, policy, input) {
 
 // src/detectors/command.ts
 function segments(raw) {
-  return raw.split(/(?:&&|\|\||[;&|\n])+/).map((s) => s.trim()).filter(Boolean);
+  const out2 = [];
+  let single = false;
+  let double = false;
+  let last = 0;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (ch === "\\" && !single) {
+      i++;
+      continue;
+    }
+    if (ch === "'" && !double) {
+      single = !single;
+      continue;
+    }
+    if (ch === '"' && !single) {
+      double = !double;
+      continue;
+    }
+    if (single || double) continue;
+    const prev = raw[i - 1];
+    const next = raw[i + 1];
+    let len = 0;
+    if (ch === "&" && next === "&") len = 2;
+    else if (ch === "|" && next === "|") len = 2;
+    else if (ch === "|" && next === "&") len = 2;
+    else if (ch === ";" || ch === "\n") len = 1;
+    else if (ch === "|" && prev !== ">") len = 1;
+    else if (ch === "&" && prev !== ">" && next !== ">") len = 1;
+    if (!len) continue;
+    out2.push(raw.slice(last, i));
+    i += len - 1;
+    last = i + 1;
+  }
+  out2.push(raw.slice(last));
+  return out2.map((s) => s.trim()).filter(Boolean);
 }
 function tokens(seg) {
   return seg.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [];
@@ -586,12 +620,12 @@ function matcher(glob) {
   }
   return m;
 }
-function matchesAny(path, globs3) {
-  return !!globs3 && globs3.some((g) => matcher(g)(path));
+function matchesAny(path, globs4) {
+  return !!globs4 && globs4.some((g) => matcher(g)(path));
 }
 function protectedCategory(path, policy) {
-  for (const [cat, globs3] of Object.entries(policy.protected ?? {})) {
-    if (matchesAny(path, globs3)) return cat;
+  for (const [cat, globs4] of Object.entries(policy.protected ?? {})) {
+    if (matchesAny(path, globs4)) return cat;
   }
   return null;
 }
@@ -607,9 +641,9 @@ function isIgnored(path, policy) {
 }
 function mergeProtected(base, user) {
   const out2 = { ...base };
-  for (const [cat, globs3] of Object.entries(user ?? {})) {
+  for (const [cat, globs4] of Object.entries(user ?? {})) {
     const have = new Set(out2[cat] ?? []);
-    out2[cat] = [...out2[cat] ?? [], ...(globs3 ?? []).filter((g) => !have.has(g))];
+    out2[cat] = [...out2[cat] ?? [], ...(globs4 ?? []).filter((g) => !have.has(g))];
   }
   return out2;
 }
@@ -654,6 +688,13 @@ function defaultPolicy(version = 1) {
       config: [
         "**/jest.config.*",
         "**/vitest.config.*",
+        // A `vitest.workspace.*` file REPLACES the root config's selection with the
+        // union of its projects, and a `vite.config.*` carrying a `test:` key is the
+        // vitest config when no vitest.config exists — both are where a spec can be
+        // dropped from the suite without a line of it changing. ADDITIVE, like every
+        // baseline widening (the policy-diff reads it as a strengthening).
+        "**/vitest.workspace.*",
+        "**/vite.config.*",
         "**/tsconfig*.json",
         "**/.eslintrc*",
         "**/eslint.config.*",
@@ -686,6 +727,9 @@ function defaultPolicy(version = 1) {
       hooks: [
         ".husky/**",
         "**/lefthook.*",
+        // lefthook merges `lefthook-local.yml` OVER `lefthook.yml`: a `skip: true`
+        // there switches the gate off without touching the file init pointed at.
+        "**/lefthook-local.*",
         ".tamperward.yml",
         "**/.tamperward.yml",
         ".claude/settings.json",
@@ -1141,6 +1185,25 @@ function trackedFiles(ctx) {
   cache2.set(ctx.cwd, files);
   return files;
 }
+var branchCache = /* @__PURE__ */ new Map();
+function defaultBranch(ctx) {
+  if (!ctx?.cwd) return null;
+  const hit = branchCache.get(ctx.cwd);
+  if (hit !== void 0) return hit;
+  let name = null;
+  try {
+    const ref = execFileSync2("git", ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"], {
+      cwd: ctx.cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+    name = ref.replace(/^origin\//, "") || null;
+  } catch {
+    name = null;
+  }
+  branchCache.set(ctx.cwd, name);
+  return name;
+}
 var dirOf = (t) => t.replace(/^\.\//, "").replace(/\/+$/, "");
 function containsProtected(token, policy, category, ctx) {
   const dir = dirOf(token);
@@ -1199,6 +1262,13 @@ function underKey(node, key2) {
   }
   return false;
 }
+function ownerKey(node) {
+  const obj = node.parent;
+  if (!obj || !ts2.isObjectLiteralExpression(obj)) return null;
+  let q = obj.parent;
+  while (q && (ts2.isParenthesizedExpression(q) || ts2.isAsExpression(q) || q.kind === ts2.SyntaxKind.SatisfiesExpression)) q = q.parent;
+  return q && ts2.isPropertyAssignment(q) ? keyName(q.name) : null;
+}
 function asExpression(src) {
   const t = src.trim();
   return t.startsWith("{") ? `(${t})` : src;
@@ -1276,18 +1346,20 @@ function literals(e) {
   return { items, opaque };
 }
 function parseLists(src) {
-  const res = { collectFrom: null, ignore: [], opaqueCollect: false, opaqueIgnore: false };
+  const res = { collectFrom: null, collectKey: "collectCoverageFrom", ignore: [], opaqueCollect: false, opaqueIgnore: false };
   try {
     const sf = sourceOf(src);
     const resolve5 = resolverFor(sf);
     const visit = (node) => {
       if (ts2.isPropertyAssignment(node)) {
         const k = keyName(node.name);
-        if (k === "collectCoverageFrom") {
+        const vitestCoverage = ownerKey(node) === "coverage";
+        if (k === "collectCoverageFrom" || k === "include" && vitestCoverage) {
           const { items, opaque } = literals(resolve5(node.initializer));
           res.collectFrom = items;
+          res.collectKey = k === "include" ? "coverage.include" : k;
           if (opaque) res.opaqueCollect = true;
-        } else if (k === "coveragePathIgnorePatterns" || k === "exclude" && underKey(node, "coverage")) {
+        } else if (k === "coveragePathIgnorePatterns" || k === "exclude" && vitestCoverage) {
           const { items, opaque } = literals(resolve5(node.initializer));
           res.ignore.push(...items);
           if (opaque) res.opaqueIgnore = true;
@@ -1300,6 +1372,43 @@ function parseLists(src) {
   }
   return res;
 }
+function parseSwitches(src) {
+  const res = {};
+  try {
+    const sf = sourceOf(src);
+    const bool = (e) => e.kind === ts2.SyntaxKind.TrueKeyword ? true : e.kind === ts2.SyntaxKind.FalseKeyword ? false : void 0;
+    const visit = (node) => {
+      if (ts2.isPropertyAssignment(node)) {
+        const k = keyName(node.name);
+        const owner = ownerKey(node);
+        if (k === "enabled" && owner === "coverage") res.enabled = bool(node.initializer);
+        else if (k === "perFile" && owner === "thresholds" && underKey(node, "coverage")) res.perFile = bool(node.initializer);
+      }
+      ts2.forEachChild(node, visit);
+    };
+    visit(sf);
+  } catch {
+  }
+  return res;
+}
+function sectionText(src, key2) {
+  try {
+    const sf = sourceOf(src);
+    let out2 = "";
+    const visit = (node) => {
+      if (out2) return;
+      if (ts2.isPropertyAssignment(node) && keyName(node.name) === key2 && ts2.isObjectLiteralExpression(node.initializer)) {
+        out2 = node.initializer.getText(sf);
+        return;
+      }
+      ts2.forEachChild(node, visit);
+    };
+    visit(sf);
+    return out2;
+  } catch {
+    return "";
+  }
+}
 var BENIGN_EXEMPTION = /node_modules|(?:^|[/!])(?:dist|build|out|coverage|tmp|temp|vendor|test|tests|__tests__|__mocks__|__fixtures__|fixtures?|mocks?|spec|specs|e2e|cypress|playwright|storybook|scripts?|examples?|docs?|bin|types?|typings)(?:\/|$|\*)|\.(?:test|spec|stories|d)\.|\.(?:config|setup)\.|\.git\b|\.cache|\.next|\.nuxt|\.output|\.idea|\.d\.ts|\.json$|\.md$|\.css$|\.s[ac]ss$/i;
 function compareMetrics(scope, before, after, out2) {
   if (!before) return;
@@ -1325,10 +1434,10 @@ function overrideTargetExists(key2, configPath, ctx) {
   }
   return files.some((f) => f.startsWith(root) && m(f.slice(root.length)));
 }
-function weakenings(before, after, configPath, ctx) {
+function weakenings(before, after, configPath, movedElsewhere, ctx) {
   const out2 = [];
   if (before.present && !after.present) {
-    out2.push("the coverage threshold gate was removed");
+    if (!movedElsewhere) out2.push("the coverage threshold gate was removed");
     return out2;
   }
   if (after.opaque && !after.global && after.paths.size === 0) return out2;
@@ -1355,16 +1464,45 @@ function weakenings(before, after, configPath, ctx) {
   }
   return out2;
 }
-function narrowings(before, after) {
+var globs = (patterns) => {
+  const ms = patterns.map((g) => {
+    try {
+      return picomatch2(norm(g), { dot: true });
+    } catch {
+      return () => false;
+    }
+  });
+  return (p) => ms.some((m) => m(p));
+};
+var globList = (patterns) => {
+  const pos = globs(patterns.filter((g) => !g.startsWith("!")));
+  const neg = globs(patterns.filter((g) => g.startsWith("!")).map((g) => g.slice(1)));
+  return (p) => pos(p) && !neg(p);
+};
+var CANONICAL_SOURCES = ["src/index.ts", "src/a.ts", "src/a.tsx", "src/lib/b.ts", "src/index.js", "src/a.jsx", "lib/a.js"];
+var NON_SOURCE = /(?:^|\/)(?:dist|build|out|coverage|node_modules|vendor|test|tests|__tests__|__mocks__|__fixtures__|fixtures|mocks|spec|specs|e2e|cypress|playwright|storybook|scripts|examples|docs|bin|types|typings)\/|\.(?:test|spec|stories|d|config|setup)\.|\.d\.ts$/;
+function sourceSamples(configPath, policy, ctx) {
+  const files = trackedFiles(ctx);
+  if (!files) return CANONICAL_SOURCES;
+  const root = configPath.includes("/") ? configPath.slice(0, configPath.lastIndexOf("/") + 1) : "";
+  const own = files.filter((f) => f.startsWith(root) && langOf(f) === "js" && !NON_SOURCE.test(f) && !isProtected(f, policy, "tests") && !isProtected(f, policy, "config")).map((f) => f.slice(root.length));
+  return own.length ? own : CANONICAL_SOURCES;
+}
+function narrowings(before, after, sources) {
   const out2 = [];
-  if (before.collectFrom && after.collectFrom && !after.opaqueCollect) {
-    const kept = new Set(after.collectFrom);
-    for (const g of before.collectFrom) {
-      if (!g.startsWith("!") && !kept.has(g)) out2.push(`collectCoverageFrom no longer measures ${JSON.stringify(g)}`);
+  if (before.collectFrom && after.collectFrom && !after.opaqueCollect && !before.opaqueCollect) {
+    const pb = globList(before.collectFrom);
+    const pa = globList(after.collectFrom);
+    const dropped = sources.filter((s) => pb(s) && !pa(s));
+    if (dropped.length) {
+      const shown = dropped.slice(0, 3).map((d) => JSON.stringify(d)).join(", ");
+      out2.push(`${after.collectKey} no longer measures ${shown}${dropped.length > 3 ? ` (+${dropped.length - 3} more)` : ""}`);
     }
     const had2 = new Set(before.collectFrom);
     for (const g of after.collectFrom) {
-      if (g.startsWith("!") && !had2.has(g) && !BENIGN_EXEMPTION.test(g)) out2.push(`collectCoverageFrom now exempts ${JSON.stringify(g)}`);
+      if (g.startsWith("!") && !had2.has(g) && !BENIGN_EXEMPTION.test(g) && !dropped.some((d) => globs([g.slice(1)])(d))) {
+        out2.push(`${after.collectKey} now exempts ${JSON.stringify(g)}`);
+      }
     }
   }
   const had = new Set(before.ignore);
@@ -1373,75 +1511,153 @@ function narrowings(before, after) {
   }
   return out2;
 }
+function switchWeakenings(before, after) {
+  const out2 = [];
+  if (before.enabled === true && after.enabled === false) out2.push("coverage.enabled switched off \u2014 the thresholds are never checked");
+  if (before.perFile === true && after.perFile !== true) out2.push("thresholds.perFile removed \u2014 a single uncovered file now hides behind the aggregate");
+  return out2;
+}
+var NYC_KEYS = METRICS.map((m) => ({
+  key: new RegExp(`(?:^|[\\s{,])"?${m}"?\\s*[:=]\\s*"?(\\d+(?:\\.\\d+)?)`, "g"),
+  label: m,
+  weakens: "lower"
+}));
+var COVERAGE_PY = /(?:^|\/)(?:\.coveragerc|pyproject\.toml)$/;
+var CODECOV = /(?:^|\/)\.?codecov\.yml$/;
 var SIMPLE_FILES = [
   {
     // coverage.py: `fail_under = 90` under [report] (.coveragerc, setup.cfg-style) or
     // [tool.coverage.report] (pyproject.toml)
-    file: /(?:^|\/)(?:\.coveragerc|pyproject\.toml)$/,
+    file: COVERAGE_PY,
     keys: [{ key: /^\s*fail[_-]under\s*=\s*"?(\d+(?:\.\d+)?)/, label: "fail_under", weakens: "lower" }],
     removable: true
   },
   {
     // nyc: .nycrc / .nycrc.json / .nycrc.yml / nyc.config.js — metric thresholds
     file: /(?:^|\/)(?:\.nycrc(?:\.\w+)?|nyc\.config\.\w+)$/,
-    keys: METRICS.map((m) => ({
-      key: new RegExp(`(?:^|[\\s{,])"?${m}"?\\s*[:=]\\s*"?(\\d+(?:\\.\\d+)?)`, "g"),
-      label: m,
-      weakens: "lower"
-    })),
+    keys: NYC_KEYS,
     removable: false
   },
   {
-    // codecov: `target: 90%` is the floor (lowering weakens); `threshold: 2%` is the
+    // codecov: `target: 90%` is the floor (lowering weakens; `auto` is a floor that
+    // follows the base commit, lower than any fixed number); `threshold: 2%` is the
     // permitted drop (raising weakens)
-    file: /(?:^|\/)\.?codecov\.yml$/,
+    file: CODECOV,
     keys: [
-      { key: /^\s*target:\s*"?(\d+(?:\.\d+)?)%?/, label: "target", weakens: "lower" },
+      { key: /^\s*target:\s*"?(\d+(?:\.\d+)?|auto)\b%?/, label: "target", weakens: "lower" },
       { key: /^\s*threshold:\s*"?(\d+(?:\.\d+)?)%?/, label: "threshold", weakens: "raise" }
     ],
-    removable: false
+    removable: false,
+    scoped: true
   }
 ];
-function numbersOf(src, key2) {
+var lessThan = (a, b) => a === "auto" ? b !== "auto" : b === "auto" ? false : a < b;
+var numOf = (s) => s === "auto" ? "auto" : Number(s);
+function numbersOf(src, key2, scoped = false) {
   const out2 = [];
+  const stack = [];
   for (const line of src.split("\n")) {
+    let scope = "";
+    if (scoped) {
+      const m = line.match(/^(\s*)([\w-]+):/);
+      if (m) {
+        const ind = m[1].length;
+        while (stack.length && stack[stack.length - 1].ind >= ind) stack.pop();
+        stack.push({ ind, key: m[2] });
+      }
+      scope = [...stack.slice(0, -1)].reverse().find((s) => /^(?:project|patch|changes)$/.test(s.key))?.key ?? "";
+    }
     if (key2.global) {
-      for (const m of line.matchAll(key2)) out2.push(Number(m[1]));
+      for (const m of line.matchAll(key2)) out2.push({ v: numOf(m[1]), scope });
     } else {
       const m = line.match(key2);
-      if (m) out2.push(Number(m[1]));
+      if (m) out2.push({ v: numOf(m[1]), scope });
     }
   }
   return out2;
 }
-function simpleWeakenings(path, before, after) {
+function simpleWeakeningsOf(spec, before, after) {
   const out2 = [];
-  const spec = SIMPLE_FILES.find((s) => s.file.test(path));
-  if (!spec) return out2;
   for (const k of spec.keys) {
-    const b = numbersOf(before, k.key).sort((x, y) => y - x);
-    const a = numbersOf(after, k.key).sort((x, y) => y - x);
-    if (b.length === 0) continue;
-    if (a.length === 0) {
-      if (spec.removable) out2.push(`${k.label} removed (was ${b.join(", ")})`);
-      continue;
-    }
-    if (k.weakens === "lower") {
-      for (let i = 0; i < b.length; i++) {
-        const av = a[Math.min(i, a.length - 1)];
-        if (av < b[i]) {
-          out2.push(`${k.label} lowered ${b[i]} \u2192 ${av}`);
-          break;
+    const bAll = numbersOf(before, k.key, spec.scoped);
+    const aAll = numbersOf(after, k.key, spec.scoped);
+    const scopes = [...new Set(bAll.map((n) => n.scope))];
+    for (const scope of scopes) {
+      const label = scope ? `${scope} ${k.label}` : k.label;
+      const desc = (x, y) => x === "auto" ? -1 : y === "auto" ? 1 : lessThan(x, y) ? 1 : lessThan(y, x) ? -1 : 0;
+      const b = bAll.filter((n) => n.scope === scope).map((n) => n.v).sort(desc);
+      const a = aAll.filter((n) => n.scope === scope).map((n) => n.v).sort(desc);
+      if (b.length === 0) continue;
+      if (a.length === 0) {
+        if (spec.removable) out2.push(`${label} removed (was ${b.join(", ")})`);
+        continue;
+      }
+      if (k.weakens === "lower") {
+        for (let i = 0; i < b.length; i++) {
+          const av = a[Math.min(i, a.length - 1)];
+          if (lessThan(av, b[i])) {
+            out2.push(`${label} lowered ${b[i]} \u2192 ${av}`);
+            break;
+          }
         }
+      } else {
+        const bMax = b[0];
+        const aMax = a[0];
+        if (lessThan(bMax, aMax)) out2.push(`${label} raised ${bMax} \u2192 ${aMax} (a wider permitted drop)`);
       }
-    } else {
-      const bMax = b[0];
-      const aMax = a[0];
-      if (aMax > bMax) out2.push(`${k.label} raised ${bMax} \u2192 ${aMax} (a wider permitted drop)`);
     }
   }
   return out2;
 }
+function listEntries(src, key2) {
+  const out2 = [];
+  const lines = src.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(key2);
+    if (!m) continue;
+    let rest = m[1] ?? "";
+    let j = i + 1;
+    if (rest.trim().startsWith("[") && !rest.includes("]")) {
+      while (j < lines.length && !lines[j].includes("]")) rest += "," + lines[j++];
+      if (j < lines.length) rest += "," + lines[j];
+    } else if (rest.trim() === "") {
+      while (j < lines.length && /^\s+(?:-\s+)?\S/.test(lines[j])) rest += "," + lines[j++].replace(/^\s*-\s+/, "");
+    }
+    for (const e of rest.replace(/[[\]]/g, "").split(",")) {
+      const v = e.trim().replace(/^(['"])(.*)\1$/, "$2");
+      if (v) out2.push(v);
+    }
+  }
+  return out2;
+}
+function simpleNarrowings(path, before, after) {
+  const out2 = [];
+  const spec = [
+    [COVERAGE_PY, /^\s*omit\s*=\s*(.*)$/, "omit now exempts"],
+    [CODECOV, /^ignore:\s*(.*)$/, "codecov now ignores"]
+  ];
+  for (const [file, key2, what] of spec) {
+    if (!file.test(path)) continue;
+    const had = new Set(listEntries(before, key2));
+    for (const e of listEntries(after, key2)) if (!had.has(e) && !BENIGN_EXEMPTION.test(e)) out2.push(`${what} ${JSON.stringify(e)}`);
+  }
+  if (CODECOV.test(path)) {
+    const off2 = (s) => new Set(s.split("\n").map((l) => l.match(/^\s*(project|patch):\s*off\b/)?.[1]).filter((x) => !!x));
+    const had = off2(before);
+    for (const s of off2(after)) if (!had.has(s)) out2.push(`codecov status.${s} switched off`);
+  }
+  return out2;
+}
+function simpleWeakenings(path, before, after) {
+  const spec = SIMPLE_FILES.find((s) => s.file.test(path));
+  const out2 = spec ? simpleWeakeningsOf(spec, before, after) : [];
+  if ((path.split("/").pop() ?? path) === "package.json") {
+    const b = sectionText(before, "nyc");
+    const a = sectionText(after, "nyc");
+    if (b && a) out2.push(...simpleWeakeningsOf({ file: /./, keys: NYC_KEYS, removable: false }, b, a).map((r) => `nyc ${r}`));
+  }
+  return out2;
+}
 var SWITCHES = [
   {
     re: /--passWithNoTests\b/,
@@ -1480,6 +1696,35 @@ var SWITCHES = [
   }
 ];
 var isJsConfig = (path) => /\.(?:[cm]?[jt]sx?|json)$/.test(path);
+function gateMovedElsewhere(c, changes, policy) {
+  const before = c.before ?? "";
+  const others = changes.filter((o) => o.kind === "file" && o !== c && o.after != null && isProtected(o.path, policy, "config"));
+  if (isJsConfig(c.path)) {
+    const was = parseThresholds(before);
+    if (!was.present) return false;
+    return others.some((o) => {
+      if (!isJsConfig(o.path)) return false;
+      const now = parseThresholds(o.after);
+      if (!now.present) return false;
+      if (now.opaque) return true;
+      return METRICS.every((m) => {
+        const bv = was.global?.values[m];
+        const av = now.global?.values[m];
+        return bv === void 0 || av !== void 0 && av >= bv;
+      });
+    });
+  }
+  const spec = SIMPLE_FILES.find((s) => s.file.test(c.path));
+  if (!spec) return false;
+  return spec.keys.every((k) => {
+    const b = numbersOf(before, k.key, spec.scoped).map((n) => n.v);
+    if (b.length === 0) return true;
+    return others.some((o) => {
+      const a = numbersOf(o.after, k.key, spec.scoped).map((n) => n.v);
+      return a.length > 0 && b.every((bv) => a.some((av) => k.weakens === "lower" ? !lessThan(av, bv) : !lessThan(bv, av)));
+    });
+  });
+}
 var coverageLowering = {
   id: RULE4,
   surface: ["file"],
@@ -1492,10 +1737,15 @@ var coverageLowering = {
       if (c.after != null && c.op !== "delete") {
         const reasons = [];
         if (isJsConfig(c.path)) {
-          reasons.push(...weakenings(parseThresholds(c.before ?? ""), parseThresholds(c.after), c.path, ctx));
-          reasons.push(...narrowings(parseLists(c.before ?? ""), parseLists(c.after)));
+          const moved = () => gateMovedElsewhere(c, changes, policy);
+          const b = parseThresholds(c.before ?? "");
+          const a = parseThresholds(c.after);
+          reasons.push(...weakenings(b, a, c.path, b.present && !a.present && moved(), ctx));
+          reasons.push(...narrowings(parseLists(c.before ?? ""), parseLists(c.after), sourceSamples(c.path, policy, ctx)));
+          reasons.push(...switchWeakenings(parseSwitches(c.before ?? ""), parseSwitches(c.after)));
         }
         reasons.push(...simpleWeakenings(c.path, c.before ?? "", c.after));
+        reasons.push(...simpleNarrowings(c.path, c.before ?? "", c.after));
         for (const reason of reasons) {
           out2.push(
             makeFinding(RULE4, policy, {
@@ -1509,7 +1759,7 @@ var coverageLowering = {
       } else if (c.op === "delete" || c.after === "" && (c.before ?? "").length > 0) {
         const before = c.before ?? "";
         const gated = isJsConfig(c.path) ? parseThresholds(before).present : simpleWeakenings(c.path, before, "").length > 0 || SIMPLE_FILES.some((s) => s.file.test(c.path) && s.keys.some((k) => numbersOf(before, k.key).length));
-        if (gated) {
+        if (gated && !gateMovedElsewhere(c, changes, policy)) {
           out2.push(
             makeFinding(RULE4, policy, {
               file: c.path,
@@ -1606,8 +1856,33 @@ function canonical(core) {
   return s.replace(/\s+--\s*$/, "").trim();
 }
 var usesRef = (core) => core.replace(/@.*$/, "");
-var NEUTRALISING_SUFFIX = /\|\||;|(?<!&)&(?!&)|\|(?!\|)|--passWithNoTests\b|--coverage=false\b|--coverageThreshold\b|--testPathIgnorePatterns\b|--testPathPattern\b|--testNamePattern\b|(?:^|\s)-t\s|--onlyChanged\b|--changed\b|--findRelatedTests\b/;
-function survives(removedCore, isUses, afterCores) {
+var SUITE_NARROWING_FLAGS = /--testPathIgnorePatterns\b|--testPathPattern\b|--testNamePattern\b|(?:^|\s)-t\s|--onlyChanged\b|--changed\b|--findRelatedTests\b|--exclude\b|--dir\b|--project\b/;
+var NEUTRALISING_SUFFIX = new RegExp(
+  `\\|\\||;|(?<!&)&(?!&)|\\|(?!\\|)|--passWithNoTests\\b|--coverage=false\\b|--coverageThreshold\\b|${SUITE_NARROWING_FLAGS.source}`
+);
+var TIMEOUT_WRAP = /^timeout\s+(?:-{1,2}\S+\s+)*\d\S*\s+(.+)$/;
+var PATH_SHAPED = /\/|\.(?:test|spec)\./;
+function narrowedByPositional(args) {
+  const toks = args.trim().split(/\s+/).filter(Boolean);
+  for (let i = 0; i < toks.length; i++) {
+    const t = toks[i];
+    if (t === "--" || t.startsWith("-")) continue;
+    const prev = toks[i - 1];
+    if (prev && (prev.startsWith("-") && prev !== "--" && !prev.includes("=") || /[<>]/.test(prev))) continue;
+    if (/[<>|;&]/.test(t)) continue;
+    if (PATH_SHAPED.test(t)) return true;
+  }
+  return false;
+}
+function checkKind(core) {
+  if (!invokesCheck(core)) return null;
+  const s = canonical(core);
+  if (/\btamperward\b/.test(s)) return "gate";
+  if (/\b(?:lint|eslint)\b/i.test(s)) return "lint";
+  if (/\b(?:typecheck|type-check|tsc)\b/i.test(s)) return "types";
+  return "test";
+}
+function survives(removedCore, isUses, afterCores, addedCores) {
   if (isUses) {
     const ref = usesRef(removedCore);
     return afterCores.some((a) => usesRef(a) === ref) ? { state: "kept" } : { state: "gone" };
@@ -1619,15 +1894,33 @@ function survives(removedCore, isUses, afterCores) {
     if (a === r) return { state: "kept" };
     if (a.startsWith(r + " ")) {
       const rest = a.slice(r.length);
-      if (NEUTRALISING_SUFFIX.test(rest)) neutralised = raw;
+      if (NEUTRALISING_SUFFIX.test(rest) || narrowedByPositional(rest)) neutralised ??= raw;
       else return { state: "kept" };
     } else if (r.startsWith(a + " ") && invokesCheck(a)) {
       return { state: "kept" };
+    } else {
+      const w = a.match(TIMEOUT_WRAP);
+      if (w && (canonical(w[1]) === r || canonical(w[1]).startsWith(r + " "))) neutralised ??= raw;
+    }
+  }
+  const kind = checkKind(removedCore);
+  let respelled = false;
+  for (const raw of addedCores) {
+    if (!kind || checkKind(raw) !== kind) continue;
+    const a = canonical(raw);
+    if (a.match(TIMEOUT_WRAP)) {
+      neutralised ??= raw;
+      continue;
     }
+    const args = a.slice(a.indexOf(" ") + 1 || a.length);
+    if (a.includes(" ") && (NEUTRALISING_SUFFIX.test(" " + args) || narrowedByPositional(args))) neutralised ??= raw;
+    else respelled = true;
   }
+  if (respelled) return { state: "kept" };
   return neutralised ? { state: "neutralised", by: neutralised } : { state: "gone" };
 }
 var uncommented = (v) => v.replace(/\s+#.*$/, "").trim();
+var TRUTHY = Symbol("truthy");
 function lex(src) {
   const out2 = [];
   let i = 0;
@@ -1658,13 +1951,13 @@ function lex(src) {
       i += num[0].length;
       continue;
     }
-    const op = src.slice(i).match(/^(?:==|!=|&&|\|\||<=|>=|[!()<>])/);
+    const op = src.slice(i).match(/^(?:==|!=|&&|\|\||<=|>=|[!()<>,[\]])/);
     if (op) {
       out2.push({ t: "op", v: op[0] });
       i += op[0].length;
       continue;
     }
-    const id = src.slice(i).match(/^[A-Za-z_][\w.\-[\]*]*/);
+    const id = src.slice(i).match(/^[A-Za-z_][\w.\-*]*/);
     if (id) {
       out2.push({ t: "id", v: id[0] });
       i += id[0].length;
@@ -1674,15 +1967,16 @@ function lex(src) {
   }
   return out2;
 }
+var truthy = (v) => v === TRUTHY ? true : typeof v === "string" ? v !== "" : typeof v === "number" ? v !== 0 : v === true;
 function foldConst(src) {
   const toks = lex(src);
   if (!toks) return void 0;
   let p = 0;
   const peek = () => toks[p];
   const eat = (v2) => toks[p]?.t === "op" && toks[p].v === v2 ? (p++, true) : false;
-  const truthy = (v2) => typeof v2 === "string" ? v2 !== "" : typeof v2 === "number" ? v2 !== 0 : v2 === true;
-  const num = (v2) => typeof v2 === "number" ? v2 : typeof v2 === "boolean" ? v2 ? 1 : 0 : v2 === null ? 0 : v2.trim() === "" ? 0 : Number(v2);
+  const num = (v2) => v2 === TRUTHY ? NaN : typeof v2 === "number" ? v2 : typeof v2 === "boolean" ? v2 ? 1 : 0 : v2 === null ? 0 : v2.trim() === "" ? 0 : Number(v2);
   const eq = (a, b) => {
+    if (a === TRUTHY || b === TRUTHY) return void 0;
     if (typeof a === "string" && typeof b === "string") return a.toLowerCase() === b.toLowerCase();
     if (a === null && b === null) return true;
     const x = num(a);
@@ -1693,8 +1987,9 @@ function foldConst(src) {
     let l = and();
     while (eat("||")) {
       const r = and();
-      if (l === void 0 || r === void 0) return void 0;
-      l = truthy(l) ? l : r;
+      if (l !== void 0 && truthy(l)) continue;
+      if (l !== void 0) l = r;
+      else l = r !== void 0 && truthy(r) ? TRUTHY : void 0;
     }
     return l;
   };
@@ -1702,8 +1997,9 @@ function foldConst(src) {
     let l = cmp();
     while (eat("&&")) {
       const r = cmp();
-      if (l === void 0 || r === void 0) return void 0;
-      l = truthy(l) ? r : l;
+      if (l !== void 0 && !truthy(l)) continue;
+      if (l !== void 0) l = r;
+      else l = r !== void 0 && !truthy(r) ? false : void 0;
     }
     return l;
   };
@@ -1714,14 +2010,18 @@ function foldConst(src) {
       if (!t || t.t !== "op" || !/^(?:==|!=|<|>|<=|>=)$/.test(t.v)) return l;
       p++;
       const r = unary();
-      if (l === void 0 || r === void 0) return void 0;
-      if (t.v === "==") l = eq(l, r);
-      else if (t.v === "!=") l = !eq(l, r);
-      else {
+      if (l === void 0 || r === void 0) {
+        l = void 0;
+        continue;
+      }
+      if (t.v === "==" || t.v === "!=") {
+        const e = eq(l, r);
+        l = e === void 0 ? void 0 : t.v === "==" ? e : !e;
+      } else {
         const x = num(l);
         const y = num(r);
-        if (Number.isNaN(x) || Number.isNaN(y)) return void 0;
-        l = t.v === "<" ? x < y : t.v === ">" ? x > y : t.v === "<=" ? x <= y : x >= y;
+        if (Number.isNaN(x) || Number.isNaN(y)) l = void 0;
+        else l = t.v === "<" ? x < y : t.v === ">" ? x > y : t.v === "<=" ? x <= y : x >= y;
       }
     }
   };
@@ -1746,6 +2046,19 @@ function foldConst(src) {
       if (/^true$/i.test(t.v)) return true;
       if (/^false$/i.test(t.v)) return false;
       if (/^null$/i.test(t.v)) return null;
+      if (eat("(")) {
+        if (!eat(")")) {
+          for (; ; ) {
+            or();
+            if (eat(")")) break;
+            if (!eat(",")) return void 0;
+          }
+        }
+      }
+      while (eat("[")) {
+        or();
+        if (!eat("]")) return void 0;
+      }
       return void 0;
     }
     return void 0;
@@ -1762,7 +2075,7 @@ function isAlwaysFalse(raw) {
   const e = expressionOf(raw);
   if (e === "") return false;
   const v = foldConst(e);
-  return v !== void 0 && !(typeof v === "string" ? v !== "" : typeof v === "number" ? v !== 0 : v === true);
+  return v !== void 0 && !truthy(v);
 }
 function isTruthy(raw) {
   const v = uncommented(raw).replace(/^(['"])(.*)\1$/, "$2").trim();
@@ -1770,7 +2083,7 @@ function isTruthy(raw) {
   const m = v.match(/^\$\{\{\s*(.+?)\s*\}\}$/);
   if (!m) return false;
   const f = foldConst(m[1]);
-  return f !== void 0 && (typeof f === "string" ? f !== "" : typeof f === "number" ? f !== 0 : f === true);
+  return f !== void 0 && truthy(f);
 }
 var indentOf = (l) => l.match(/^\s*/)[0].length;
 var STEP_START = /^\s*-\s+(?:name|uses|run|if|id|with|env|shell|continue-on-error|working-directory|timeout-minutes):/;
@@ -1784,7 +2097,21 @@ function stepOf(lines, i) {
   while (e < lines.length && (lines[e].trim() === "" || indentOf(lines[e]) > stepInd)) e++;
   return [s, e];
 }
+function jobOf(lines, i) {
+  const ind = indentOf(lines[i]);
+  let h = i - 1;
+  while (h >= 0 && (lines[h].trim() === "" || indentOf(lines[h]) >= ind)) h--;
+  if (h < 0 || !/^\s+[\w-]+:\s*(?:#.*)?$/.test(lines[h])) return null;
+  let t = h - 1;
+  while (t >= 0 && (lines[t].trim() === "" || indentOf(lines[t]) > 0)) t--;
+  if (t < 0 || !/^jobs:/.test(lines[t])) return null;
+  const hi = indentOf(lines[h]);
+  let e = i + 1;
+  while (e < lines.length && (lines[e].trim() === "" || indentOf(lines[e]) > hi)) e++;
+  return [h, e];
+}
 var stepHasCheck = (lines, range) => range === null || lines.slice(range[0], range[1]).some((l) => invokesCheck(l) || USES.test(l) && CHECK.test(l));
+var jobHasCheck = (lines, range) => lines.slice(range[0], range[1]).some((l) => invokesCheck(l) || USES.test(l) && CHECK.test(l) || /^\s*uses:\s*\S/.test(l));
 function runBlocks(lines) {
   const out2 = [];
   for (let i = 0; i < lines.length; i++) {
@@ -1802,13 +2129,28 @@ var NEUTRALISERS = [
   { re: /^\s*if\s+false\s*;?\s*then\b/, what: "if false; then \u2014 the check is never run" },
   { re: /^\s*:\s*<<\s*['"]?\w+/, what: "a heredoc fed to `:` \u2014 the check is commented out" }
 ];
+var LIST_KEYS = {
+  branches: "branches",
+  "branches-ignore": "branchesIgnore",
+  "paths-ignore": "pathsIgnore",
+  paths: "paths",
+  types: "types"
+};
 function flowList(v) {
   const m = v.trim().match(/^\[(.*)\]$/);
   if (!m) return null;
   return m[1].split(",").map((s) => s.trim().replace(/^(['"])(.*)\1$/, "$2")).filter(Boolean);
 }
 function parseTriggers(src) {
-  const t = { events: /* @__PURE__ */ new Set(), branches: /* @__PURE__ */ new Map(), branchesIgnore: /* @__PURE__ */ new Map(), pathsIgnore: /* @__PURE__ */ new Map(), present: false };
+  const t = {
+    events: /* @__PURE__ */ new Set(),
+    branches: /* @__PURE__ */ new Map(),
+    branchesIgnore: /* @__PURE__ */ new Map(),
+    pathsIgnore: /* @__PURE__ */ new Map(),
+    paths: /* @__PURE__ */ new Map(),
+    types: /* @__PURE__ */ new Map(),
+    present: false
+  };
   const lines = src.split("\n");
   const i = lines.findIndex((l) => /^(?:on|"on"|'on'|true):/.test(l));
   if (i < 0) return t;
@@ -1816,8 +2158,8 @@ function parseTriggers(src) {
   const head = lines[i].replace(/^(?:on|"on"|'on'|true):\s*/, "");
   const inline = uncommented(head);
   if (inline) {
-    const list = flowList(inline);
-    for (const e of list ?? [inline]) t.events.add(e);
+    const list2 = flowList(inline);
+    for (const e of list2 ?? [inline]) t.events.add(e);
     return t;
   }
   let event = null;
@@ -1844,47 +2186,92 @@ function parseTriggers(src) {
       listKey = null;
       continue;
     }
-    if (event && /^(?:branches|branches-ignore|paths-ignore)$/.test(kv[1])) {
-      listKey = kv[1] === "branches" ? "branches" : kv[1] === "branches-ignore" ? "branchesIgnore" : "pathsIgnore";
+    const key2 = LIST_KEYS[kv[1]];
+    if (event && key2) {
+      listKey = key2;
       listInd = ind;
-      const list = flowList(kv[2]);
-      t[listKey].set(event, list ?? []);
+      const list2 = flowList(kv[2]);
+      t[listKey].set(event, list2 ?? []);
     } else listKey = null;
   }
   return t;
 }
 var DEFAULT_BRANCH = /^(?:main|master)$/;
 var ALL = (g) => /^\*\*?$|^\*\*\/\*$/.test(g);
-function triggerNarrowings(before, after) {
+var CODE_EVENTS = ["push", "pull_request", "pull_request_target"];
+var PR_CODE_TYPES = /^(?:opened|synchronize|reopened)$/;
+function ghGlob(g) {
+  const re = g.split("**").map((part) => part.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")).join(".*");
+  try {
+    const r = new RegExp(`^${re}$`);
+    return (p) => r.test(p);
+  } catch {
+    return () => false;
+  }
+}
+function pathsMatchSource(globs4, sources) {
+  const ms = globs4.map((g) => ({ neg: g.startsWith("!"), m: ghGlob(g.startsWith("!") ? g.slice(1) : g) }));
+  return sources.some((s) => {
+    let on = false;
+    for (const { neg, m } of ms) if (m(s)) on = !neg;
+    return on;
+  });
+}
+var CODE_PROBES = ["src/index.ts", "src/index.js", "lib/index.js", "index.ts", "main.go", "src/main.py", "src/lib.rs", "packages/a/src/index.ts", "test/a.test.ts"];
+function sourceProbes(ctx) {
+  const files = trackedFiles(ctx);
+  if (!files) return CODE_PROBES;
+  const code = files.filter((f) => langOf(f) !== null);
+  return code.length ? code : CODE_PROBES;
+}
+function triggerNarrowings(before, after, opts) {
   const out2 = [];
   if (!before.present || !after.present) return out2;
-  for (const e of ["push", "pull_request", "pull_request_target"]) {
+  const isDefault = (b) => opts.defaultBranch ? b === opts.defaultBranch : DEFAULT_BRANCH.test(b);
+  const namesDefault = (l) => l.some(isDefault);
+  for (const e of CODE_EVENTS) {
     if (before.events.has(e) && !after.events.has(e)) out2.push(`the ${e} trigger was removed \u2014 the workflow no longer runs on it`);
   }
-  for (const [e, list] of after.pathsIgnore) {
+  for (const [e, list2] of after.pathsIgnore) {
     const had = before.pathsIgnore.get(e) ?? [];
-    if (list.some((g) => ALL(g) && !had.includes(g))) out2.push(`on.${e}.paths-ignore now ignores every path \u2014 the workflow never runs on ${e}`);
+    if (list2.some((g) => ALL(g) && !had.includes(g))) out2.push(`on.${e}.paths-ignore now ignores every path \u2014 the workflow never runs on ${e}`);
+  }
+  for (const [e, list2] of after.paths) {
+    if (!CODE_EVENTS.includes(e) || !after.events.has(e)) continue;
+    const had = before.paths.get(e);
+    if (had && !pathsMatchSource(had, opts.sources)) continue;
+    if (!pathsMatchSource(list2, opts.sources)) out2.push(`on.${e}.paths matches no source file (now [${list2.join(", ")}]) \u2014 the workflow never runs on code`);
+  }
+  for (const [e, list2] of after.types) {
+    if (!/^pull_request(?:_target)?$/.test(e) || !after.events.has(e)) continue;
+    const had = before.types.get(e);
+    if (had && !had.some((t) => PR_CODE_TYPES.test(t))) continue;
+    if (!list2.some((t) => PR_CODE_TYPES.test(t))) out2.push(`on.${e}.types no longer includes opened/synchronize (now [${list2.join(", ")}]) \u2014 the workflow does not run on the pull request's code`);
   }
-  for (const [e, list] of after.branchesIgnore) {
+  for (const [e, list2] of after.branchesIgnore) {
     const had = before.branchesIgnore.get(e) ?? [];
-    if (list.some((g) => (ALL(g) || DEFAULT_BRANCH.test(g)) && !had.includes(g))) out2.push(`on.${e}.branches-ignore now covers the default branch`);
+    if (list2.some((g) => (ALL(g) || isDefault(g)) && !had.includes(g))) out2.push(`on.${e}.branches-ignore now covers the default branch`);
   }
   for (const [e, was] of before.branches) {
     const now = after.branches.get(e);
     if (!now || !after.events.has(e)) continue;
     if (now.some(ALL)) continue;
-    const lostDefault = was.some((b) => DEFAULT_BRANCH.test(b) && !now.includes(b));
-    const replaced = was.length > 0 && !was.some((b) => now.includes(b));
+    const lostDefault = namesDefault(was) && !namesDefault(now);
+    const replaced = !namesDefault(was) && !namesDefault(now) && was.length > 0 && !was.some((b) => now.includes(b));
     if (lostDefault || replaced) out2.push(`on.${e}.branches no longer names ${was.filter((b) => !now.includes(b)).join(", ")} (now [${now.join(", ")}])`);
   }
   return out2;
 }
+var REUSED_WORKFLOW = /^\s*uses:\s*\.\/(\.github\/workflows\/[^\s@]+)/;
 var ciTampering = {
   id: RULE5,
   surface: ["file"],
   certainty: "mechanical",
-  run(changes, policy) {
+  run(changes, policy, _view, ctx) {
     const out2 = [];
+    const afterByPath = /* @__PURE__ */ new Map();
+    for (const c of changes) if (c.kind === "file" && c.after != null) afterByPath.set(c.path, c.after);
+    let triggerOpts = null;
     for (const c of changes) {
       if (c.kind !== "file") continue;
       if (c.op === "rename" && c.oldPath && isActiveWorkflow(c.oldPath) && !isActiveWorkflow(c.path)) {
@@ -1907,6 +2294,10 @@ var ciTampering = {
         if (!coe && !cond) continue;
         const step = afterLines && l.newLine != null ? stepOf(afterLines, l.newLine - 1) : null;
         if (afterLines && step && !stepHasCheck(afterLines, step)) continue;
+        if (afterLines && !step && l.newLine != null) {
+          const job = jobOf(afterLines, l.newLine - 1);
+          if (job && !jobHasCheck(afterLines, job)) continue;
+        }
         if (coe && isTruthy(coe[1])) {
           out2.push(
             makeFinding(RULE5, policy, {
@@ -1964,25 +2355,35 @@ var ciTampering = {
           );
         }
         if (c.before != null) {
-          for (const reason of triggerNarrowings(parseTriggers(c.before), parseTriggers(c.after))) {
+          triggerOpts ??= { defaultBranch: defaultBranch(ctx), sources: sourceProbes(ctx) };
+          for (const reason of triggerNarrowings(parseTriggers(c.before), parseTriggers(c.after), triggerOpts)) {
             out2.push(
               makeFinding(RULE5, policy, {
                 file: c.path,
                 message: `The workflow's triggers were narrowed: ${reason}.`,
                 evidence: reason,
-                remediation: "Keep the workflow running on push and pull_request for the default branch; a check that never runs is no check."
+                remediation: "Keep the workflow running on push and pull_request for the default branch and its source paths; a check that never runs is no check."
               })
             );
           }
         }
       }
       const afterCores = (afterLines ?? addedLines(c).map((l) => l.content)).map(commandCore);
+      const addedCores = addedLines(c).map((l) => commandCore(l.content));
+      for (const l of afterLines ?? []) {
+        const reused = l.match(REUSED_WORKFLOW)?.[1];
+        const content = reused ? afterByPath.get(reused) : void 0;
+        if (content == null || reused === c.path) continue;
+        const cores = content.split("\n").map(commandCore);
+        afterCores.push(...cores);
+        addedCores.push(...cores);
+      }
       for (const l of removedLines(c)) {
         if (/^\s*#/.test(l.content)) continue;
         const isUsesLine = USES.test(l.content) && CHECK.test(l.content);
         const isCheckCommand = !isUsesLine && !/^\s*-?\s*uses:/.test(l.content) && (YAML_KEY.test(l.content) ? /^\s*-?\s*run:/.test(l.content) : true) && invokesCheck(l.content);
         if (!isUsesLine && !isCheckCommand) continue;
-        const s = survives(commandCore(l.content), isUsesLine, afterCores);
+        const s = survives(commandCore(l.content), isUsesLine, afterCores, addedCores);
         if (s.state === "kept") continue;
         if (s.state === "neutralised") {
           out2.push(
@@ -1990,7 +2391,7 @@ var ciTampering = {
               file: c.path,
               message: "A CI check command was neutralised in place: it still runs, but its result no longer decides (or its suite was narrowed).",
               evidence: `${l.content.trim()} \u2192 ${s.by}`,
-              remediation: "Let the check decide the step; do not mask its status or narrow what it runs."
+              remediation: "Let the check decide the step; do not mask its status, cut it short, or narrow what it runs."
             })
           );
           continue;
@@ -2010,12 +2411,59 @@ var ciTampering = {
 };
 
 // src/detectors/hook-tampering.ts
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import { isAbsolute, join as join2, relative } from "node:path";
+import { existsSync, readFileSync as readFileSync3 } from "node:fs";
+import { isAbsolute, join as join3, relative } from "node:path";
+
+// src/wiring.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+function shippedVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    for (const rel of ["../package.json", "../../package.json", "../../../package.json"]) {
+      try {
+        const pkg = JSON.parse(readFileSync2(join2(here, rel), "utf8"));
+        if (pkg.name === "tamperward" && pkg.version) return pkg.version;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return "latest";
+}
+var TW_VERSION = shippedVersion();
+var PRE_TOOLS = ["Bash", "Edit", "Write", "MultiEdit", "NotebookEdit"];
+var PRE_MATCHER = PRE_TOOLS.join("|");
+var MARKER = "# tamperward: block agent shortcuts before they land";
+var HOOK_CMD = `npx --yes tamperward@${TW_VERSION} hook claude`;
+var SWEEP_CMD = `npx --yes tamperward@${TW_VERSION} sweep claude`;
+var PRECOMMIT_CMD = `npx --yes tamperward@${TW_VERSION} check --staged`;
+var OURS = /^\s*npx\s+(?:--yes|-y)\s+tamperward(?:@(\S+))?\s+(hook claude|sweep claude|check --staged)\s*$/;
+var PLAIN_SEMVER = /^\d+\.\d+\.\d+$/;
+function compareVersions(a, b) {
+  if (!PLAIN_SEMVER.test(a) || !PLAIN_SEMVER.test(b)) return null;
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) if (pa[i] !== pb[i]) return pa[i] < pb[i] ? -1 : 1;
+  return 0;
+}
+function pinNotBelow(now, floor) {
+  if (!now) return false;
+  const c = compareVersions(now, floor);
+  return c !== null && c >= 0;
+}
+var INIT_SCRIPT = /^#!\/bin\/sh\n# tamperward: block agent shortcuts before they land\nnpx --yes tamperward(?:@(\S+))? check --staged\n?$/;
+function initScriptPin(src) {
+  const m = src.match(INIT_SCRIPT);
+  return m ? m[1] ?? "" : null;
+}
+var CLAUDE_SETTINGS = /(?:^|\/)(?:\.claude\/settings(?:\.local)?\.json|managed-settings\.json)$/;
+var isClaudeSettings = (path) => CLAUDE_SETTINGS.test(path);
 
 // src/detectors/policy-diff.ts
 import { parse } from "yaml";
-var globs = (list) => Array.isArray(list) ? list.filter((g) => typeof g === "string").map(normalizeGlob) : [];
+var globs2 = (list2) => Array.isArray(list2) ? list2.filter((g) => typeof g === "string").map(normalizeGlob) : [];
 function safeParse(src) {
   try {
     const v = parse(src);
@@ -2032,13 +2480,13 @@ function effective(raw) {
   const rules = { ...base.rules };
   for (const [name, cfg] of Object.entries(raw.rules ?? {})) {
     const over = cfg && typeof cfg === "object" && !Array.isArray(cfg) ? cfg : {};
-    rules[name] = { ...rules[name] ?? {}, ...over, ...over.exclude ? { exclude: globs(over.exclude) } : {} };
+    rules[name] = { ...rules[name] ?? {}, ...over, ...over.exclude ? { exclude: globs2(over.exclude) } : {} };
   }
-  const userProtected = raw.protected && typeof raw.protected === "object" ? Object.fromEntries(Object.entries(raw.protected).map(([cat, list]) => [cat, globs(list)])) : void 0;
+  const userProtected = raw.protected && typeof raw.protected === "object" ? Object.fromEntries(Object.entries(raw.protected).map(([cat, list2]) => [cat, globs2(list2)])) : void 0;
   return {
     version,
     rules,
-    ignore: raw.ignore ? globs(raw.ignore) : base.ignore ?? [],
+    ignore: raw.ignore ? globs2(raw.ignore) : base.ignore ?? [],
     protected: mergeProtected(base.protected, userProtected),
     requiredFor: raw.signoff?.required_for ?? raw.signoff?.requiredFor ?? base.signoff.requiredFor,
     ledger: typeof raw.signoff?.ledger === "string" ? raw.signoff.ledger : base.signoff.ledger
@@ -2155,7 +2603,7 @@ var RUNNER = /^(?:npx|pnpm|yarn|bunx|bun|npm)\s+(?:(?:exec|dlx|x|run)\s+)?(?:(?:
 var TOOL = /^(tamperward|jest|vitest|eslint|tsc|lint-staged|lefthook|husky|pytest|make|cargo|go|pre-commit|mypy|ruff|rubocop|prettier|gradlew?)\b/;
 var SCRIPT = /^(test|tests|lint|typecheck|type-check|coverage|check)\b/;
 var SUBCOMMAND_TOOLS = /* @__PURE__ */ new Set(["tamperward", "make", "cargo", "go", "lefthook", "husky", "pre-commit"]);
-var PREFIX = /^(?:(?:then|do|else|\{|\(|!|exec|command|time|nice|env|sudo|[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"(?=\s|$)|'[^']*'(?=\s|$)|[^\s"']\S*|(?=\s)))\s+)*/;
+var PREFIX = /^(?:(?:then|do|else|\{|\(|exec|command|time|nice|env|sudo|[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"(?=\s|$)|'[^']*'(?=\s|$)|[^\s"']\S*|(?=\s)))\s+)*/;
 function checkIdentity(segment) {
   const core = segment.trim().replace(PREFIX, "").replace(/\s+/g, " ");
   const viaRunner = RUNNER.test(core);
@@ -2166,20 +2614,49 @@ function checkIdentity(segment) {
   if (tool === "tamperward") {
     const sub = toks[1];
     if (!sub || sub.startsWith("-")) return null;
-    return `tamperward ${sub}`;
+    const cwd = rest.match(/\s--cwd(?:=|\s+)(\S+)/)?.[1];
+    return cwd ? `tamperward ${sub} --cwd ${cwd}` : `tamperward ${sub}`;
   }
   if (SUBCOMMAND_TOOLS.has(tool) && toks[1] && !toks[1].startsWith("-")) return `${tool} ${toks[1]}`;
   return tool;
 }
+function pinOfSegment(segment) {
+  const m = segment.trim().replace(PREFIX, "").replace(RUNNER, "").match(/^tamperward(?:@(\S+))?\b/);
+  return m ? m[1] ?? "" : null;
+}
 function split(stmt) {
   const segs = [];
   const ops = [];
-  const re = /(&&|\|\||;|\|)/g;
+  let depth = 0;
+  let single = false;
+  let double = false;
   let last = 0;
-  for (const m of stmt.matchAll(re)) {
-    segs.push(stmt.slice(last, m.index));
-    ops.push(m[1]);
-    last = (m.index ?? 0) + m[1].length;
+  for (let i = 0; i < stmt.length; i++) {
+    const ch = stmt[i];
+    if (ch === "'" && !double) {
+      single = !single;
+      continue;
+    }
+    if (ch === '"' && !single) {
+      double = !double;
+      continue;
+    }
+    if (single || double) continue;
+    if (ch === "(" || ch === "{" && /(?:^|\s)$/.test(stmt.slice(0, i)) && /^(?:\s|$)/.test(stmt.slice(i + 1))) {
+      depth++;
+      continue;
+    }
+    if (ch === ")" || ch === "}" && depth > 0 && /(?:^|[\s;])$/.test(stmt.slice(0, i))) {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (depth > 0) continue;
+    const op = stmt.startsWith("&&", i) ? "&&" : stmt.startsWith("||", i) ? "||" : ch === ";" ? ";" : ch === "|" ? "|" : null;
+    if (!op) continue;
+    segs.push(stmt.slice(last, i));
+    ops.push(op);
+    i += op.length - 1;
+    last = i + 1;
   }
   segs.push(stmt.slice(last));
   return { segs, ops };
@@ -2228,106 +2705,602 @@ function alwaysFalse(cond) {
   if (/^(?:""|'')$/.test(inner)) return true;
   return false;
 }
-var alwaysTrue = (cond) => /^(?:true|:|\[\s+1\s+-eq\s+1\s+\]|\[\s+-n\s+"?\S"?\s+\])$/.test(cond.trim().replace(/;$/, "").trim());
+var alwaysTrue = (cond) => {
+  const c = cond.trim().replace(/;$/, "").trim();
+  if (/^(?:true|:|!\s*false|\(\s*exit\s+0*\s*\))$/.test(c)) return true;
+  const m = c.match(/^(?:\[\[\s+(.+?)\s+\]\]|\[\s+(.+?)\s+\]|test\s+(.+))$/);
+  if (!m) return false;
+  const inner = (m[1] ?? m[2] ?? m[3]).trim();
+  if (inner.includes("$")) return false;
+  const parts = inner.match(/^(\S+)\s+(-eq|-ne|-lt|-le|-gt|-ge|=|==|!=)\s+(\S+)$/);
+  if (parts) {
+    const ints = /^-?\d+$/.test(unq(parts[1])) && /^-?\d+$/.test(unq(parts[3]));
+    if (parts[2].startsWith("-") && !ints) return false;
+    return !alwaysFalse(c);
+  }
+  if (/^(?:-n|-z)\s+\S+$/.test(inner)) return !alwaysFalse(c);
+  if (/^\S+$/.test(inner)) return unq(inner) !== "";
+  return false;
+};
 var EXIT_ZERO = /^(?:exit|return)(?:\s+0+)?$/;
 var EXIT_ANY = /^(?:exit|return)(?:\s+\S+)?$/;
-var FAILS_LOUDLY = /\b(?:exit|return)\s+(?:[1-9]\d*|"?\$\?"?|"?\$\{?[A-Za-z_]\w*\}?"?)(?=[\s;})]|$)|\bfalse\b|\bkill\b|\bexit\s*$|\breturn\s*$/;
 function insertsPassingExit(line) {
   if (isComment(line)) return false;
-  return split(stripComment(line)).segs.some((s) => EXIT_ZERO.test(s.trim().replace(PREFIX, "")));
+  return split(stripComment(line)).segs.some((s) => EXIT_ZERO.test(s.trim().replace(/^!\s+/, "").replace(PREFIX, "")));
 }
 function insertsDeadGuard(line) {
   if (isComment(line)) return false;
   const m = stripComment(line).trim().match(/^(?:if|elif)\s+(.+?)\s*(?:;\s*then)?\s*$/);
   return !!m && alwaysFalse(m[1]);
 }
-function invocations(lines) {
+function joinContinued(lines) {
   const out2 = [];
-  const pipefail = lines.some((l) => /\bpipefail\b/.test(stripComment(l)));
-  const frames = [{ dead: false }];
+  let cur = null;
+  for (const l of lines) {
+    cur = cur === null ? l : cur + " " + l.trimStart();
+    const m = cur.match(/(\\+)$/);
+    if (m && m[1].length % 2 === 1 && !isComment(cur)) {
+      cur = cur.slice(0, -1);
+      continue;
+    }
+    out2.push(cur);
+    cur = null;
+  }
+  if (cur !== null) out2.push(cur);
+  return out2;
+}
+function stripHeredocs(lines) {
+  const out2 = [];
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i];
+    out2.push(l);
+    if (isComment(l)) continue;
+    const m = stripComment(l).match(/<<(-?)\s*(?:'([^']+)'|"([^"]+)"|\\?([A-Za-z_]\w*))/);
+    if (!m) continue;
+    const word = m[2] ?? m[3] ?? m[4];
+    const dash = m[1] === "-";
+    for (i++; i < lines.length; i++) {
+      const t = dash ? lines[i].replace(/^\t+/, "") : lines[i];
+      if (t === word) break;
+    }
+  }
+  return out2;
+}
+function explodeKeywords(line) {
+  if (isComment(line)) return [line];
+  let s = stripComment(line);
+  s = s.replace(/;;/g, "\n;;");
+  s = s.replace(/;\s*(then|do|fi|done|esac|else|elif)\b/g, "\n$1");
+  s = s.replace(/^(\s*case\s+\S+\s+in)\s+(?=\S)/, "$1\n");
+  s = s.replace(/^(\s*)(then|do|else)\s+(?=\S)/, "$1$2\n");
+  s = s.replace(/\n(then|do|else)\s+(?=\S)/g, "\n$1\n");
+  return s.split("\n");
+}
+function closingBrace(line, depth) {
+  let single = false;
+  let double = false;
+  let expansion = 0;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === "'" && !double) single = !single;
+    else if (ch === '"' && !single) double = !double;
+    else if (single) continue;
+    else if (ch === "$" && line[i + 1] === "{") {
+      expansion++;
+      i++;
+    } else if (ch === "}" && expansion > 0) expansion--;
+    else if (ch === "{" && !double) depth++;
+    else if (ch === "}" && !double && --depth === 0) return i;
+  }
+  return -1;
+}
+function braceDelta(line) {
+  let d = 0;
+  let single = false;
+  let double = false;
+  let expansion = 0;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === "'" && !double) single = !single;
+    else if (ch === '"' && !single) double = !double;
+    else if (single) continue;
+    else if (ch === "$" && line[i + 1] === "{") {
+      expansion++;
+      i++;
+    } else if (ch === "}" && expansion > 0) expansion--;
+    else if (ch === "{" && !double) d++;
+    else if (ch === "}" && !double) d--;
+  }
+  return d;
+}
+var FN_DEF = /^\s*(?:function\s+)?([A-Za-z_][\w-]*)\s*\(\s*\)\s*(.*)$|^\s*function\s+([A-Za-z_][\w-]*)\s*(\{.*)?$/;
+function prepare(lines, opts) {
+  const flat = stripHeredocs(joinContinued(lines)).flatMap(explodeKeywords);
+  const top = [];
+  const fns = /* @__PURE__ */ new Map();
+  const shadowed = /* @__PURE__ */ new Set();
+  let errexit = opts.errexit ?? false;
+  let pipefail = false;
+  if (flat[0]?.startsWith("#!")) {
+    const sb = flat[0];
+    if (/\s-[a-zA-Z]*e[a-zA-Z]*(?:\s|$)/.test(sb)) errexit = true;
+    if (/-[a-zA-Z]*o\s+pipefail\b/.test(sb)) pipefail = true;
+  }
+  for (let i = 0; i < flat.length; i++) {
+    const raw = flat[i];
+    if (isComment(raw)) {
+      top.push(raw);
+      continue;
+    }
+    const stmt = stripComment(raw).trim();
+    const al = stmt.match(/^alias\s+([A-Za-z_][\w-]*)=/);
+    if (al) shadowed.add(al[1]);
+    const def = stmt.match(FN_DEF);
+    if (!def) {
+      top.push(raw);
+      continue;
+    }
+    const name = def[1] ?? def[3];
+    shadowed.add(name);
+    let rest = (def[2] ?? def[4] ?? "").trim();
+    if (rest === "" && /^\s*\{/.test(flat[i + 1] ?? "")) {
+      i++;
+      rest = flat[i].trim();
+    }
+    const body = [];
+    if (!rest.startsWith("{")) {
+      fns.set(name, body);
+      continue;
+    }
+    rest = rest.slice(1);
+    const after = (line, close2) => {
+      const t = line.slice(0, close2);
+      if (t.trim()) body.push(t);
+      const remainder = line.slice(close2 + 1).replace(/^\s*;?\s*/, "");
+      if (remainder.trim()) top.push(remainder);
+    };
+    let close = closingBrace(rest, 1);
+    if (close !== -1) {
+      after(rest, close);
+    } else {
+      if (rest.trim()) body.push(rest);
+      let depth = 1 + braceDelta(rest);
+      for (i++; i < flat.length; i++) {
+        const line = isComment(flat[i]) ? "" : stripComment(flat[i]);
+        close = closingBrace(line, depth);
+        if (close !== -1) {
+          after(line, close);
+          break;
+        }
+        depth += braceDelta(line);
+        body.push(flat[i]);
+      }
+    }
+    fns.set(name, body);
+  }
+  return { top, fns, shadowed, pipefail, errexit };
+}
+var TRANSPARENT = /^(?:fi|done|esac|\}|\)|;;|then|do|else|exit\s+"?\$\??"?|exit\s+"?\$\{\?\}"?)\s*;?$/;
+function statusAfterFailure(seg, vars) {
+  const inner = seg.trim().replace(/^[{(]\s*/, "").replace(/\s*[})]\s*;?\s*$/, "");
+  let status = "fail";
+  for (const piece of inner.split(/;|&&|\|\||\|/)) {
+    const w = piece.trim().replace(PREFIX, "").split(/\s+/);
+    switch (w[0]) {
+      case "":
+        break;
+      case "true":
+      case ":":
+        status = "ok";
+        break;
+      case "false":
+        status = "fail";
+        break;
+      case "kill":
+        status = w[1] === "-0" ? "ok" : "exit";
+        break;
+      case "exit":
+      case "return": {
+        const arg = unq(w[1] ?? "");
+        if (arg === "" || arg === "$?" || arg === "${?}") return status === "ok" ? "ok" : "exit";
+        if (/^0+$/.test(arg)) return "ok";
+        if (/^[1-9]\d*$/.test(arg)) return "exit";
+        const v = arg.match(/^\$\{?([A-Za-z_]\w*)\}?$/);
+        const known = v ? vars.get(v[1]) : void 0;
+        return known !== void 0 && /^0+$/.test(known) ? "ok" : "exit";
+      }
+      default:
+        status = "ok";
+    }
+  }
+  return status;
+}
+function constStatus(seg) {
+  const s = seg.trim().replace(/^!\s+/, "");
+  if (alwaysTrue(s)) return "ok";
+  if (alwaysFalse(s)) return "fail";
+  return "unknown";
+}
+function reaches(segs, ops, i) {
+  let status = "ok";
+  let certain = true;
+  for (let j = 0; j < i; j++) {
+    const runs = j === 0 ? true : ops[j - 1] === "&&" ? status !== "fail" : ops[j - 1] === "||" ? status !== "ok" : true;
+    if (!runs) continue;
+    const s = constStatus(segs[j]);
+    if (s === "unknown" && (ops[j] === "&&" || ops[j] === "||")) certain = false;
+    if (ops[j] === ";" || ops[j] === "|") {
+      status = "ok";
+      certain = certain && true;
+      continue;
+    }
+    status = s;
+  }
+  const gate = i === 0 ? true : ops[i - 1] === "&&" ? status !== "fail" : ops[i - 1] === "||" ? status !== "ok" : true;
+  if (!gate) return "no";
+  if (i === 0 || ops[i - 1] === ";" || ops[i - 1] === "|") return "yes";
+  if (!certain || status === "unknown") return "maybe";
+  return "yes";
+}
+function literal(arg, vars) {
+  const a = unq(arg.trim());
+  if (/[`]|\$\(/.test(a)) return null;
+  let unknown = false;
+  const r = a.replace(/\$\{?([A-Za-z_]\w*)\}?/g, (_, n) => {
+    const v = vars.get(n);
+    if (v === void 0) unknown = true;
+    return v ?? "";
+  });
+  return unknown ? null : r;
+}
+function cdStaysHome(arg, vars) {
+  const a = arg.trim();
+  if (/rev-parse\s+--show-toplevel/.test(a)) return true;
+  const lit = literal(a, vars);
+  if (lit === null) return null;
+  return lit === "" || lit === "." || lit === "./";
+}
+function walk(lines, st, topIdx, depth) {
+  const frames = [{ dead: false, exhausted: false, kind: "base" }];
   const dead = () => frames.some((f) => f.dead);
-  for (const raw of lines) {
+  const conditional = () => frames.length > 1;
+  let exits = false;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const idx = topIdx(i);
     if (isComment(raw)) {
       const id = checkIdentity(raw.replace(/^\s*#+\s*/, ""));
-      if (id) out2.push({ identity: id, line: raw, state: "comment" });
+      if (id) st.out.push({ identity: id, line: raw, state: "comment", idx, errexit: st.errexit, passthrough: false });
       continue;
     }
-    const stmt = stripComment(raw).trim();
+    let stmt = stripComment(raw).trim();
     if (!stmt) continue;
-    const ifm = stmt.match(/^(if|elif)\s+(.+?)\s*(?:;\s*then)?\s*$/);
+    const ifm = stmt.match(/^(if|elif)\s+(.+)$/);
     if (ifm) {
-      if (ifm[1] === "if") frames.push({ dead: alwaysFalse(ifm[2]) });
-      else if (frames.length > 1) frames[frames.length - 1].dead = alwaysFalse(ifm[2]);
+      const cond = ifm[2].replace(/;\s*$/, "");
+      const cid = checkIdentity(cond.replace(/^!\s+/, ""));
+      if (cid) st.out.push({ identity: cid, line: raw, state: dead() ? "unreachable" : "neutered", why: "used as an `if` condition \u2014 its failure selects a branch instead of failing the hook", idx, errexit: st.errexit, passthrough: false });
+      if (ifm[1] === "if") frames.push({ dead: alwaysFalse(cond), exhausted: alwaysTrue(cond), kind: "if" });
+      else if (frames.length > 1) {
+        const f = frames[frames.length - 1];
+        f.dead = f.exhausted || alwaysFalse(cond);
+        f.exhausted = f.exhausted || alwaysTrue(cond);
+      }
       continue;
     }
     if (/^else\b/.test(stmt)) {
-      if (frames.length > 1) frames[frames.length - 1].dead = false;
+      if (frames.length > 1) {
+        const f = frames[frames.length - 1];
+        f.dead = f.exhausted;
+      }
       continue;
     }
-    if (/^fi\b/.test(stmt)) {
+    if (/^(?:fi|done|esac)\b/.test(stmt)) {
       if (frames.length > 1) frames.pop();
       continue;
     }
+    if (/^(?:then|do)\b/.test(stmt)) continue;
+    const loop = stmt.match(/^(while|until)\s+(.+)$/);
+    if (loop) {
+      const cond = loop[2].replace(/;\s*$/, "");
+      frames.push({ dead: loop[1] === "while" ? alwaysFalse(cond) : alwaysTrue(cond), exhausted: false, kind: "loop" });
+      continue;
+    }
+    const forl = stmt.match(/^for\s+[A-Za-z_]\w*(?:\s+in\b(.*))?$/);
+    if (forl) {
+      const list2 = (forl[1] ?? "$@").replace(/;\s*$/, "").trim();
+      frames.push({ dead: forl[1] !== void 0 && (list2 === "" || /^(?:""|'')$/.test(list2)), exhausted: false, kind: "loop" });
+      continue;
+    }
+    const casem = stmt.match(/^case\s+(\S+)\s+in\b/);
+    if (casem) {
+      frames.push({ dead: false, exhausted: false, kind: "case", word: unq(casem[1]) });
+      continue;
+    }
+    const pat = frames[frames.length - 1].kind === "case" ? stmt.match(/^\(?([^()]+)\)\s*(.*)$/) : null;
+    if (pat) {
+      const f = frames[frames.length - 1];
+      const word = f.word ?? "";
+      const patterns = pat[1].split("|").map((p) => unq(p.trim()));
+      const may = /[$`]/.test(word) || patterns.some((p) => p === "*" || /[$`*?[]/.test(p) || p === word);
+      f.dead = !may;
+      stmt = pat[2].trim();
+      if (!stmt) continue;
+    }
+    if (/^;;$/.test(stmt)) continue;
+    if (/^[{}()]$/.test(stmt)) continue;
+    const bg = /(?<!&)&\s*$/.test(stmt) && !/&&\s*$/.test(stmt);
+    if (bg) stmt = stmt.replace(/\s*&\s*$/, "");
     const { segs, ops } = split(stmt);
-    for (let i = 0; i < segs.length; i++) {
-      const seg = segs[i].trim().replace(PREFIX, "");
+    for (let s = 0; s < segs.length; s++) {
+      let seg = segs[s].trim();
+      const inverted = /^!\s+/.test(seg);
+      seg = seg.replace(/^!\s+/, "");
+      const execs = /^exec\s+/.test(seg) && !/^exec\s+(?:\d*[<>]|&>)/.test(seg);
+      seg = seg.replace(PREFIX, "");
+      const reach = dead() ? "no" : reaches(segs, ops, s);
+      const first = seg.split(/\s+/)[0] ?? "";
+      if (reach !== "no") {
+        const certain = reach === "yes" && !conditional();
+        const set = seg.match(/^set\s+(.+)$/);
+        if (set) {
+          const toks = set[1].split(/\s+/);
+          for (let t = 0; t < toks.length; t++) {
+            const m = toks[t].match(/^([-+])([a-zA-Z]+)$/);
+            if (!m) continue;
+            const on = m[1] === "-";
+            const flip = (cur) => on ? certain ? true : cur : false;
+            if (m[2].includes("e")) st.errexit = flip(st.errexit);
+            if (m[2].includes("o")) {
+              const name = toks[++t];
+              if (name === "errexit") st.errexit = flip(st.errexit);
+              if (name === "pipefail") st.pipefail = flip(st.pipefail);
+            }
+          }
+        }
+        const trap = seg.match(/^trap\s+(?:'([^']*)'|"([^"]*)"|(\S+))\s+(.+)$/);
+        if (trap) {
+          const action = trap[1] ?? trap[2] ?? trap[3];
+          const sigs = trap[4].split(/\s+/);
+          if (sigs.some((x) => /^(?:EXIT|ERR|0|SIGERR)$/i.test(x)) && /(?:^|[;\s])(?:exit(?:\s+0+)?|true|:)\s*(?:;|$)/.test(action)) st.traps.push(idx);
+        }
+        const asg = seg.match(/^(?:export\s+|readonly\s+)?([A-Za-z_]\w*)=(.*)$/);
+        if (asg) {
+          const v = certain ? literal(asg[2], st.vars) : null;
+          if (v === null) st.vars.delete(asg[1]);
+          else st.vars.set(asg[1], v);
+        }
+        if (first === "cd") {
+          const home = cdStaysHome(seg.slice(2), st.vars);
+          if (home === false) st.cdAway = true;
+          else if (home === true && certain) st.cdAway = false;
+        }
+      }
       const id = checkIdentity(seg);
       if (!id) {
-        if (EXIT_ANY.test(seg) && !dead() && (i === 0 || ops[i - 1] === ";")) frames[frames.length - 1].dead = true;
+        if (reach === "yes") {
+          if (EXIT_ANY.test(seg)) {
+            if (!conditional()) {
+              frames[0].dead = true;
+              if (/^exit\b/.test(seg)) exits = true;
+            } else if (/^exit\b/.test(seg) && depth > 0) {
+            }
+          } else if (execs && !conditional()) {
+            frames[0].dead = true;
+          } else if (st.fns.has(first) && reach === "yes") {
+            const start = st.out.length;
+            const body = st.fns.get(first) ?? [];
+            const sub = { ...st, out: st.out };
+            const fnExits = depth < 6 && walk(body, sub, () => idx, depth + 1);
+            st.errexit = sub.errexit;
+            st.pipefail = sub.pipefail;
+            st.cdAway = sub.cdAway;
+            const verdict2 = chainVerdict(segs, ops, s, st, inverted, bg);
+            for (let k = start; k < st.out.length; k++) {
+              const inv = st.out[k];
+              if (inv.state === "live" && verdict2.state !== "live") {
+                inv.state = verdict2.state;
+                inv.why = verdict2.why;
+              }
+              if (inv.state === "live") inv.passthrough = inv.passthrough && verdict2.passthrough;
+            }
+            if (fnExits && !conditional()) {
+              frames[0].dead = true;
+              exits = true;
+            }
+          }
+        } else if (reach === "maybe" && st.fns.has(first)) {
+          const start = st.out.length;
+          const sub = { ...st, out: st.out };
+          if (depth < 6) walk(st.fns.get(first) ?? [], sub, () => idx, depth + 1);
+          const verdict2 = chainVerdict(segs, ops, s, st, inverted, bg);
+          for (let k = start; k < st.out.length; k++) {
+            const inv = st.out[k];
+            if (inv.state === "live" && verdict2.state !== "live") {
+              inv.state = verdict2.state;
+              inv.why = verdict2.why;
+            }
+          }
+        }
         continue;
       }
-      let state = dead() ? "unreachable" : "live";
-      if (state === "live" && i > 0) {
-        if (ops[i - 1] === "&&" && alwaysFalse(segs[i - 1])) state = "unreachable";
-        if (ops[i - 1] === "||" && alwaysTrue(segs[i - 1])) state = "unreachable";
-      }
-      if (state === "live" && i < ops.length) {
-        const after = segs.slice(i + 1).join(" ");
-        if (ops[i] === "||" && !FAILS_LOUDLY.test(after)) state = "neutered";
-        else if (ops[i] === "|" && !pipefail) state = "neutered";
-        else if (ops[i] === ";" && segs.slice(i + 1).some((s) => /^(?:true|:)$/.test(s.trim()) || EXIT_ZERO.test(s.trim()))) state = "neutered";
+      let state = "live";
+      let why;
+      let passthrough = false;
+      if (reach === "no") {
+        state = "unreachable";
+        why = dead() ? "behind an always-false guard, an early exit, or a function body that is never called" : "behind a constant condition";
+      } else {
+        const v = chainVerdict(segs, ops, s, st, inverted, bg);
+        state = v.state;
+        why = v.why;
+        passthrough = v.passthrough;
+        if (state === "live" && /^tamperward\b/.test(id) && st.cdAway) {
+          state = "neutered";
+          why = "runs from another directory after a `cd` away from the repository root";
+        }
+        if (state === "live") {
+          const words2 = [first, "tamperward"].filter((w) => w && st.shadowed.has(w));
+          if (words2.length) {
+            state = "neutered";
+            why = `\`${words2[0]}\` is redefined by a function or alias in this script`;
+          }
+        }
       }
-      out2.push({ identity: id, line: raw, state });
+      const pin = pinOfSegment(seg);
+      st.out.push({ identity: id, line: raw, state, why, idx, errexit: st.errexit, passthrough, ...pin !== null ? { pin } : {} });
     }
   }
-  return out2;
+  return exits;
+}
+function chainVerdict(segs, ops, i, st, inverted, bg) {
+  if (inverted) return { state: "neutered", why: "its status is inverted by `!`", passthrough: false };
+  if (bg) return { state: "neutered", why: "run in the background \u2014 the hook does not wait for its status", passthrough: false };
+  let cur = "fail";
+  for (let j = i; j < ops.length; j++) {
+    const op = ops[j];
+    const next = segs[j + 1];
+    if (op === "|") {
+      if (!st.pipefail) return { state: "neutered", why: "piped into another command without `pipefail`", passthrough: false };
+      continue;
+    }
+    if (cur === "exit") break;
+    if (op === "||") {
+      if (cur === "fail") cur = statusAfterFailure(next, st.vars);
+    } else if (op === "&&") {
+      if (cur === "ok") cur = statusAfterFailure(next, st.vars);
+    } else if (op === ";") {
+      const rest = segs.slice(j + 1).map((x) => x.trim());
+      if (st.errexit && cur === "fail") {
+        if (rest.some((x) => /^(?:true|:)$/.test(x) || EXIT_ZERO.test(x))) return { state: "neutered", why: "followed by a passing statement in the same line", passthrough: false };
+        return { state: "live", passthrough: false };
+      }
+      if (rest.every((x) => TRANSPARENT.test(x))) return { state: cur === "fail" ? "live" : "neutered", why: cur === "fail" ? void 0 : "the `||` chain after it ends in success", passthrough: cur === "fail" };
+      return { state: "neutered", why: "followed by other statements whose status replaces it (no `set -e`)", passthrough: false };
+    }
+  }
+  if (cur === "ok") return { state: "neutered", why: "the `||` chain after it ends in success", passthrough: false };
+  if (cur === "exit") return { state: "live", passthrough: false };
+  return { state: "live", passthrough: i === ops.length || ops.slice(i).every((o) => o === "&&" || o === "||") };
+}
+function invocations(lines, opts = {}) {
+  const prep = prepare(lines, opts);
+  const st = {
+    errexit: prep.errexit,
+    pipefail: prep.pipefail,
+    cdAway: false,
+    vars: /* @__PURE__ */ new Map(),
+    fns: prep.fns,
+    shadowed: prep.shadowed,
+    traps: [],
+    out: [],
+    lastReal: -1
+  };
+  for (let i = 0; i < prep.top.length; i++) {
+    const t = stripComment(prep.top[i]).trim();
+    if (t && !isComment(prep.top[i]) && !TRANSPARENT.test(t)) st.lastReal = i;
+  }
+  walk(prep.top, st, (i) => i, 0);
+  const seen = new Set(st.out.map((o) => o.line));
+  for (const [, body] of prep.fns) {
+    const sub = { ...st, out: [], traps: [] };
+    walk(body, sub, () => -1, 1);
+    for (const inv of sub.out) if (!seen.has(inv.line) && inv.state !== "comment") st.out.push({ ...inv, state: "unreachable", why: "defined in a function that is never called" });
+  }
+  return st.out.map((inv) => {
+    if (inv.state !== "live") return strip(inv);
+    if (st.traps.some((t) => t < inv.idx) || !inv.errexit && st.traps.some((t) => t > inv.idx)) {
+      return strip({ ...inv, state: "neutered", why: "a `trap` on EXIT/ERR exits 0 whatever the gate returned" });
+    }
+    if (inv.passthrough && !inv.errexit && inv.idx !== -1 && inv.idx < st.lastReal) {
+      return strip({ ...inv, state: "neutered", why: "without `set -e` its failure does not fail the hook \u2014 other statements run after it" });
+    }
+    return strip(inv);
+  });
 }
-function scriptWeakening(before, after) {
+var strip = (inv) => {
+  const { idx: _i, errexit: _e, passthrough: _p, ...rest } = inv;
+  return rest;
+};
+function scriptWeakening(before, after, opts = {}) {
+  const beforeInv = invocations(before, opts);
+  const afterInv = invocations(after, opts);
   const live = (inv) => new Set(inv.filter((i) => i.state === "live").map((i) => i.identity));
-  const bl = live(invocations(before));
-  const afterInv = invocations(after);
+  const bl = live(beforeInv);
   const al = live(afterInv);
   const out2 = [];
   for (const id of bl) {
     if (al.has(id)) continue;
-    const trace = afterInv.find((i) => i.identity === id);
-    const how = trace?.state === "neutered" ? "neutralised in place (its failure can no longer fail the hook)" : trace?.state === "unreachable" ? "made unreachable (behind an always-false guard or an early exit)" : trace?.state === "comment" ? "commented out" : "removed";
-    const evidence = (trace?.line ?? before.find((l) => checkIdentity(stripComment(l).trim().replace(PREFIX, "")) === id) ?? id).trim();
+    const trace = afterInv.find((i) => i.identity === id) ?? afterInv.find((i) => i.identity.split(" --cwd ")[0] === id.split(" --cwd ")[0]);
+    const how = trace?.state === "neutered" ? `neutralised in place (${trace.why ?? "its failure can no longer fail the hook"})` : trace?.state === "unreachable" ? `made unreachable (${trace.why ?? "behind an always-false guard or an early exit"})` : trace?.state === "comment" ? "commented out" : trace && trace.identity !== id ? `replaced by \`${trace.identity}\`` : "removed";
+    const evidence = (trace?.line ?? before.find((l) => checkIdentity(stripComment(l).trim().replace(/^!\s+/, "").replace(PREFIX, "")) === id) ?? id).trim();
     out2.push({ reason: `the check invocation \`${id}\` was ${how}`, evidence });
   }
+  const floor = beforeInv.filter((i) => i.state === "live" && i.pin && PLAIN_SEMVER.test(i.pin)).map((i) => i.pin).sort((a, b) => compareVersions(a, b) ?? 0)[0];
+  if (floor) {
+    for (const inv of afterInv) {
+      if (inv.state !== "live" || !inv.pin || !PLAIN_SEMVER.test(inv.pin)) continue;
+      if ((compareVersions(inv.pin, floor) ?? 0) < 0) out2.push({ reason: `the gate's pin was lowered from ${floor} to ${inv.pin}`, evidence: inv.line.trim() });
+    }
+  }
   return out2;
 }
+function shebangProblem(src) {
+  const first = src.split("\n")[0] ?? "";
+  if (!first.startsWith("#!")) return null;
+  const body = first.slice(2).trim();
+  const toks = body.split(/\s+/);
+  let i = 0;
+  if (/(?:^|\/)env$/.test(toks[0] ?? "")) {
+    i = 1;
+    while (i < toks.length && toks[i].startsWith("-")) i++;
+  }
+  const interp = (toks[i] ?? "").replace(/^.*\//, "");
+  if (!/^(?:sh|bash|dash|zsh|ksh|ash|busybox)$/.test(interp)) return `the shebang runs \`${body}\`, not a shell`;
+  if (toks.slice(i + 1).some((t) => /^-[a-zA-Z]*c/.test(t))) return `the shebang passes \`-c\` \u2014 the interpreter runs the argument, not the script`;
+  return null;
+}
 var isCodeowners = (path) => /(?:^|\/)CODEOWNERS$/.test(path);
 var GATE_CRITICAL = [
-  "/.github/workflows/",
+  "/.github/workflows/tamperward.yml",
   "/.tamperward.yml",
   "/.github/CODEOWNERS",
   "/CODEOWNERS",
   "/docs/CODEOWNERS",
-  "/.husky/",
+  "/.husky/pre-commit",
   "/.claude/settings.json",
   "/.claude/settings.local.json",
   "/.pre-commit-config.yaml",
   "/lefthook.yml",
   "/lefthook.yaml"
 ];
-function covers(pattern, critical) {
-  if (pattern === "*" || pattern === "**") return true;
-  let p = pattern.replace(/\/\*\*$/, "/").replace(/\/\*$/, "/");
-  if (!p.startsWith("/")) p = "/" + p;
-  if (p === critical) return true;
-  if (p.endsWith("/") && critical.startsWith(p)) return true;
-  return critical.startsWith(p + "/");
+function codeownersMatcher(pattern) {
+  let p = pattern.trim();
+  if (p === "*" || p === "**") return () => true;
+  let anchored = p.startsWith("/");
+  if (anchored) p = p.slice(1);
+  const dir = p.endsWith("/");
+  p = p.replace(/\/+$/, "");
+  if (p.includes("/")) anchored = true;
+  if (p.startsWith("**/")) {
+    anchored = false;
+    p = p.slice(3);
+  }
+  let re = "";
+  for (let i = 0; i < p.length; i++) {
+    const ch = p[i];
+    if (ch === "*") {
+      if (p[i + 1] === "*") {
+        re += ".*";
+        i++;
+      } else re += "[^/]*";
+    } else if (ch === "?") re += "[^/]";
+    else re += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  const body = (anchored ? "^/" : "(?:^|/)") + re;
+  const exact = new RegExp(body + "$");
+  const under = new RegExp(body + "/");
+  return (file) => !dir && exact.test(file) || under.test(file);
 }
 function ownersOf(content, critical) {
   let owners = null;
@@ -2335,13 +3308,20 @@ function ownersOf(content, critical) {
     const t = line.trim();
     if (!t || t.startsWith("#")) continue;
     const [pattern, ...rest] = t.split(/\s+/);
-    if (covers(pattern, critical)) owners = rest.filter((o) => !o.startsWith("#"));
+    let matches;
+    try {
+      matches = codeownersMatcher(pattern)(critical);
+    } catch {
+      matches = false;
+    }
+    if (matches) owners = rest.filter((o) => !o.startsWith("#"));
   }
   return owners;
 }
-function codeownersWeakening(before, after) {
+function codeownersWeakening(before, after, extra = []) {
   const out2 = [];
-  for (const critical of GATE_CRITICAL) {
+  const files = [.../* @__PURE__ */ new Set([...GATE_CRITICAL, ...extra.map((f) => f.startsWith("/") ? f : "/" + f)])];
+  for (const critical of files) {
     const was = ownersOf(before, critical);
     if (!was || was.length === 0) continue;
     const now = ownersOf(after, critical);
@@ -2360,25 +3340,47 @@ function parseDoc(src) {
   }
 }
 var isLefthook = (path) => /(?:^|\/)\.?lefthook(?:-local)?\.(?:ya?ml|toml|json)$/.test(path);
+var isLefthookLocal = (path) => /(?:^|\/)\.?lefthook-local\.(?:ya?ml|toml|json)$/.test(path);
 var isPreCommitConfig = (path) => /(?:^|\/)\.pre-commit-config\.ya?ml$/.test(path);
 var isPackageJson = (path) => /(?:^|\/)package\.json$/.test(path);
 var GATE = /\btamperward\b/;
 var str = (v) => typeof v === "string" ? v : Array.isArray(v) ? v.map(String).join(" ") : v == null ? "" : JSON.stringify(v);
+var list = (v) => Array.isArray(v) ? v.map(String) : typeof v === "string" ? v.split(/[\s,]+/).filter(Boolean) : [];
+function runsGate(command) {
+  return invocations([command], { errexit: true }).some((i) => i.state === "live" && /^tamperward check\b/.test(i.identity));
+}
+function mergeDocs(base, over) {
+  const out2 = { ...base };
+  for (const [k, v] of Object.entries(over)) {
+    const b = out2[k];
+    out2[k] = isDoc(b) && isDoc(v) ? mergeDocs(b, v) : v;
+  }
+  return out2;
+}
+var off = (v) => v === void 0 || v === null || v === false;
 function lefthookEntries(doc) {
   const out2 = /* @__PURE__ */ new Map();
   for (const [section, v] of Object.entries(doc)) {
     if (!isDoc(v)) continue;
+    const sectionExclude = list(v.exclude_tags);
     for (const group of ["commands", "scripts"]) {
       const g = v[group];
       if (!isDoc(g)) continue;
       for (const [name, cfg] of Object.entries(g)) {
-        if (!isDoc(cfg) || !GATE.test(str(cfg.run ?? cfg.runner))) continue;
+        if (!isDoc(cfg)) continue;
+        const run = cfg.run ?? cfg.runner;
+        const named = GATE.test(name);
+        if (!GATE.test(str(run)) && !named) continue;
+        const tags = list(cfg.tags);
         out2.set(`${section}.${group}.${name}`, {
+          live: run === void 0 ? named : runsGate(str(run)),
           skip: cfg.skip,
+          only: cfg.only,
           sectionSkip: v.skip,
+          sectionOnly: v.only,
           glob: str(cfg.glob),
           exclude: str(cfg.exclude),
-          only: str(cfg.only)
+          excludedByTag: tags.filter((t) => sectionExclude.includes(t))
         });
       }
     }
@@ -2390,33 +3392,46 @@ function lefthookWeakening(before, after) {
   const b = lefthookEntries(before);
   const a = lefthookEntries(after);
   for (const [key2, was] of b) {
+    if (!was.live) continue;
     const now = a.get(key2);
     if (!now) {
       out2.push(`lefthook entry ${key2} (the gate) was removed`);
       continue;
     }
-    if (now.skip === true && was.skip !== true) out2.push(`lefthook entry ${key2} (the gate) is now \`skip: true\``);
-    if (now.sectionSkip === true && was.sectionSkip !== true) out2.push(`the lefthook hook carrying ${key2} (the gate) is now \`skip: true\``);
+    if (!now.live) out2.push(`lefthook entry ${key2} no longer runs \`tamperward check\` live`);
+    if (!off(now.skip) && off(was.skip)) out2.push(`lefthook entry ${key2} (the gate) is now \`skip: ${str(now.skip)}\``);
+    if (!off(now.sectionSkip) && off(was.sectionSkip)) out2.push(`the lefthook hook carrying ${key2} (the gate) is now \`skip: ${str(now.sectionSkip)}\``);
+    if (!off(now.only) && str(now.only) !== str(was.only)) out2.push(`lefthook entry ${key2} (the gate) gained or changed \`only\` (${str(now.only)})`);
+    if (!off(now.sectionOnly) && str(now.sectionOnly) !== str(was.sectionOnly)) out2.push(`the lefthook hook carrying ${key2} (the gate) gained or changed \`only\` (${str(now.sectionOnly)})`);
     if (now.glob !== was.glob && now.glob) out2.push(`lefthook entry ${key2} (the gate) gained or changed \`glob\` (${now.glob}) \u2014 it no longer runs on every commit`);
     if (now.exclude !== was.exclude && now.exclude) out2.push(`lefthook entry ${key2} (the gate) gained or changed \`exclude\` (${now.exclude})`);
-    if (now.only !== was.only && now.only) out2.push(`lefthook entry ${key2} (the gate) gained or changed \`only\` (${now.only})`);
+    if (now.excludedByTag.length && !was.excludedByTag.length) out2.push(`lefthook entry ${key2} (the gate) is tagged ${now.excludedByTag.join(", ")}, which the hook's \`exclude_tags\` switches off`);
   }
   return out2;
 }
-var COMMIT_STAGES = /* @__PURE__ */ new Set(["commit", "pre-commit", "push", "pre-push", "commit-msg", "pre-merge-commit", "prepare-commit-msg"]);
+var STAGE_ALIAS = { commit: "pre-commit", push: "pre-push", merge_commit: "pre-merge-commit" };
+var GATE_STAGES = /* @__PURE__ */ new Set(["pre-commit", "pre-push"]);
+var ALL_STAGES = ["pre-commit", "pre-merge-commit", "pre-push", "prepare-commit-msg", "commit-msg", "post-checkout", "post-commit", "post-merge", "post-rewrite", "manual"];
+var normStage = (s) => STAGE_ALIAS[s] ?? s;
 function preCommitEntries(doc) {
   const out2 = /* @__PURE__ */ new Map();
   const repos = Array.isArray(doc.repos) ? doc.repos : [];
+  const defaults = Array.isArray(doc.default_stages) ? doc.default_stages.map(String).map(normStage) : ALL_STAGES;
   for (const repo of repos) {
     if (!isDoc(repo)) continue;
     const hooks = Array.isArray(repo.hooks) ? repo.hooks : [];
     for (const h of hooks) {
       if (!isDoc(h)) continue;
       if (!GATE.test(`${str(repo.repo)} ${str(h.id)} ${str(h.entry)} ${str(h.name)}`)) continue;
+      const live = h.entry !== void 0 ? runsGate(str(h.entry)) : GATE.test(`${str(repo.repo)} ${str(h.id)}`);
       out2.set(`${str(repo.repo)}:${str(h.id)}`, {
-        stages: Array.isArray(h.stages) ? h.stages.map(String) : null,
+        live,
+        stages: Array.isArray(h.stages) ? h.stages.map(String).map(normStage) : defaults,
+        explicitStages: Array.isArray(h.stages),
         exclude: str(h.exclude),
-        files: str(h.files)
+        files: str(h.files),
+        types: [str(h.types), str(h.types_or), str(h.exclude_types)].join(" ").trim(),
+        alwaysRun: h.always_run === true
       });
     }
   }
@@ -2427,28 +3442,45 @@ function preCommitWeakening(before, after) {
   const b = preCommitEntries(before);
   const a = preCommitEntries(after);
   for (const [key2, was] of b) {
+    if (!was.live) continue;
     const now = a.get(key2);
     if (!now) {
       out2.push(`pre-commit hook ${key2} (the gate) was removed`);
       continue;
     }
-    const wasStages = was.stages ?? [...COMMIT_STAGES];
-    if (now.stages && !now.stages.some((s) => COMMIT_STAGES.has(s)) && wasStages.some((s) => COMMIT_STAGES.has(s))) {
+    if (!now.live) out2.push(`pre-commit hook ${key2} no longer runs \`tamperward check\` live`);
+    const lost = was.stages.filter((s) => GATE_STAGES.has(s) && !now.stages.includes(s));
+    if (lost.length && !now.stages.some((s) => GATE_STAGES.has(s))) {
       out2.push(`pre-commit hook ${key2} (the gate) now runs only at stages [${now.stages.join(", ")}] \u2014 no commit or push triggers it`);
-    } else if (now.stages && was.stages) {
-      const lost = was.stages.filter((s) => COMMIT_STAGES.has(s) && !now.stages.includes(s));
-      if (lost.length) out2.push(`pre-commit hook ${key2} (the gate) no longer runs at stage(s) ${lost.join(", ")}`);
+    } else if (lost.length) {
+      out2.push(`pre-commit hook ${key2} (the gate) no longer runs at stage(s) ${lost.join(", ")}${now.explicitStages ? "" : " (default_stages changed)"}`);
     }
     if (now.exclude !== was.exclude && now.exclude) out2.push(`pre-commit hook ${key2} (the gate) gained or changed \`exclude\` (${now.exclude})`);
     if (now.files !== was.files && now.files) out2.push(`pre-commit hook ${key2} (the gate) gained or changed \`files\` (${now.files})`);
+    if (now.types !== was.types && now.types && !now.alwaysRun) out2.push(`pre-commit hook ${key2} (the gate) is scoped by file type (${now.types}) without \`always_run\``);
   }
   const topB = str(before.exclude);
   const topA = str(after.exclude);
   if (topA && topA !== topB && b.size > 0) out2.push(`a top-level pre-commit \`exclude\` was added or changed (${topA}) \u2014 it scopes every hook, the gate included`);
   return out2;
 }
-var INSTALLER = /\b(?:husky|lefthook|simple-git-hooks|pre-commit)\b/;
 var INSTALL_SCRIPTS = ["prepare", "postinstall", "install", "preinstall"];
+function installerOf(script) {
+  for (const seg of script.split(/&&|\|\||;|\n/)) {
+    const raw = seg.trim();
+    if (!raw) continue;
+    if (/^(?:HUSKY|LEFTHOOK)=0\b/.test(raw)) continue;
+    const core = raw.replace(PREFIX, "").replace(RUNNER, "").replace(/\s+/g, " ");
+    const m = core.match(/^(?:node\s+)?(?:\S*\/)?(husky|lefthook|simple-git-hooks|pre-commit)(?:\.js)?(?:\s+(\S+))?/);
+    if (!m) continue;
+    const [, tool, sub] = m;
+    if (tool === "husky" && (sub === void 0 || sub === "install" || sub.startsWith("-"))) return sub === "install" ? "husky install" : "husky";
+    if (tool === "lefthook" && sub === "install") return "lefthook install";
+    if (tool === "pre-commit" && sub === "install") return "pre-commit install";
+    if (tool === "simple-git-hooks" && (sub === void 0 || sub.startsWith("-"))) return "simple-git-hooks";
+  }
+  return null;
+}
 function packageJsonWeakening(before, after) {
   let b;
   let a;
@@ -2459,13 +3491,14 @@ function packageJsonWeakening(before, after) {
     return [];
   }
   if (!isDoc(b) || !isDoc(a)) return [];
-  const scripts = (d) => {
+  const installers = (d) => {
     const sc = d.scripts;
-    return isDoc(sc) ? INSTALL_SCRIPTS.map((k) => str(sc[k])).join(" ") : "";
+    if (!isDoc(sc)) return [];
+    return INSTALL_SCRIPTS.map((k) => installerOf(str(sc[k]))).filter((x) => x !== null);
   };
-  const was = scripts(b).match(INSTALLER)?.[0];
+  const was = installers(b)[0];
   if (!was) return [];
-  if (INSTALLER.test(scripts(a))) return [];
+  if (installers(a).length) return [];
   return [`the install script that wires the git hooks (\`${was}\`) was removed from package.json scripts \u2014 a fresh checkout installs no hooks`];
 }
 var GIT_HOOKS = /* @__PURE__ */ new Set([
@@ -2492,7 +3525,7 @@ var GIT_HOOKS = /* @__PURE__ */ new Set([
 ]);
 function hookIdentity(path) {
   const base = path.split("/").pop() ?? "";
-  if (isLefthook(path)) return "lefthook";
+  if (isLefthook(path)) return isLefthookLocal(path) ? "lefthook-local" : "lefthook";
   if (isPreCommitConfig(path)) return "pre-commit-config";
   if (base === "CODEOWNERS") return "codeowners";
   const husky = path.match(/(?:^|\/)\.husky\/([^/]+)$/);
@@ -2500,7 +3533,7 @@ function hookIdentity(path) {
   return null;
 }
 var ownerExec = (mode) => (parseInt(mode.slice(-3).padStart(3, "0"), 8) & 64) !== 0;
-var SYMBOLIC = /^[ugoa]*([-+=])([rwxXst]*)$/;
+var SYMBOLIC = /^([ugoa]*)((?:[-+=][rwxXstugo]*)+)$/;
 function chmodDropsExec(toks) {
   const at = toks.findIndex((t) => t === "chmod" || t.endsWith("/chmod"));
   if (at === -1) return false;
@@ -2513,31 +3546,113 @@ function chmodDropsExec(toks) {
     for (const clause of tok.split(",")) {
       const m = clause.match(SYMBOLIC);
       if (!m) continue;
-      const [, op, perms] = m;
-      if (op === "-" && /[xX]/.test(perms)) return true;
-      if (op === "=" && !/[xX]/.test(perms)) return true;
+      const [, who, opsText] = m;
+      if (who && !/[ua]/.test(who)) continue;
+      let exec = null;
+      for (const g of opsText.match(/[-+=][rwxXstugo]*/g) ?? []) {
+        const op = g[0];
+        const perms = g.slice(1);
+        if (/[ugo]/.test(perms)) {
+          exec = false;
+          continue;
+        }
+        if (op === "-" && /[xX]/.test(perms)) exec = false;
+        else if (op === "+" && /[xX]/.test(perms)) exec = true;
+        else if (op === "=") exec = /[xX]/.test(perms);
+      }
+      if (exec === false) return true;
     }
   }
   return false;
 }
+function setfaclDropsExec(toks) {
+  if (!toks.some((t) => /^-[a-zA-Z]*m|^--modify/.test(t))) return false;
+  return toks.some((t) => t.split(",").some((e) => {
+    const m = e.match(/^(?:u|user)::([rwxX-]*)$/);
+    return !!m && !/[xX]/.test(m[1]);
+  }));
+}
 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) {
+var INTERPRETERS = /* @__PURE__ */ new Set(["python", "python2", "python3", "node", "perl", "ruby", "php", "deno", "bun"]);
+var INLINE_FLAG = /^-(?:c|e|r|E|p|pe|pi|i|ne|ni|le)$|^--eval$|^--print$|^--exec$/;
+var EDITORS = /* @__PURE__ */ new Set(["ex", "ed", "vim", "vi", "nvim"]);
+var HOOK_BASENAMES = ["pre-commit", "pre-push", "commit-msg", "settings.json", "settings.local.json", ".tamperward.yml", "lefthook.yml", "lefthook.yaml", "lefthook-local.yml", ".pre-commit-config.yaml", "CODEOWNERS"];
+function nameGlob(pattern) {
+  const re = new RegExp("^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
+  return (n) => re.test(n);
+}
+function destinations(cmd, args, isDir) {
+  const positional = [];
+  let target = null;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--") {
+      positional.push(...args.slice(i + 1));
+      break;
+    }
+    if (a === "-t" || a === "--target-directory") {
+      target = args[++i] ?? null;
+      continue;
+    }
+    const eq = a.match(/^--target-directory=(.*)$/);
+    if (eq) {
+      target = eq[1];
+      continue;
+    }
+    if (cmd === "install" && /^-[mogS]$/.test(a) || cmd === "install" && /^--(?:mode|owner|group|suffix)$/.test(a) || cmd === "rsync" && /^(?:-e|--rsh|--exclude|--include|--files-from)$/.test(a)) {
+      i++;
+      continue;
+    }
+    if (a.startsWith("-")) continue;
+    positional.push(a);
+  }
+  const base = (p) => p.replace(/\/+$/, "").split("/").pop() ?? p;
+  if (target !== null) return positional.map((p) => `${target.replace(/\/+$/, "")}/${base(p)}`);
+  if (positional.length < 2) return [];
+  const dest = positional[positional.length - 1];
+  const srcs = positional.slice(0, -1);
+  if (dest.endsWith("/") || srcs.length > 1 || isDir(dest)) return [dest, ...srcs.map((s) => `${dest.replace(/\/+$/, "")}/${base(s)}`)];
+  return [dest];
+}
+var REDIRECT_TARGET = /(?:^|\s)(?:\d*>{1,2}\|?|&>{1,2})\s*(\S+)/g;
+function hookTests(policy, ctx) {
+  const rel = (t) => {
+    let p = t.replace(/^["']|["']$/g, "");
+    if (ctx?.cwd && p.startsWith(ctx.cwd + "/")) p = p.slice(ctx.cwd.length + 1);
+    return p.replace(/^\.\/(?=.)/, "");
+  };
+  const hook = (t) => isProtected(rel(t), policy, "hooks");
+  const whole = (t) => /^(?:\.|\.\/|:\/|\*)$/.test(rel(t)) || ctx?.cwd !== void 0 && rel(t) === ctx.cwd;
+  const holds = (t) => !t.startsWith("-") && (whole(t) || containsProtected(rel(t), policy, "hooks", ctx));
+  const hookish = (t) => hook(t) || holds(t);
+  return { rel, hook, whole, holds, hookish };
+}
+function shellHookTarget(seg, toks, policy, ctx) {
+  const { rel, hook, whole, holds } = hookTests(policy, ctx);
   for (const m of seg.matchAll(REDIRECT_TARGET)) {
-    const t = hookPath(m[1]);
-    if (isProtected(t, policy, "hooks")) return t;
+    if (hook(m[1])) return rel(m[1]);
   }
-  for (const tok of toks) {
-    const t = hookPath(tok.replace(/^of=/, ""));
-    if (isProtected(t, policy, "hooks")) return t;
+  const args = toks.map((t) => t.replace(/^(?:of=|--(?:include|exclude|directory)=)/, ""));
+  const fileLike = (p) => {
+    const b = p.replace(/\/+$/, "").split("/").pop() ?? "";
+    return HOOK_BASENAMES.includes(b) || /\.[A-Za-z0-9]+$/.test(b.replace(/^\.+/, "")) || (trackedFiles(ctx)?.includes(p) ?? false);
+  };
+  for (const t of args) if (hook(t) && fileLike(rel(t))) return rel(t);
+  for (const t of args) {
+    if (t.startsWith("-") || !holds(t)) continue;
+    const dir = rel(t).replace(/\/+$/, "");
+    const under = whole(t) ? "" : dir + "/";
+    const listed = trackedFiles(ctx)?.find((f) => f.startsWith(under) && isProtected(f, policy, "hooks"));
+    if (listed) return listed;
+    const guess = under + "pre-commit";
+    return isProtected(guess, policy, "hooks") ? guess : whole(t) ? ".tamperward.yml" : dir;
   }
   return null;
 }
-function shellWritesHook(seg, toks, policy) {
-  const hook = (t) => isProtected(t.replace(/^\.\//, ""), policy, "hooks");
+function shellWritesHook(seg, toks, policy, ctx) {
+  const { rel, hook, whole, holds, hookish } = hookTests(policy, ctx);
   for (const m of seg.matchAll(REDIRECT_TARGET)) {
-    if (hook(m[1].replace(/^["']|["']$/g, ""))) return "a redirect empties or rewrites a protected hook";
+    if (hook(m[1])) return "a redirect empties or rewrites a protected hook";
   }
   let at = 0;
   while (at < toks.length && WRAPPERS.test(toks[at])) at++;
@@ -2547,21 +3662,28 @@ function shellWritesHook(seg, toks, policy) {
   const last = positional[positional.length - 1] ?? "";
   const anyHook = args.some(hook);
   const inPlace = args.some((a) => /^-[A-Za-z]*i|^--in-place/.test(a));
+  const scripts = args.filter((_, i) => i > 0 && INLINE_FLAG.test(args[i - 1]));
+  const namesHookInText = () => scripts.some((a) => (a.match(/[\w.~/-]+/g) ?? []).some(hook));
   switch (cmd) {
     case "rm":
     case "unlink":
     case "shred":
-      return anyHook ? "rm deletes a protected hook" : null;
+      return anyHook || positional.some(holds) ? "rm deletes a protected hook" : null;
     case "truncate":
       return anyHook ? "truncate empties a protected hook" : null;
     case "chmod":
-      return anyHook && chmodDropsExec(toks) ? "chmod removes execute permission from a hook \u2014 git will skip it" : null;
+      return (anyHook || positional.some(holds)) && chmodDropsExec(toks) ? "chmod removes execute permission from a hook \u2014 git will skip it" : null;
+    case "setfacl":
+      return anyHook && setfaclDropsExec(args) ? "setfacl removes the owner execute permission from a hook \u2014 git will skip it" : null;
     case "mv":
-      return anyHook ? "mv moves a protected hook out of place or overwrites it" : null;
+      return anyHook || positional.some(holds) ? "mv moves a protected hook out of place or overwrites it" : null;
     case "cp":
     case "install":
     case "ln":
-      return hook(last) ? `${cmd} replaces a protected hook in place` : null;
+    case "rsync": {
+      const dests = destinations(cmd, args, holds);
+      return dests.some(hook) ? `${cmd} replaces a protected hook in place` : null;
+    }
     case "tee":
     case "sponge":
       return anyHook ? `${cmd} rewrites a protected hook in place` : null;
@@ -2569,20 +3691,45 @@ function shellWritesHook(seg, toks, policy) {
       return args.some((a) => a.startsWith("of=") && hook(a.slice(3))) ? "dd rewrites a protected hook in place" : null;
     case "sed":
     case "perl":
-      return anyHook && inPlace ? `an in-place ${cmd} rewrites a protected hook` : null;
+      if (anyHook && inPlace) return `an in-place ${cmd} rewrites a protected hook`;
+      if (cmd === "perl" && args.some((a) => INLINE_FLAG.test(a)) && namesHookInText()) return "an inline perl script names a protected hook";
+      return null;
     case "awk":
     case "gawk":
       return anyHook && args.some((a, i) => a === "-i" && args[i + 1] === "inplace" || a === "--in-place" || a === "-i=inplace") ? "an in-place awk rewrites a protected hook" : null;
+    case "patch":
+      return anyHook ? "patch rewrites a protected hook" : null;
+    case "xargs":
+      return null;
+    // judged by the caller, which sees the segments feeding it
+    case "find": {
+      const mutates = /\s(?:-delete\b|-exec(?:dir)?\s+(?:rm|unlink|chmod|truncate|mv|sed|tee|shred)\b)/.test(seg);
+      if (!mutates) return null;
+      if (/-exec(?:dir)?\s+chmod\b/.test(seg) && !chmodDropsExec(toks)) return null;
+      const dirs = positional.filter((p) => !/^-/.test(p) && !["{}", ";", "+", "rm", "chmod", "unlink", "truncate", "mv", "sed", "tee", "shred", "inplace"].includes(p));
+      const names = args.filter((a, i) => /^-i?(?:name|path|regex)$/.test(args[i - 1] ?? ""));
+      const nameHits = names.length === 0 || names.some((n) => {
+        try {
+          const g = nameGlob(n.replace(/^.*\//, ""));
+          return HOOK_BASENAMES.some(g);
+        } catch {
+          return true;
+        }
+      });
+      const reachesHook = dirs.some((d) => hook(d) || holds(d) || whole(d) && nameHits) || dirs.length === 0 && nameHits;
+      return reachesHook && nameHits ? "find rewrites or removes protected hooks" : null;
+    }
     case "git": {
       let i = 0;
       while (i < args.length && args[i].startsWith("-")) i += args[i] === "-C" || args[i] === "-c" ? 2 : 1;
       const sub = args[i];
       const rest = args.slice(i + 1);
-      if (!rest.some(hook)) return null;
+      if (sub === "apply" || sub === "am") return rest.some((a) => hook(a.replace(/^--(?:include|exclude|directory)=/, ""))) ? `git ${sub} applies a patch that names a protected hook` : null;
+      if (!rest.some(hookish)) return null;
       if (sub === "checkout") {
         const dd = rest.indexOf("--");
         const before = dd === -1 ? rest : rest.slice(0, dd);
-        const revs = before.filter((p) => !p.startsWith("-") && !hook(p));
+        const revs = before.filter((p) => !p.startsWith("-") && !hookish(p));
         return revs.length > 0 ? "git checkout <rev> -- <hook> puts an older version of a protected hook back" : null;
       }
       if (sub === "restore" && rest.some((a) => /^--source(?:=|$)/.test(a) || a === "-s")) {
@@ -2591,108 +3738,290 @@ function shellWritesHook(seg, toks, policy) {
       return null;
     }
     default:
+      if (INTERPRETERS.has(cmd) && inPlace && anyHook) return `an in-place ${cmd} rewrites a protected hook`;
+      if (INTERPRETERS.has(cmd) && args.some((a) => INLINE_FLAG.test(a)) && namesHookInText()) return `an inline ${cmd} script names a protected hook`;
+      if (EDITORS.has(cmd) && (anyHook || args.some((a) => /^-[a-zA-Z]*[cs]/.test(a) || a === "--cmd") && namesHookInText())) return `${cmd} rewrites a protected hook`;
       return null;
   }
 }
+function xargsWritesHook(toks, fed, policy, ctx) {
+  const at = toks.findIndex((t) => t === "xargs" || t.endsWith("/xargs"));
+  if (at === -1) return null;
+  const rel = (t) => (ctx?.cwd && t.startsWith(ctx.cwd + "/") ? t.slice(ctx.cwd.length + 1) : t).replace(/^\.\//, "");
+  const fedHook = fed.some((t) => isProtected(rel(t), policy, "hooks") || !t.startsWith("-") && containsProtected(rel(t), policy, "hooks", ctx));
+  if (!fedHook) return null;
+  let i = at + 1;
+  while (i < toks.length && toks[i].startsWith("-")) i += /^-(?:I|n|L|P|d|a|s)$/.test(toks[i]) ? 2 : 1;
+  const cmd = (toks[i] ?? "").replace(/^.*\//, "");
+  const args = toks.slice(i + 1);
+  if (["rm", "unlink", "shred", "truncate", "mv", "tee", "sponge"].includes(cmd)) return `xargs ${cmd} rewrites or removes a protected hook named earlier in the line`;
+  if (cmd === "chmod" && chmodDropsExec(toks.slice(i))) return "xargs chmod removes execute permission from a hook named earlier in the line";
+  if ((cmd === "sed" || cmd === "perl") && args.some((a) => /^-[A-Za-z]*i|^--in-place/.test(a))) return `xargs ${cmd} -i rewrites a protected hook named earlier in the line`;
+  return null;
+}
 
 // src/detectors/hook-tampering.ts
 var RULE6 = "hook-tampering";
 var ownerExec2 = (mode) => (parseInt(mode.slice(-3), 8) & 64) !== 0;
-var CLAUDE_SETTINGS = /(?:^|\/)\.claude\/settings(?:\.local)?\.json$/;
-var isClaudeSettings = (p) => CLAUDE_SETTINGS.test(p);
-function siblingSettings(p) {
-  return p.endsWith("settings.local.json") ? p.replace(/settings\.local\.json$/, "settings.json") : p.replace(/settings\.json$/, "settings.local.json");
-}
-var TW_INVOCATION = /\btamperward(?:@\S+)?\s+(?:hook|sweep)\s+claude\b/;
 var EVENTS = ["PreToolUse", "Stop"];
+var isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 function parseSettings(src) {
   try {
     const v = JSON.parse(src);
-    return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
+    return isObj(v) ? v : null;
   } catch {
     return null;
   }
 }
-function toolSet(matcher2) {
-  const m = typeof matcher2 === "string" ? matcher2.trim() : "";
-  if (m === "" || m === "*") return null;
-  return new Set(m.split("|").map((t) => t.trim()).filter(Boolean));
-}
 function eventEntries(s, event) {
   const hooks = s.hooks;
-  if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks)) return null;
+  if (!isObj(hooks)) return null;
   const arr = hooks[event];
   return Array.isArray(arr) ? arr : null;
 }
 var declares = (s, event) => eventEntries(s, event) !== null;
-function gateWiring(s, event) {
+var GATE_KEYS = /* @__PURE__ */ new Set(["type", "command", "timeout"]);
+var CANONICAL_CMD = /^npx --yes tamperward@(\S+) (hook|sweep) claude$/;
+var MENTIONS_GATE = /\btamperward\b.*\b(?:hook|sweep)\b/;
+var FORGERY = /hookSpecificOutput|permissionDecision|updatedInput|"decision"|"continue"/;
+var SENSITIVE_ENV = /^(?:PATH|NODE_OPTIONS|NODE_PATH|HOME|npm_config_.*|NPM_CONFIG_.*)$/;
+function analyseGateCommand(cmd, event) {
+  const want = event === "PreToolUse" ? "hook" : "sweep";
+  const problems = [];
+  let runs = true;
+  const canonical2 = cmd.match(CANONICAL_CMD);
+  if (canonical2) {
+    if (canonical2[2] !== want) {
+      problems.push(`runs \`${canonical2[2]} claude\` under ${event}`);
+      runs = false;
+    }
+    if (!PLAIN_SEMVER.test(canonical2[1])) {
+      problems.push(`the pin \`${canonical2[1]}\` is not a plain version`);
+      runs = false;
+    }
+    return { runs, problems, pin: canonical2[1] };
+  }
+  const inv = cmd.match(/\btamperward(?:@(\S+))?\s+(hook|sweep)\s+(\S+)/);
+  if (!inv) return { runs: false, problems: ["the command does not invoke the gate"], pin: null };
+  if (inv[2] !== want || inv[3] !== "claude") {
+    problems.push(`runs \`${inv[2]} ${inv[3]}\` under ${event}`);
+    runs = false;
+  }
+  if (inv[1] !== void 0 && !PLAIN_SEMVER.test(inv[1])) {
+    problems.push(`the pin \`${inv[1]}\` is not a plain version`);
+    runs = false;
+  }
+  if (/[|;&<>`]|\$\(/.test(cmd)) {
+    problems.push("text around the invocation (a redirect, pipe or chain)");
+    runs = false;
+  }
+  if (/^\s*[A-Za-z_]\w*=/.test(cmd)) {
+    problems.push("an environment assignment in front of the gate");
+    runs = false;
+  }
+  if (/\b(?:sh|bash|zsh|dash)\s+-[a-zA-Z]*c\b/.test(cmd)) {
+    problems.push("wrapped in `sh -c`");
+    runs = false;
+  }
+  if (/(?:^|\s)(?:-p|--package)(?:=|\s)/.test(cmd)) {
+    problems.push("`-p`/`--package` points npx at another package");
+    runs = false;
+  }
+  const at = cmd.indexOf(inv[0]);
+  const trailing = cmd.slice(at + inv[0].length).trim();
+  if (trailing) {
+    problems.push(`extra text after the invocation (\`${trailing}\`)`);
+    runs = false;
+  }
+  const head = cmd.slice(0, at).trim();
+  if (head !== "npx --yes") problems.push(`the launcher \`${head || "(none)"}\` is not \`npx --yes\``);
+  return { runs, problems, pin: inv[1] ?? "" };
+}
+function matcherSelection(m) {
+  if (m === void 0) return { tools: null, problem: null };
+  if (typeof m !== "string") return { tools: /* @__PURE__ */ new Set(), problem: `the matcher ${JSON.stringify(m)} is not a string` };
+  if (m === "" || m === "*") return { tools: null, problem: null };
+  let problem = null;
+  if (/[^\x00-\x7f]/.test(m)) problem = "the matcher contains non-ASCII characters that look like tool names but are not";
+  if (/^[A-Za-z0-9_ |-]+$/.test(m)) return { tools: new Set(m.split("|").map((t) => t.trim()).filter(Boolean)), problem };
+  let re;
+  try {
+    re = new RegExp(m);
+  } catch {
+    return { tools: /* @__PURE__ */ new Set(), problem: `the matcher \`${m}\` is not a valid pattern \u2014 it selects nothing` };
+  }
+  return { tools: new Set(PRE_TOOLS.filter((t) => re.test(t))), problem };
+}
+function gateCandidates(s, event) {
   const out2 = [];
-  for (const m of eventEntries(s, event) ?? []) {
-    if (m === null || typeof m !== "object") continue;
-    const matcher2 = m;
-    if (!Array.isArray(matcher2.hooks)) continue;
-    for (const h of matcher2.hooks) {
-      if (h === null || typeof h !== "object") continue;
-      const entry = h;
-      if (entry.type !== void 0 && entry.type !== "command") continue;
-      if (typeof entry.command !== "string" || !TW_INVOCATION.test(entry.command)) continue;
-      out2.push({ tools: toolSet(matcher2.matcher), command: entry.command });
+  const mentions = (v) => /\btamperward\b/.test(JSON.stringify(v) ?? "");
+  for (const group of eventEntries(s, event) ?? []) {
+    if (!isObj(group)) {
+      if (mentions(group)) out2.push({ key: JSON.stringify(group), runs: false, problems: ["the matcher entry is not an object"], pin: null, tools: null });
+      continue;
+    }
+    if (!Array.isArray(group.hooks)) {
+      if (mentions(group)) out2.push({ key: JSON.stringify(group), runs: false, problems: ["`hooks` is not a list"], pin: null, tools: null });
+      continue;
+    }
+    for (const h of group.hooks) {
+      if (!isObj(h)) {
+        if (mentions(h)) out2.push({ key: JSON.stringify(h), runs: false, problems: ["the hook entry is not an object"], pin: null, tools: null });
+        continue;
+      }
+      const cmd = typeof h.command === "string" ? h.command : null;
+      if (cmd === null) {
+        if (mentions(h)) out2.push({ key: JSON.stringify(h), runs: false, problems: ["the gate is not in a `command` string"], pin: null, tools: null });
+        continue;
+      }
+      if (!MENTIONS_GATE.test(cmd)) continue;
+      const a = analyseGateCommand(cmd, event);
+      const problems = [...a.problems];
+      let runs = a.runs;
+      if (h.type !== "command") {
+        problems.push(h.type === void 0 ? "no `type`" : `\`type\` is ${JSON.stringify(h.type)}`);
+        if (h.type !== void 0) runs = false;
+      }
+      for (const k of Object.keys(h)) {
+        if (GATE_KEYS.has(k)) continue;
+        problems.push(`carries \`${k}\``);
+        runs = false;
+      }
+      if ("timeout" in h) {
+        const t = h.timeout;
+        if (typeof t !== "number" || !Number.isInteger(t) || t < 120) {
+          problems.push(`\`timeout\` ${JSON.stringify(t)} \u2014 the gate is cut off before it answers`);
+          runs = false;
+        }
+      }
+      let tools = null;
+      if (event === "PreToolUse") {
+        const sel = matcherSelection(group.matcher);
+        tools = sel.tools;
+        if (sel.problem) {
+          problems.push(sel.problem);
+        }
+      } else if (group.matcher !== void 0 && !(typeof group.matcher === "string" && (group.matcher === "" || group.matcher === "*"))) {
+        problems.push(`a \`matcher\` (${JSON.stringify(group.matcher)}) on the Stop entry`);
+        runs = false;
+      }
+      out2.push({ key: JSON.stringify({ m: group.matcher, h }), runs, problems, pin: a.pin, tools });
     }
   }
   return out2;
 }
-function coverage(ws2) {
-  if (ws2.length === 0) return "none";
-  if (ws2.some((w) => w.tools === null)) return null;
-  return new Set(ws2.flatMap((w) => [...w.tools]));
+function otherCommands(s, event) {
+  const out2 = [];
+  for (const group of eventEntries(s, event) ?? []) {
+    if (!isObj(group) || !Array.isArray(group.hooks)) continue;
+    for (const h of group.hooks) {
+      if (!isObj(h) || typeof h.command !== "string" || MENTIONS_GATE.test(h.command)) continue;
+      out2.push(h.command);
+    }
+  }
+  return out2;
+}
+function coverage(cs) {
+  const live = cs.filter((c) => c.runs);
+  if (live.length === 0) return "none";
+  if (live.some((c) => c.tools === null)) return null;
+  return new Set(live.flatMap((c) => [...c.tools]));
+}
+function duplicateJsonKeys(src) {
+  const dups = [];
+  const stack = [];
+  let expectKey = false;
+  for (let i = 0; i < src.length; i++) {
+    const ch = src[i];
+    if (ch === '"') {
+      let j = i + 1;
+      let s = "";
+      while (j < src.length && src[j] !== '"') {
+        if (src[j] === "\\") {
+          s += src[j + 1] ?? "";
+          j += 2;
+        } else {
+          s += src[j];
+          j++;
+        }
+      }
+      if (expectKey) {
+        const set = stack[stack.length - 1];
+        if (set) {
+          if (set.has(s)) dups.push(s);
+          set.add(s);
+        }
+        expectKey = false;
+      }
+      i = j;
+      continue;
+    }
+    if (ch === "{") {
+      stack.push(/* @__PURE__ */ new Set());
+      expectKey = true;
+    } else if (ch === "[") {
+      stack.push(null);
+      expectKey = false;
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      expectKey = false;
+    } else if (ch === ",") expectKey = stack[stack.length - 1] !== null;
+  }
+  return [...new Set(dups)];
 }
-var hooksDisabled = (s) => s.disableAllHooks === true;
-function settingsWeakening(before, after, sibling) {
+function settingsWeakening(before, after, local) {
   const reasons = [];
-  if (hooksDisabled(after) && !(before !== null && hooksDisabled(before))) {
-    reasons.push("`disableAllHooks: true` switches every hook off, the gate included");
+  const dis = after.disableAllHooks;
+  if (dis !== void 0 && dis !== false && !(before !== null && before.disableAllHooks === dis)) {
+    reasons.push(`\`disableAllHooks: ${JSON.stringify(dis)}\` switches every hook off, the gate included`);
+  }
+  if (isObj(after.env)) {
+    const was = before !== null && isObj(before.env) ? before.env : {};
+    for (const [k, v] of Object.entries(after.env)) {
+      if (SENSITIVE_ENV.test(k) && JSON.stringify(was[k]) !== JSON.stringify(v)) {
+        reasons.push(`a top-level \`env\` sets ${k} \u2014 the gate command resolves through it`);
+      }
+    }
   }
   for (const event of EVENTS) {
-    const was = before ? coverage(gateWiring(before, event)) : "none";
-    const now = coverage(gateWiring(after, event));
+    const bc = before !== null ? gateCandidates(before, event) : [];
+    const ac = gateCandidates(after, event);
+    const was = coverage(bc);
+    const now = coverage(ac);
     if (was !== "none") {
       if (now === "none") {
         reasons.push(`the tamperward ${event} hook entry was removed`);
       } else if (event === "PreToolUse") {
         if (was === null && now !== null) {
-          reasons.push(`the PreToolUse matcher for the gate was narrowed from every tool to ${[...now].join("|")}`);
+          reasons.push(`the PreToolUse matcher for the gate was narrowed from every tool to ${[...now].join("|") || "(nothing)"}`);
         } else if (was !== null && now !== null) {
           const lost = [...was].filter((t) => !now.has(t));
           if (lost.length) reasons.push(`the PreToolUse matcher for the gate no longer covers ${lost.join(", ")}`);
         }
       }
-      continue;
+    } else if (now === "none" && declares(after, event) && !(before !== null && declares(before, event)) && (eventEntries(after, event) ?? []).length === 0) {
+      reasons.push(`${event} hooks declared empty in ${local ? "an override file" : "the settings file"}`);
+    }
+    const had = new Set(bc.map((c) => c.key));
+    const fresh = ac.filter((c) => !had.has(c.key));
+    for (const c of fresh) {
+      if (c.problems.length) reasons.push(`the ${event} gate entry does not match the shape \`tamperward init\` writes: ${c.problems.join("; ")}`);
+    }
+    const pins = bc.map((c) => c.pin).filter((p) => !!p && PLAIN_SEMVER.test(p)).sort((a, b) => compareVersions(b, a) ?? 0);
+    const floor = pins[0] ?? (before === null && PLAIN_SEMVER.test(TW_VERSION) ? TW_VERSION : null);
+    if (floor) {
+      for (const c of fresh) {
+        if (c.pin && PLAIN_SEMVER.test(c.pin) && !pinNotBelow(c.pin, floor)) reasons.push(`the ${event} gate is pinned to tamperward@${c.pin}, below ${floor}`);
+      }
     }
-    if (now !== "none" || !declares(after, event)) continue;
-    if (before !== null && declares(before, event)) continue;
-    const empty = (eventEntries(after, event) ?? []).length === 0;
-    const shadowed = sibling !== null && gateWiring(sibling, event).length > 0;
-    if (empty || shadowed) {
-      reasons.push(
-        `${event} hooks declared ${empty ? "empty" : "without the tamperward entry"} in an override file` + (shadowed ? " \u2014 this shadows the gate the sibling settings file wires" : "")
-      );
+    const hadOther = new Set(before !== null ? otherCommands(before, event) : []);
+    for (const cmd of otherCommands(after, event)) {
+      if (!hadOther.has(cmd) && FORGERY.test(cmd)) reasons.push(`a ${event} hook entry beside the gate emits a hook decision of its own (\`${cmd.slice(0, 60)}\`)`);
     }
   }
   return reasons;
 }
-function siblingOf(c, changes, ctx) {
-  const path = siblingSettings(c.path);
-  const inSet = changes.find((o) => o.kind === "file" && o.path === path);
-  if (inSet) return inSet.after != null ? parseSettings(inSet.after) : null;
-  if (!ctx?.cwd) return null;
-  try {
-    const p = join2(ctx.cwd, path);
-    return existsSync(p) ? parseSettings(readFileSync2(p, "utf8")) : null;
-  } catch {
-    return null;
-  }
-}
-function claudeSettingsFindings(c, changes, policy, ctx) {
+function claudeSettingsFindings(c, policy) {
   if (c.after == null) return null;
   const after = parseSettings(c.after);
   const before = c.before != null ? parseSettings(c.before) : null;
@@ -2700,14 +4029,19 @@ function claudeSettingsFindings(c, changes, policy, ctx) {
     file: c.path,
     message: `The Claude Code hook wiring was weakened: ${reason}.`,
     evidence: reason,
-    remediation: "Leave the PreToolUse and Stop entries that run tamperward, and the matcher that covers every editing tool, exactly as `tamperward init` wrote them. Editing the wiring is editing the gate."
+    remediation: "Leave the PreToolUse and Stop entries that run tamperward, and the matcher that covers every editing tool, exactly as `tamperward init` wrote them. Editing the wiring is editing the gate: re-run `tamperward init` to restore it, or sign off."
   });
   if (c.before != null && before === null) return null;
   if (after === null) {
     if (c.before == null) return [];
     return [finding("the settings file no longer parses as JSON \u2014 the runtime ignores it, hooks and all")];
   }
-  return settingsWeakening(before, after, siblingOf(c, changes, ctx)).map(finding);
+  const reasons = settingsWeakening(before, after, /settings\.local\.json$/.test(c.path));
+  const had = new Set(c.before != null ? duplicateJsonKeys(c.before) : []);
+  for (const k of duplicateJsonKeys(c.after)) {
+    if (!had.has(k)) reasons.push(`the key "${k}" appears twice \u2014 which reading the runtime keeps is not something the gate can vouch for`);
+  }
+  return reasons.map(finding);
 }
 function policyFindings(c, policy) {
   if (c.after == null) return null;
@@ -2729,12 +4063,54 @@ function renameKept(c) {
   if (id === null || hookIdentity(c.path) !== id) return false;
   return c.before != null && c.after != null ? c.before === c.after : c.hunks.length === 0;
 }
-function configFindings(c, policy) {
-  if (c.before == null || c.after == null) return null;
-  const before = parseDoc(c.before);
-  const after = parseDoc(c.after);
-  if (before === null) return null;
-  const reasons = after === null ? ["the file no longer parses as YAML \u2014 the tool that reads it runs nothing"] : isLefthook(c.path) ? lefthookWeakening(before, after) : preCommitWeakening(before, after);
+function lefthookBase(c, changes, ctx) {
+  const dir = c.path.includes("/") ? c.path.slice(0, c.path.lastIndexOf("/") + 1) : "";
+  const names = ["lefthook.yml", "lefthook.yaml", ".lefthook.yml", ".lefthook.yaml"].map((n) => dir + n);
+  const inSet = changes.find((o) => o.kind === "file" && names.includes(o.path));
+  if (inSet) return inSet.after != null ? parseDoc(inSet.after) : null;
+  if (!ctx?.cwd) return null;
+  for (const n of names) {
+    try {
+      const p = join3(ctx.cwd, n);
+      if (existsSync(p)) return parseDoc(readFileSync3(p, "utf8"));
+    } catch {
+    }
+  }
+  return null;
+}
+function syntheticBase(over) {
+  const base = {};
+  for (const [section, v] of Object.entries(over)) {
+    if (!isObj(v)) continue;
+    for (const group of ["commands", "scripts"]) {
+      const g = v[group];
+      if (!isObj(g)) continue;
+      for (const name of Object.keys(g)) {
+        if (!/tamperward/.test(name)) continue;
+        const sec = base[section] ??= {};
+        const grp = sec[group] ??= {};
+        grp[name] = { run: "npx tamperward check --staged" };
+      }
+    }
+  }
+  return base;
+}
+function configFindings(c, changes, policy, ctx) {
+  if (c.after == null) return null;
+  let reasons;
+  if (isLefthookLocal(c.path)) {
+    const overBefore = c.before != null ? parseDoc(c.before) : {};
+    const overAfter = parseDoc(c.after);
+    if (overBefore === null) return null;
+    const base = lefthookBase(c, changes, ctx) ?? syntheticBase(overAfter ?? {});
+    reasons = overAfter === null ? ["the file no longer parses as YAML \u2014 the tool that reads it runs nothing"] : lefthookWeakening(mergeDocs(base, overBefore), mergeDocs(base, overAfter));
+  } else {
+    if (c.before == null) return null;
+    const before = parseDoc(c.before);
+    const after = parseDoc(c.after);
+    if (before === null) return null;
+    reasons = after === null ? ["the file no longer parses as YAML \u2014 the tool that reads it runs nothing"] : isLefthook(c.path) ? lefthookWeakening(before, after) : preCommitWeakening(before, after);
+  }
   return reasons.map(
     (reason) => makeFinding(RULE6, policy, {
       file: c.path,
@@ -2744,6 +4120,11 @@ function configFindings(c, policy) {
     })
   );
 }
+function repoGateFiles(ctx) {
+  const files = trackedFiles(ctx);
+  if (!files) return [];
+  return files.filter((f) => /^\.github\/workflows\/[^/]+\.ya?ml$/.test(f) || /^\.husky\/[^/_][^/]*$/.test(f));
+}
 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));
@@ -2765,6 +4146,7 @@ function repoRelative(path, ctx) {
   const rel = relative(ctx.cwd, path);
   return rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : path;
 }
+var isHuskyScript = (path) => /(?:^|\/)\.husky\/[^/]+$/.test(path);
 var hookTampering = {
   id: RULE6,
   surface: ["file", "command"],
@@ -2774,7 +4156,7 @@ var hookTampering = {
     for (const c of changes) {
       let semantic;
       if (c.kind === "file") {
-        const targetsHook = isProtected(c.path, policy, "hooks") || (c.oldPath ? isProtected(c.oldPath, policy, "hooks") : false);
+        const targetsHook = isProtected(c.path, policy, "hooks") || (c.oldPath ? isProtected(c.oldPath, policy, "hooks") : false) || isClaudeSettings(c.path);
         if (!targetsHook) {
           if (isPackageJson(c.path) && c.before != null && c.after != null) {
             for (const reason of packageJsonWeakening(c.before, c.after)) {
@@ -2818,12 +4200,12 @@ var hookTampering = {
               remediation: "Renaming a hook out of place disables it. Restore the original path."
             })
           );
-        } else if ((c.path.endsWith(POLICY_FILE) || isClaudeSettings(c.path)) && (semantic = c.path.endsWith(POLICY_FILE) ? policyFindings(c, policy) : claudeSettingsFindings(c, changes, policy, ctx)) !== null) {
+        } else if ((c.path.endsWith(POLICY_FILE) || isClaudeSettings(c.path)) && (semantic = c.path.endsWith(POLICY_FILE) ? policyFindings(c, policy) : claudeSettingsFindings(c, policy)) !== null) {
           out2.push(...semantic);
         } else if (c.op === "rename") {
         } else if (isCodeowners(c.path)) {
           if (c.before != null && c.after != null) {
-            for (const reason of codeownersWeakening(c.before, c.after)) {
+            for (const reason of codeownersWeakening(c.before, c.after, [...repoGateFiles(ctx), c.path])) {
               out2.push(
                 makeFinding(RULE6, policy, {
                   file: c.path,
@@ -2834,9 +4216,40 @@ var hookTampering = {
               );
             }
           }
-        } else if ((isLefthook(c.path) || isPreCommitConfig(c.path)) && (semantic = configFindings(c, policy)) !== null) {
+        } else if ((isLefthook(c.path) || isPreCommitConfig(c.path)) && (semantic = configFindings(c, changes, policy, ctx)) !== null) {
           out2.push(...semantic);
         } else if (!c.path.endsWith(POLICY_FILE)) {
+          const husky = isHuskyScript(c.path);
+          const beforePin = c.before != null && c.after != null ? initScriptPin(c.before) : null;
+          if (beforePin !== null) {
+            const afterPin = initScriptPin(c.after);
+            const kept = afterPin !== null && (beforePin === "" ? afterPin === "" || PLAIN_SEMVER.test(afterPin) : pinNotBelow(afterPin, beforePin));
+            if (!kept) {
+              out2.push(
+                makeFinding(RULE6, policy, {
+                  file: c.path,
+                  message: "A protected hook script no longer matches the shape `tamperward init` writes.",
+                  evidence: "the gate script no longer matches the shape init wrote; re-run init or sign off",
+                  remediation: "The pre-commit script init writes is the marker line and the pinned staged check, nothing else. Re-run `tamperward init` to restore it, or sign off on the customised script."
+                })
+              );
+            }
+            continue;
+          }
+          if (!husky && c.after != null) {
+            const problem = shebangProblem(c.after);
+            if (problem && (c.before == null || problem !== shebangProblem(c.before))) {
+              out2.push(
+                makeFinding(RULE6, policy, {
+                  file: c.path,
+                  line: 1,
+                  message: `A protected hook's interpreter was changed: ${problem}.`,
+                  evidence: c.after.split("\n")[0],
+                  remediation: "Keep a shell in shebang position. git execs the hook directly, and an interpreter that never reads the script is a disabled hook."
+                })
+              );
+            }
+          }
           const added = addedLines(c);
           const earlyExit = added.find((l) => insertsPassingExit(l.content));
           if (earlyExit) {
@@ -2864,7 +4277,7 @@ var hookTampering = {
           }
           const beforeLines = c.before != null ? c.before.split("\n") : removedLines(c).map((l) => l.content);
           const afterLines = c.after != null ? c.after.split("\n") : added.map((l) => l.content);
-          const lost = scriptWeakening(beforeLines, afterLines);
+          const lost = scriptWeakening(beforeLines, afterLines, husky ? { errexit: true } : {});
           if (lost.length) {
             out2.push(
               makeFinding(RULE6, policy, {
@@ -2908,6 +4321,7 @@ var hookTampering = {
           }
         }
       } else {
+        const fed = [];
         for (const seg of segments(c.raw)) {
           const toks = tokens(seg).map(unquote);
           const hiding = updateIndexHiding(toks, policy);
@@ -2920,11 +4334,12 @@ var hookTampering = {
                 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."
               })
             );
+            fed.push(...toks);
             continue;
           }
-          const why = shellWritesHook(seg, toks, policy);
+          const why = shellWritesHook(seg, toks, policy, ctx) ?? xargsWritesHook(toks, fed, policy, ctx);
           if (why) {
-            const target = shellHookTarget(seg, toks, policy);
+            const target = shellHookTarget(seg, toks, policy, ctx) ?? shellHookTarget("", fed, policy, ctx);
             out2.push(
               makeFinding(RULE6, policy, {
                 ...target ? { file: repoRelative(target, ctx) } : {},
@@ -2934,6 +4349,7 @@ var hookTampering = {
               })
             );
           }
+          fed.push(...toks);
         }
       }
     }
@@ -2971,67 +4387,147 @@ function keyName2(name) {
   if (ts3.isIdentifier(name) || ts3.isStringLiteral(name)) return name.text;
   return null;
 }
+var isStr = (e) => ts3.isStringLiteral(e) || ts3.isNoSubstitutionTemplateLiteral(e);
 function literals2(e) {
-  if (ts3.isStringLiteral(e) || ts3.isNoSubstitutionTemplateLiteral(e)) return { items: [e.text], opaque: false };
+  if (isStr(e)) return { items: [e.text], opaque: false };
   if (!ts3.isArrayLiteralExpression(e)) return { items: [], opaque: true };
   const items = [];
   let opaque = false;
   for (const el of e.elements) {
-    if (ts3.isStringLiteral(el) || ts3.isNoSubstitutionTemplateLiteral(el)) items.push(el.text);
+    if (isStr(el)) items.push(el.text);
     else if (ts3.isSpreadElement(el) && /^(?:configDefaults\.|default)(?:exclude|include)$/i.test(el.expression.getText())) {
       items.push(.../exclude$/i.test(el.expression.getText()) ? VITEST_DEFAULT_EXCLUDE : VITEST_DEFAULT_INCLUDE);
     } else opaque = true;
   }
   return { items, opaque };
 }
-function underKey2(node, key2) {
-  for (let p = node.parent; p; p = p.parent) {
-    if (ts3.isPropertyAssignment(p) && keyName2(p.name) === key2) return true;
-  }
-  return false;
+function ownerKey2(node) {
+  const obj = node.parent;
+  if (!obj || !ts3.isObjectLiteralExpression(obj)) return null;
+  let q = obj.parent;
+  while (q && (ts3.isParenthesizedExpression(q) || ts3.isAsExpression(q) || q.kind === ts3.SyntaxKind.SatisfiesExpression)) q = q.parent;
+  return q && ts3.isPropertyAssignment(q) ? keyName2(q.name) : null;
 }
 function asExpression2(src) {
   const t = src.trim();
   return t.startsWith("{") ? `(${t})` : src;
 }
-function runnerOf(path) {
+function runnerOf(path, content) {
   const base = path.split("/").pop() ?? path;
   if (/^jest\.config\./.test(base) || base === "package.json") return "jest";
-  if (/^vitest\.config\./.test(base)) return "vitest";
+  if (/^vitest\.(?:config|workspace)\./.test(base)) return "vitest";
+  if (/^vite\.config\./.test(base) && content != null && /(?:^|[\s,{])["']?test["']?\s*:/m.test(content)) return "vitest";
   return null;
 }
-function parseSelection(src, runner) {
-  const sel = { include: null, regex: null, ignore: null, opaque: false, present: false };
+var isWorkspaceFile = (path) => /^vitest\.workspace\./.test(path.split("/").pop() ?? path);
+var empty = () => ({ include: null, regex: null, ignore: null, roots: null, base: null, projects: null, opaque: false, present: false });
+var stripRootDir = (g) => g.replace(/^<rootDir>\/?/, "");
+function dirValue(e) {
+  if (!isStr(e)) return { dir: null, opaque: true };
+  const d = stripRootDir(e.text).replace(/^\.\//, "").replace(/\/+$/, "");
+  if (d === "." || d === "" || d.split("/").includes("..")) return { dir: null, opaque: false };
+  return { dir: d, opaque: false };
+}
+function collect(root, runner) {
+  const sel = empty();
+  const seen = /* @__PURE__ */ new Set();
+  const take = (key2, e) => {
+    const { items, opaque } = literals2(e);
+    if (opaque || seen.has(key2)) sel.opaque = true;
+    seen.add(key2);
+    sel.present = true;
+    return items.map(stripRootDir);
+  };
+  const ignores = (key2, e) => {
+    const entries = take(key2, e).map((pattern) => ({ pattern, key: key2 }));
+    sel.ignore = [...sel.ignore ?? [], ...entries];
+  };
+  const projects = (e) => {
+    sel.present = true;
+    if (!ts3.isArrayLiteralExpression(e)) {
+      sel.opaque = true;
+      return;
+    }
+    const list2 = [];
+    for (const el of e.elements) {
+      if (ts3.isObjectLiteralExpression(el)) list2.push(collect(el, runner));
+      else sel.opaque = true;
+    }
+    sel.projects = list2;
+    if (list2.some((p) => p.opaque)) sel.opaque = true;
+  };
+  const visit = (node) => {
+    if (ts3.isPropertyAssignment(node)) {
+      const k = keyName2(node.name);
+      if (runner === "jest") {
+        if (k === "testMatch") sel.include = take(k, node.initializer);
+        else if (k === "testRegex") sel.regex = take(k, node.initializer);
+        else if (k === "testPathIgnorePatterns" || k === "modulePathIgnorePatterns") ignores(k, node.initializer);
+        else if (k === "roots") sel.roots = take(k, node.initializer);
+        else if (k === "rootDir") {
+          const { dir, opaque } = dirValue(node.initializer);
+          sel.present = true;
+          if (opaque) sel.opaque = true;
+          else sel.base = dir;
+        } else if (k === "projects") {
+          projects(node.initializer);
+          return;
+        }
+      } else if (ownerKey2(node) === "test") {
+        if (k === "include") sel.include = take(k, node.initializer);
+        else if (k === "exclude") ignores(k, node.initializer);
+        else if (k === "dir") {
+          const { dir, opaque } = dirValue(node.initializer);
+          sel.present = true;
+          if (opaque) sel.opaque = true;
+          else sel.base = dir;
+        } else if (k === "projects") {
+          projects(node.initializer);
+          return;
+        }
+      }
+    }
+    ts3.forEachChild(node, visit);
+  };
+  visit(root);
+  return sel;
+}
+function workspaceArray(sf) {
+  for (const st of sf.statements) {
+    let e;
+    if (ts3.isExportAssignment(st)) e = st.expression;
+    else if (ts3.isExpressionStatement(st) && ts3.isBinaryExpression(st.expression) && /module\.exports/.test(st.expression.left.getText())) e = st.expression.right;
+    if (!e) continue;
+    while (ts3.isParenthesizedExpression(e) || ts3.isAsExpression(e) || e.kind === ts3.SyntaxKind.SatisfiesExpression) {
+      e = e.expression;
+    }
+    if (ts3.isCallExpression(e) && e.arguments.length > 0) e = e.arguments[0];
+    return ts3.isArrayLiteralExpression(e) ? e : null;
+  }
+  return null;
+}
+function parseSelection(src, runner, path = "") {
+  let sel = empty();
   try {
     const sf = ts3.createSourceFile("cfg.ts", asExpression2(src), ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
-    const seen = /* @__PURE__ */ new Set();
-    const take = (key2, e) => {
-      const { items, opaque } = literals2(e);
-      if (opaque || seen.has(key2)) sel.opaque = true;
-      seen.add(key2);
-      sel.present = true;
-      return items.map((g) => g.replace(/^<rootDir>\//, ""));
-    };
-    const visit = (node) => {
-      if (ts3.isPropertyAssignment(node)) {
-        const k = keyName2(node.name);
-        if (runner === "jest") {
-          if (k === "testMatch") sel.include = take(k, node.initializer);
-          else if (k === "testRegex") sel.regex = take(k, node.initializer);
-          else if (k === "testPathIgnorePatterns") sel.ignore = take(k, node.initializer);
-        } else if (underKey2(node, "test") && !underKey2(node, "coverage")) {
-          if (k === "include") sel.include = take(k, node.initializer);
-          else if (k === "exclude") sel.ignore = take(k, node.initializer);
+    if (runner === "vitest" && isWorkspaceFile(path)) {
+      const arr = workspaceArray(sf);
+      if (arr) {
+        const list2 = [];
+        for (const el of arr.elements) {
+          if (ts3.isObjectLiteralExpression(el)) list2.push(collect(el, runner));
+          else sel.opaque = true;
         }
-      }
-      ts3.forEachChild(node, visit);
-    };
-    visit(sf);
+        sel.projects = list2;
+        sel.present = true;
+        if (list2.some((p) => p.opaque)) sel.opaque = true;
+      } else if (src.trim()) sel.opaque = true;
+    } else sel = collect(sf, runner);
   } catch {
   }
   return sel;
 }
-var globs2 = (patterns) => {
+var globs3 = (patterns) => {
   const ms = patterns.map((g) => {
     try {
       return picomatch3(g, { dot: true });
@@ -3041,6 +4537,11 @@ var globs2 = (patterns) => {
   });
   return (path) => ms.some((m) => m(path));
 };
+var globList2 = (patterns) => {
+  const pos = globs3(patterns.filter((g) => !g.startsWith("!")));
+  const neg = globs3(patterns.filter((g) => g.startsWith("!")).map((g) => g.slice(1)));
+  return (path) => pos(path) && !neg(path);
+};
 var regexes = (patterns) => {
   const rs = patterns.flatMap((p) => {
     try {
@@ -3051,29 +4552,44 @@ var regexes = (patterns) => {
   });
   return (path) => rs.some((r) => r.test("/" + path));
 };
+var underDir = (path, dir) => dir === "" || path.startsWith(dir + "/");
 function predicate(sel, runner) {
+  if (sel.projects) {
+    const ps = sel.projects.map((p) => predicate(p, runner));
+    return {
+      selects: (p) => ps.some((x) => x.selects(p)),
+      why: (p) => ps.length ? `no project selects it (${ps[0].why(p)})` : "the projects list is empty"
+    };
+  }
   const includeList = sel.include ?? (runner === "jest" ? sel.regex ? null : JEST_DEFAULT_MATCH : VITEST_DEFAULT_INCLUDE);
-  const ignoreList = sel.ignore ?? (runner === "jest" ? JEST_DEFAULT_IGNORE : VITEST_DEFAULT_EXCLUDE);
-  const included = includeList ? globs2(includeList) : sel.regex ? regexes(sel.regex) : () => true;
-  const ignored = runner === "jest" ? regexes(ignoreList) : globs2(ignoreList);
+  const ignoreList = sel.ignore ?? (runner === "jest" ? JEST_DEFAULT_IGNORE : VITEST_DEFAULT_EXCLUDE).map((pattern) => ({ pattern, key: runner === "jest" ? "testPathIgnorePatterns" : "test.exclude" }));
+  const included = includeList ? globList2(includeList) : sel.regex ? regexes(sel.regex) : () => true;
+  const ignoredBy = (p) => ignoreList.find((e) => (runner === "jest" ? regexes([e.pattern]) : globs3([e.pattern]))(p));
+  const roots = sel.roots?.map((r) => r.replace(/^\.\//, "").replace(/\/+$/, "")).map((r) => r === "." ? "" : r) ?? null;
+  const rebase = (p) => sel.base === null ? p : underDir(p, sel.base) ? p.slice(sel.base.length + 1) : null;
+  const inRoots = (p) => roots === null || roots.some((r) => underDir(p, r));
   return {
-    selects: (p) => included(p) && !ignored(p),
+    selects: (p) => {
+      const r = rebase(p);
+      return r !== null && inRoots(r) && included(r) && !ignoredBy(r);
+    },
     why: (p) => {
-      if (ignored(p)) {
-        const key3 = runner === "jest" ? "testPathIgnorePatterns" : "test.exclude";
-        const hit = ignoreList.find((g) => (runner === "jest" ? regexes([g]) : globs2([g]))(p));
-        return `${key3} now matches it (${JSON.stringify(hit ?? "")})`;
-      }
+      const r = rebase(p);
+      const baseKey = runner === "jest" ? "rootDir" : "test.dir";
+      if (r === null) return `${baseKey} no longer covers it (${JSON.stringify(sel.base)})`;
+      if (!inRoots(r)) return `roots no longer covers it (${JSON.stringify(sel.roots)})`;
+      const hit = ignoredBy(r);
+      if (hit) return `${hit.key === "exclude" ? "test.exclude" : hit.key} now matches it (${JSON.stringify(hit.pattern)})`;
       const key2 = sel.include ? runner === "jest" ? "testMatch" : "test.include" : "testRegex";
       return `${key2} no longer matches it (${JSON.stringify(sel.include ?? sel.regex ?? [])})`;
     }
   };
 }
 function suiteNarrowings(before, after, path, samples) {
-  const runner = runnerOf(path);
+  const runner = runnerOf(path, after) ?? runnerOf(path, before);
   if (!runner) return [];
-  const b = parseSelection(before ?? "", runner);
-  const a = parseSelection(after, runner);
+  const b = parseSelection(before ?? "", runner, path);
+  const a = parseSelection(after, runner, path);
   if (!a.present || a.opaque) return [];
   const pb = predicate(b, runner);
   const pa = predicate(a, runner);
@@ -3105,6 +4621,18 @@ function calleeName(expr) {
   return null;
 }
 var isEachOf = (expr) => ts4.isPropertyAccessExpression(expr) && ts4.isIdentifier(expr.expression) && (expr.expression.text === "it" || expr.expression.text === "test") && expr.name.text === "each";
+var isDescribeEach = (expr) => ts4.isPropertyAccessExpression(expr) && ts4.isIdentifier(expr.expression) && expr.expression.text === "describe" && expr.name.text === "each";
+function templateRows(node) {
+  const rows = node.template.getText().split("\n").filter((l) => /\S/.test(l.replace(/[`]/g, ""))).length - 1;
+  return Math.max(rows, 1);
+}
+function hasSubstantiveBody(call) {
+  const fn = call.arguments.find((a) => ts4.isArrowFunction(a) || ts4.isFunctionExpression(a));
+  if (!fn) return true;
+  const body = fn.body;
+  const text = ts4.isBlock(body) ? body.getText().slice(1, -1) : body.getText();
+  return text.split("\n").some((l) => isSignificantLine(l.trim(), "js"));
+}
 function eachRows(call) {
   const arg = call.arguments[0];
   if (!arg) return { n: 1, open: true };
@@ -3119,7 +4647,7 @@ function eachRows(call) {
   }
   return { n: 1, open: true };
 }
-function countTests(src, path = "spec.ts") {
+function countTests(src, path = "spec.ts", substantiveOnly = false) {
   const lang = langOf(path);
   if (lang && lang !== "js") {
     const re = TEST_DEFS[lang];
@@ -3130,23 +4658,33 @@ function countTests(src, path = "spec.ts") {
   const sf = ts4.createSourceFile("spec.ts", src, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
   let n = 0;
   let open = false;
-  const visit = (node) => {
+  const visit = (node, mult) => {
     if (ts4.isCallExpression(node)) {
+      const head = node.expression;
+      if (ts4.isCallExpression(head) && isDescribeEach(head.expression)) {
+        const r = eachRows(head);
+        if (r.open) open = true;
+        for (const a of node.arguments) visit(a, mult * r.n);
+        return;
+      }
+      if (ts4.isTaggedTemplateExpression(head) && isDescribeEach(head.tag)) {
+        for (const a of node.arguments) visit(a, mult * templateRows(head));
+        return;
+      }
       if (isEachOf(node.expression)) {
         const r = eachRows(node);
-        n += r.n;
+        n += r.n * mult;
         if (r.open) open = true;
       } else {
         const name = calleeName(node.expression);
-        if (name === "it" || name === "test") n++;
+        if ((name === "it" || name === "test") && (!substantiveOnly || hasSubstantiveBody(node))) n += mult;
       }
     } else if (ts4.isTaggedTemplateExpression(node) && isEachOf(node.tag)) {
-      const rows = node.template.getText().split("\n").filter((l) => /\S/.test(l.replace(/[`]/g, ""))).length - 1;
-      n += Math.max(rows, 1);
+      n += templateRows(node) * mult;
     }
-    ts4.forEachChild(node, visit);
+    ts4.forEachChild(node, (c) => visit(c, mult));
   };
-  visit(sf);
+  visit(sf, 1);
   return { min: n, open };
 }
 function countTestBlocks(src, path = "spec.ts") {
@@ -3161,7 +4699,7 @@ function significantLines(src, path) {
   }
   return out2;
 }
-var OTHER_RUNNER_DIR = /(?:^|\/)(?:e2e|cypress|playwright)\//;
+var OTHER_RUNNER_DIR = /(?:^|\/)(?:e2e|cypress|playwright|fixtures|__fixtures__|__mocks__)\//;
 function runnerSamples(configPath, policy, ctx) {
   const files = trackedFiles(ctx);
   if (!files) return CANONICAL_SAMPLES;
@@ -3169,6 +4707,34 @@ function runnerSamples(configPath, policy, ctx) {
   const own = files.filter((f) => f.startsWith(root) && langOf(f) === "js" && isProtected(f, policy, "tests") && !OTHER_RUNNER_DIR.test(f)).map((f) => f.slice(root.length));
   return own.length ? own : CANONICAL_SAMPLES;
 }
+function scriptNarrowings(before, after, path) {
+  if ((path.split("/").pop() ?? path) !== "package.json") return [];
+  const scriptsOf = (src) => {
+    try {
+      const s = JSON.parse(src ?? "{}").scripts ?? {};
+      return Object.fromEntries(Object.entries(s).filter((e) => typeof e[1] === "string"));
+    } catch {
+      return {};
+    }
+  };
+  const was = scriptsOf(before);
+  const now = scriptsOf(after);
+  const out2 = [];
+  for (const [name, cmd] of Object.entries(now)) {
+    if (!/^test(?:$|[:.-])/.test(name) || !/\b(?:jest|vitest)\b/.test(cmd)) continue;
+    const prev = was[name] ?? "";
+    const flags = new RegExp(SUITE_NARROWING_FLAGS.source, "g");
+    for (const m of cmd.matchAll(flags)) {
+      const flag = m[0].trim();
+      if (!flag) continue;
+      const one = new RegExp(SUITE_NARROWING_FLAGS.source);
+      if (one.test(prev) && prev.includes(flag)) continue;
+      out2.push({ script: name, flag, before: prev, after: cmd });
+      break;
+    }
+  }
+  return out2;
+}
 function joinRoot(root, to) {
   const parts = root ? root.split("/") : [];
   for (const seg of to.replace(/\/+$/, "").split("/")) {
@@ -3200,11 +4766,11 @@ var testDeletion = {
       if (c.kind !== "file" || c.after == null || !isProtected(c.path, policy, "tests")) continue;
       if (c.op === "add") {
         for (const l of significantLines(c.after, c.path)) addedTestLines.add(l);
-        addedTestBlocks += countTestBlocks(c.after, c.path);
+        addedTestBlocks += countTests(c.after, c.path, true).min;
       } else if (c.before != null) {
         const before = significantLines(c.before, c.path);
         for (const l of significantLines(c.after, c.path)) if (!before.has(l)) addedTestLines.add(l);
-        addedTestBlocks += Math.max(0, countTestBlocks(c.after, c.path) - countTestBlocks(c.before, c.path));
+        addedTestBlocks += Math.max(0, countTests(c.after, c.path, true).min - countTests(c.before, c.path, true).min);
       }
     }
     const isRelocation = (removed, blocksRemoved) => {
@@ -3251,7 +4817,7 @@ var testDeletion = {
               })
             );
           }
-        } else if (c.op !== "delete" && c.after != null && !isTest && isProtected(c.path, policy, "config") && runnerOf(c.path)) {
+        } else if (c.op !== "delete" && c.after != null && !isTest && isProtected(c.path, policy, "config") && runnerOf(c.path, c.after)) {
           for (const n of suiteNarrowings(c.before, c.after, c.path, runnerSamples(c.path, policy, ctx))) {
             out2.push(
               makeFinding(RULE7, policy, {
@@ -3262,6 +4828,16 @@ var testDeletion = {
               })
             );
           }
+          for (const n of scriptNarrowings(c.before, c.after, c.path)) {
+            out2.push(
+              makeFinding(RULE7, policy, {
+                file: c.path,
+                message: `The test script now narrows the suite: ${n.flag} added to scripts.${n.script}.`,
+                evidence: `"${n.script}": ${JSON.stringify(n.before)} \u2192 ${JSON.stringify(n.after)}`,
+                remediation: "Keep the test script running the whole suite; a runner flag that selects fewer specs removes the rest from every run."
+              })
+            );
+          }
         }
       } else {
         let root = "";
@@ -3275,15 +4851,25 @@ var testDeletion = {
           const inRepo = (t) => root ? `${root}/${t}` : t;
           const listing = trackedFiles(ctx);
           const testToks = toks.filter((t) => {
-            if (!isProtected(t, policy, "tests")) return false;
+            const resolved = root !== null && /(?:^|\/)\.{1,2}(?:\/|$)/.test(t) ? joinRoot(root, t) : null;
+            const probe = resolved ?? t;
+            if (!isProtected(probe, policy, "tests")) return false;
             if (!listing || root === null) return true;
-            const looksLikeFile = /\.[A-Za-z0-9]+$/.test(t.split("/").pop() ?? "");
-            if (looksLikeFile || listing.includes(inRepo(t))) return true;
-            return containsProtected(inRepo(t), policy, "tests", ctx);
+            const looksLikeFile = /\.[A-Za-z0-9]+$/.test(probe.split("/").pop() ?? "");
+            if (looksLikeFile || listing.includes(resolved ?? inRepo(t))) return true;
+            return containsProtected(resolved ?? inRepo(t), policy, "tests", ctx);
+          });
+          const rootHasProtected = () => listing ? listing.some((f) => isProtected(f, policy, "tests")) : true;
+          const dirToks = toks.filter((t) => {
+            if (t.startsWith("-") || testToks.includes(t)) return false;
+            const whole = /^(?:\.|\.\/|\*|\.\/\*)$/.test(t);
+            if (!whole && /[*?{}[\]]/.test(t)) return false;
+            if (root === null) return whole ? false : containsProtected(t, policy, "tests", ctx);
+            const dir = whole ? root : joinRoot(root, t);
+            if (dir === null) return false;
+            if (dir === "") return rootHasProtected();
+            return containsProtected(dir, policy, "tests", ctx);
           });
-          const dirToks = toks.filter(
-            (t) => !t.startsWith("-") && !testToks.includes(t) && !/[*?{}[\]]/.test(t) && (root === null ? containsProtected(t, policy, "tests", ctx) : containsProtected(inRepo(t), policy, "tests", ctx))
-          );
           if (testToks.length === 0 && dirToks.length === 0) continue;
           const named = [...testToks, ...dirToks];
           const cmd = toks[0] ?? "";
@@ -3294,8 +4880,11 @@ var testDeletion = {
           const findDeletes = cmd === "find" && /\s(?:-delete\b|-exec\s+(?:rm|unlink)\b|-execdir\s+(?:rm|unlink)\b)/.test(seg);
           const gitRestoresOld = cmd === "git" && /^git\s+(?:checkout|restore)\b/.test(seg) && (() => {
             const src = seg.match(/--source[= ]\s*(\S+)/)?.[1];
-            const rev = src ?? toks.slice(2).find((t) => !t.startsWith("-") && !named.includes(t) && t !== "--");
-            return !!rev && rev !== "HEAD" && (!!src || seg.includes(" -- "));
+            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") return false;
+            if (src || seg.includes(" -- ")) return true;
+            return revIdx >= 0 && toks.some((t, i) => i > revIdx && named.includes(t));
           })();
           if (/\brm\b/.test(seg) && !/^(?:git|npm|yarn|pnpm|bun)\b/.test(seg)) {
             why = "rm deletes a test file";
@@ -3350,7 +4939,7 @@ var MIN_REMOVED_LINES = 3;
 var MIN_REMOVED_ROWS = 2;
 var ws = (s) => s.replace(/\s+/g, "");
 function eachTables(src, path) {
-  const rows = /* @__PURE__ */ new Set();
+  const rows = /* @__PURE__ */ new Map();
   let open = false;
   if (langOf(path) !== "js" && langOf(path) !== null) return { rows, open };
   try {
@@ -3364,10 +4953,9 @@ function eachTables(src, path) {
               open = true;
               continue;
             }
-            for (const raw of el.getText(sf).split("\n")) {
-              const l = raw.trim().replace(/,$/, "");
-              if (isSignificantLine(l, "js")) rows.add(l);
-            }
+            const text = el.getText(sf).replace(/\s*\n\s*/g, " ");
+            const key2 = ws(text);
+            if (key2.length >= 3) rows.set(key2, text);
           }
         } else open = true;
       }
@@ -3422,12 +5010,13 @@ var testContentRemoval = {
         gone.push(line);
       }
       const table = eachTables(c.before, c.path);
-      const goneRows = table.rows.size && eachTables(c.after, c.path).open ? gone.filter((l) => table.rows.has(l.replace(/,$/, "")) && !addedPool.includes(ws(l))) : [];
+      const tableAfter = eachTables(c.after, c.path);
+      const goneRows = table.rows.size && tableAfter.open ? [...table.rows].filter(([k]) => !tableAfter.rows.has(k) && !addedPool.includes(k)).map(([, text]) => text) : [];
       if (goneRows.length >= MIN_REMOVED_ROWS) {
         out2.push(
           makeFinding(RULE8, policy, {
             file: c.path,
-            message: `Rows removed from a test table: ${goneRows.length} case(s) gone from an each-table that now spreads from elsewhere, and they reappear nowhere in the change.`,
+            message: `Rows removed from a test table: ${goneRows.length} case(s) gone from an each-table that spreads from elsewhere, and they reappear nowhere in the change.`,
             evidence: goneRows.slice(0, 3).map((l) => l.slice(0, 80)).join(" | "),
             remediation: "Fix the code under test. A row of it.each is a test; moving the table out of the spec must carry every row with it."
           })
@@ -3564,7 +5153,7 @@ var GUARDED_RULE = "hook-tampering";
 var BASELINE_HOOKS = defaultPolicy().protected.hooks;
 function isGuardedFinding(f) {
   if (f.rule !== GUARDED_RULE || !f.file) return false;
-  return isPolicyFile(f.file) || matchesAny(f.file, BASELINE_HOOKS);
+  return isPolicyFile(f.file) || matchesAny(f.file, BASELINE_HOOKS) || isClaudeSettings(f.file);
 }
 function key(f) {
   return `${f.rule}|${f.file ?? ""}|${f.line ?? ""}|${f.evidence}`;
@@ -3623,8 +5212,8 @@ function hasBlocking(findings) {
 }
 
 // src/policy-load.ts
-import { readFileSync as readFileSync3, existsSync as existsSync2 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join3, posix } from "node:path";
+import { readFileSync as readFileSync4, existsSync as existsSync2 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join4, posix } from "node:path";
 import { parse as parse2 } from "yaml";
 var PolicyError = class extends Error {
 };
@@ -3672,8 +5261,8 @@ function validate(r, where) {
   if (r.ignore !== void 0 && !isStringList(r.ignore)) bad(`ignore must be a list of globs, got ${show(r.ignore)}`);
   if (r.protected !== void 0) {
     if (!isMapping(r.protected)) bad(`protected must be a mapping of category to a list of globs, got ${show(r.protected)}`);
-    for (const [cat, globs3] of Object.entries(r.protected)) {
-      if (!isStringList(globs3)) bad(`protected.${cat} must be a list of globs, got ${show(globs3)}`);
+    for (const [cat, globs4] of Object.entries(r.protected)) {
+      if (!isStringList(globs4)) bad(`protected.${cat} must be a list of globs, got ${show(globs4)}`);
     }
   }
   if (r.signoff !== void 0) {
@@ -3705,10 +5294,10 @@ function parsePolicy(raw, where = POLICY_FILE) {
   const version = normalizeVersion(r.version, where);
   validate(r, where);
   const base = defaultPolicy(version);
-  const globs3 = (list) => list?.map(normalizeGlob);
-  const userProtected = r.protected ? Object.fromEntries(Object.entries(r.protected).map(([cat, list]) => [cat, globs3(list) ?? []])) : void 0;
+  const globs4 = (list2) => list2?.map(normalizeGlob);
+  const userProtected = r.protected ? Object.fromEntries(Object.entries(r.protected).map(([cat, list2]) => [cat, globs4(list2) ?? []])) : void 0;
   const userRules = r.rules ? Object.fromEntries(
-    Object.entries(r.rules).map(([name, cfg]) => [name, cfg?.exclude ? { ...cfg, exclude: globs3(cfg.exclude) } : cfg])
+    Object.entries(r.rules).map(([name, cfg]) => [name, cfg?.exclude ? { ...cfg, exclude: globs4(cfg.exclude) } : cfg])
   ) : void 0;
   return {
     version,
@@ -3718,7 +5307,7 @@ function parsePolicy(raw, where = POLICY_FILE) {
     // an `exclude`-only override drop the rule's baseline severity (see mergeRules).
     protected: mergeProtected(base.protected, userProtected),
     rules: mergeRules(base.rules, userRules),
-    ignore: globs3(r.ignore) ?? base.ignore,
+    ignore: globs4(r.ignore) ?? base.ignore,
     signoff: {
       requiredFor: r.signoff?.required_for ?? r.signoff?.requiredFor ?? base.signoff.requiredFor,
       ledger: r.signoff?.ledger ?? base.signoff.ledger
@@ -3748,9 +5337,9 @@ function parseOrThrow(src, where) {
   return parsePolicy(raw, where);
 }
 function loadPolicy(cwd = process.cwd()) {
-  const path = join3(cwd, POLICY_FILE);
+  const path = join4(cwd, POLICY_FILE);
   if (!existsSync2(path)) return defaultPolicy();
-  return parseOrThrow(readFileSync3(path, "utf8"), POLICY_FILE);
+  return parseOrThrow(readFileSync4(path, "utf8"), POLICY_FILE);
 }
 function loadPolicyAt(rev, cwd) {
   const src = fileAt(rev, POLICY_FILE, { cwd });
@@ -3760,8 +5349,8 @@ function loadPolicyAt(rev, cwd) {
 
 // src/signoff.ts
 import { createHash } from "node:crypto";
-import { appendFileSync, mkdirSync, readFileSync as readFileSync4, existsSync as existsSync3 } from "node:fs";
-import { dirname, join as join4 } from "node:path";
+import { appendFileSync, mkdirSync, readFileSync as readFileSync5, existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
 var DEFAULT_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 function fingerprint(rule, file, evidence) {
   return createHash("sha256").update(`${rule}\0${file ?? ""}\0${evidence}`).digest("hex").slice(0, 16);
@@ -3772,13 +5361,13 @@ function ledgerPath(cwd, policy) {
   if (!ledgerInsideRepo(rel)) {
     throw new PolicyError(`signoff.ledger must be a relative path inside the repository, got ${JSON.stringify(rel)}`);
   }
-  return join4(cwd, rel);
+  return join5(cwd, rel);
 }
 function readLedger(cwd, policy) {
   const p = ledgerPath(cwd, policy);
   if (!existsSync3(p)) return [];
   const out2 = [];
-  for (const line of readFileSync4(p, "utf8").split("\n")) {
+  for (const line of readFileSync5(p, "utf8").split("\n")) {
     if (!line.trim()) continue;
     try {
       const e = JSON.parse(line);
@@ -3790,7 +5379,7 @@ function readLedger(cwd, policy) {
 }
 function appendEntry(cwd, policy, e) {
   const p = ledgerPath(cwd, policy);
-  mkdirSync(dirname(p), { recursive: true });
+  mkdirSync(dirname2(p), { recursive: true });
   appendFileSync(p, JSON.stringify(e) + "\n");
 }
 function makeEntry(f, reason, now, ttlMs = DEFAULT_TTL_MS) {
@@ -4147,21 +5736,21 @@ function runCheck(opts) {
 }
 
 // src/cli/hook.ts
-import { readFileSync as readFileSync10, appendFileSync as appendFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync7, statSync as statSync4 } from "node:fs";
+import { readFileSync as readFileSync11, appendFileSync as appendFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync7, statSync as statSync4 } from "node:fs";
 import { createHash as createHash4 } from "node:crypto";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/adapters/claude/changes.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { readFileSync as readFileSync5, existsSync as existsSync4, writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { readFileSync as readFileSync6, existsSync as existsSync4, writeFileSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { isAbsolute as isAbsolute3, join as join5, relative as relative2, resolve } from "node:path";
+import { isAbsolute as isAbsolute3, join as join6, relative as relative2, resolve } from "node:path";
 function asStr(v) {
   return typeof v === "string" ? v : "";
 }
 function readDisk(path) {
   try {
-    return existsSync4(path) ? readFileSync5(path, "utf8") : null;
+    return existsSync4(path) ? readFileSync6(path, "utf8") : null;
   } catch {
     return null;
   }
@@ -4184,11 +5773,11 @@ function synthFileChange(displayPath, before, after) {
   if (before === null) op = "add";
   else if (after === null) op = "delete";
   else op = "modify";
-  const dir = mkdtempSync(join5(tmpdir(), "hf-"));
+  const dir = mkdtempSync(join6(tmpdir(), "hf-"));
   let raw = "";
   try {
-    const a = join5(dir, "a");
-    const b = join5(dir, "b");
+    const a = join6(dir, "a");
+    const b = join6(dir, "b");
     writeFileSync(a, before ?? "");
     writeFileSync(b, after ?? "");
     try {
@@ -4273,14 +5862,14 @@ function formatDenial(blocks) {
 }
 
 // src/session.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join6 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join7 } from "node:path";
 var UNSAFE = /[^A-Za-z0-9_-]/g;
 var SHA = /^[0-9a-f]{7,40}$/;
 function baselinePath(cwd, sessionId) {
   const gd = gitDir(cwd);
   if (!gd) return null;
-  return join6(gd, "tamperward", `session-${sessionId.replace(UNSAFE, "")}`);
+  return join7(gd, "tamperward", `session-${sessionId.replace(UNSAFE, "")}`);
 }
 function turnBaseline(cwd, sessionId) {
   if (!sessionId) return null;
@@ -4288,12 +5877,12 @@ function turnBaseline(cwd, sessionId) {
     const p = baselinePath(cwd, sessionId);
     if (!p) return null;
     if (existsSync5(p)) {
-      const v = readFileSync6(p, "utf8").trim();
+      const v = readFileSync7(p, "utf8").trim();
       if (SHA.test(v)) return v;
     }
     const head = headSha(cwd);
     if (!head) return null;
-    mkdirSync2(dirname2(p), { recursive: true });
+    mkdirSync2(dirname3(p), { recursive: true });
     writeFileSync2(p, head);
     return head;
   } catch {
@@ -4306,7 +5895,7 @@ function advanceTurnBaseline(cwd, sessionId) {
     const p = baselinePath(cwd, sessionId);
     const head = headSha(cwd);
     if (!p || !head) return;
-    mkdirSync2(dirname2(p), { recursive: true });
+    mkdirSync2(dirname3(p), { recursive: true });
     writeFileSync2(p, head);
   } catch {
   }
@@ -4314,8 +5903,8 @@ 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, renameSync, rmSync as rmSync2, statSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { isAbsolute as isAbsolute4, join as join7 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync8, renameSync, rmSync as rmSync2, statSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { isAbsolute as isAbsolute4, join as join8 } from "node:path";
 import { execFileSync as execFileSync4 } from "node:child_process";
 var UNSAFE2 = /[^A-Za-z0-9._-]/g;
 var SKIP_DIRS2 = /* @__PURE__ */ new Set([".git", "node_modules", ".hg", ".svn"]);
@@ -4327,7 +5916,7 @@ function gitDir2(cwd) {
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
     if (!d) return null;
-    return isAbsolute4(d) ? d : join7(cwd, d);
+    return isAbsolute4(d) ? d : join8(cwd, d);
   } catch {
     return null;
   }
@@ -4336,8 +5925,8 @@ function statePath(cwd, sessionId, kind) {
   if (!sessionId) return null;
   const gd = gitDir2(cwd);
   if (!gd) return null;
-  const dir = join7(gd, "tamperward");
-  return join7(dir, `${kind}-${sessionId.replace(UNSAFE2, "")}.json`);
+  const dir = join8(gd, "tamperward");
+  return join8(dir, `${kind}-${sessionId.replace(UNSAFE2, "")}.json`);
 }
 function ptreePath(cwd, sessionId) {
   return statePath(cwd, sessionId, "ptree");
@@ -4351,8 +5940,8 @@ function contentHash(content) {
 }
 function snapshotProtected(cwd, policy, prev) {
   const out2 = {};
-  const walk = (rel) => {
-    const abs2 = rel ? join7(cwd, rel) : cwd;
+  const walk2 = (rel) => {
+    const abs2 = rel ? join8(cwd, rel) : cwd;
     let names;
     try {
       names = readdirSync(abs2);
@@ -4364,15 +5953,15 @@ function snapshotProtected(cwd, policy, prev) {
       const r = rel ? `${rel}/${name}` : name;
       let st;
       try {
-        st = statSync(join7(cwd, r));
+        st = statSync(join8(cwd, r));
       } catch {
         continue;
       }
-      if (st.isDirectory()) walk(r);
+      if (st.isDirectory()) walk2(r);
       else if (st.isFile() && isProtected(r, policy)) {
         let hash = "";
         try {
-          hash = sha(readFileSync7(join7(cwd, r)));
+          hash = sha(readFileSync8(join8(cwd, r)));
         } catch {
           hash = "unreadable";
         }
@@ -4380,7 +5969,7 @@ function snapshotProtected(cwd, policy, prev) {
       }
     }
   };
-  walk("");
+  walk2("");
   return out2;
 }
 function driftBetween(expected, current) {
@@ -4400,7 +5989,7 @@ function driftBetween(expected, current) {
 function loadTree(p) {
   if (!p || !existsSync6(p)) return null;
   try {
-    return JSON.parse(readFileSync7(p, "utf8"));
+    return JSON.parse(readFileSync8(p, "utf8"));
   } catch {
     return null;
   }
@@ -4408,7 +5997,7 @@ function loadTree(p) {
 function saveTree(p, tree) {
   if (!p) return;
   try {
-    mkdirSync3(join7(p, ".."), { recursive: true });
+    mkdirSync3(join8(p, ".."), { recursive: true });
     const tmp = `${p}.${process.pid}.tmp`;
     writeFileSync3(tmp, JSON.stringify(tree));
     renameSync(tmp, p);
@@ -4439,15 +6028,15 @@ function dropTurnTree(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";
-import { join as join8 } from "node:path";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync2, watch } from "node:fs";
+import { join as join9 } from "node:path";
 import { createHash as createHash3 } from "node:crypto";
 var SKIP2 = /(^|\/)(\.git|node_modules)(\/|$)/;
 function snap(abs2) {
   try {
     const st = statSync2(abs2);
     if (!st.isFile()) return { mode: st.mode, size: null, hash: null };
-    const hash = createHash3("sha256").update(readFileSync8(abs2)).digest("hex").slice(0, 16);
+    const hash = createHash3("sha256").update(readFileSync9(abs2)).digest("hex").slice(0, 16);
     return { mode: st.mode, size: st.size, hash };
   } catch {
     return { mode: null, size: null, hash: null };
@@ -4455,7 +6044,7 @@ function snap(abs2) {
 }
 function defaultEventLog(cwd) {
   if (process.env.TAMPERWARD_FSEVENTS) return process.env.TAMPERWARD_FSEVENTS;
-  return join8(gitDir(cwd) ?? join8(cwd, ".git"), "tamperward", "fsevents.jsonl");
+  return join9(gitDir(cwd) ?? join9(cwd, ".git"), "tamperward", "fsevents.jsonl");
 }
 function watchTree(dir, cb) {
   if (process.env.TAMPERWARD_WATCH_NO_RECURSIVE !== "1") {
@@ -4472,12 +6061,12 @@ function watchTree(dir, cb) {
     if (watchers.has(rel) || SKIP2.test(rel + "/")) return;
     let w;
     try {
-      w = watch(rel ? join8(dir, rel) : dir, (kind, fname) => {
+      w = watch(rel ? join9(dir, rel) : dir, (kind, fname) => {
         if (!fname) return;
         const child = rel ? `${rel}/${String(fname)}` : String(fname);
         cb(kind, child);
         try {
-          if (statSync2(join8(dir, child)).isDirectory()) addDir(child);
+          if (statSync2(join9(dir, child)).isDirectory()) addDir(child);
         } catch {
         }
       });
@@ -4486,11 +6075,11 @@ function watchTree(dir, cb) {
     }
     watchers.set(rel, w);
   };
-  const walk = (rel) => {
+  const walk2 = (rel) => {
     addDir(rel);
     let names = [];
     try {
-      names = readdirSync2(rel ? join8(dir, rel) : dir);
+      names = readdirSync2(rel ? join9(dir, rel) : dir);
     } catch {
       return;
     }
@@ -4498,25 +6087,25 @@ function watchTree(dir, cb) {
       const child = rel ? `${rel}/${name}` : name;
       if (SKIP2.test(child + "/")) continue;
       try {
-        if (statSync2(join8(dir, child)).isDirectory()) walk(child);
+        if (statSync2(join9(dir, child)).isDirectory()) walk2(child);
       } catch {
       }
     }
   };
-  walk("");
+  walk2("");
   return { close: () => {
     for (const w of watchers.values()) w.close();
   } };
 }
 function startWatcher(dir, log, policy) {
   try {
-    mkdirSync4(join8(log, ".."), { recursive: true });
+    mkdirSync4(join9(log, ".."), { recursive: true });
   } catch {
   }
   const last = /* @__PURE__ */ new Map();
   return watchTree(dir, (kind, rel) => {
     if (SKIP2.test(rel) || !isProtected(rel, policy)) return;
-    const s = snap(join8(dir, rel));
+    const s = snap(join9(dir, rel));
     const key2 = `${s.hash}:${s.mode}`;
     if (last.get(rel) === key2) return;
     last.set(rel, key2);
@@ -4543,7 +6132,7 @@ function runWatch(args) {
 }
 
 // src/detectors/fs-events.ts
-import { readFileSync as readFileSync9, statSync as statSync3 } from "node:fs";
+import { readFileSync as readFileSync10, statSync as statSync3 } from "node:fs";
 var RULE11 = "transient-protected-mutation";
 function readEvents(log, offset) {
   let size = 0;
@@ -4553,7 +6142,7 @@ function readEvents(log, offset) {
     return { events: [], newOffset: offset };
   }
   if (size <= offset) return { events: [], newOffset: offset >= 0 ? Math.min(offset, size) : 0 };
-  const raw = readFileSync9(log, "utf8").slice(offset);
+  const raw = readFileSync10(log, "utf8").slice(offset);
   const events = [];
   for (const line of raw.split("\n")) {
     if (!line.trim()) continue;
@@ -4606,7 +6195,7 @@ var HookInputError = class extends Error {
 };
 function readStdin() {
   try {
-    return readFileSync10(0, "utf8");
+    return readFileSync11(0, "utf8");
   } catch (e) {
     throw new HookInputError(`cannot read the hook payload on stdin: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -4665,7 +6254,7 @@ function fileChanges(changes) {
 }
 function hashOnDisk(cwd, rel) {
   try {
-    return contentHash(readFileSync10(join9(cwd, rel)));
+    return contentHash(readFileSync11(join10(cwd, rel)));
   } catch {
     return null;
   }
@@ -4854,7 +6443,7 @@ function turnTransientBlocks(cwd, sessionId, policy, changes) {
   if (!existsSync7(log)) return none;
   let offset = 0;
   if (cp && existsSync7(cp)) {
-    const n = Number(readFileSync10(cp, "utf8"));
+    const n = Number(readFileSync11(cp, "utf8"));
     offset = Number.isFinite(n) ? n : 0;
   }
   const { events, newOffset } = readEvents(log, offset);
@@ -4868,7 +6457,7 @@ function turnTransientBlocks(cwd, sessionId, policy, changes) {
   const finalHash = (path) => {
     try {
       if (!statSync4(`${cwd}/${path}`).isFile()) return null;
-      return createHash4("sha256").update(readFileSync10(`${cwd}/${path}`)).digest("hex").slice(0, 16);
+      return createHash4("sha256").update(readFileSync11(`${cwd}/${path}`)).digest("hex").slice(0, 16);
     } catch {
       return null;
     }
@@ -5011,9 +6600,8 @@ Honored at LOCAL pre-commit only. The agent-layer hook ignores this file; CI req
 // src/cli/init.ts
 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 isAbsolute5, join as join10, relative as relative3, resolve as resolve2 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync5, chmodSync, statSync as statSync5 } from "node:fs";
+import { basename, dirname as dirname4, isAbsolute as isAbsolute5, join as join11, relative as relative3, resolve as resolve2 } from "node:path";
 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);
 function gitConfig(cwd, key2) {
@@ -5023,12 +6611,9 @@ function gitConfig(cwd, key2) {
     return null;
   }
 }
-var PRE_MATCHER = "Bash|Edit|Write|MultiEdit|NotebookEdit";
-var MARKER = "# tamperward: block agent shortcuts before they land";
 var HOOK_RE = /\btamperward(?:@\S+)?\s+hook\s+claude\b/;
 var SWEEP_RE = /\btamperward(?:@\S+)?\s+sweep\s+claude\b/;
 var PRECOMMIT_RE = /\btamperward(?:@\S+)?\s+check\s+--staged\b/;
-var OURS = /^\s*npx\s+(?:--yes|-y)\s+tamperward(?:@(\S+))?\s+(hook claude|sweep claude|check --staged)\s*$/;
 var CODEOWNERS_MARK = "# tamperward: the gate cannot guard the file that defines it";
 var CODEOWNERS_PATHS = ["/.github/workflows/", "/.tamperward.yml", "/.github/CODEOWNERS"];
 function coveredBy(existing, critical) {
@@ -5072,24 +6657,6 @@ version: 1
 #   snapshot-rewrite: { severity: block }
 # ignore: []            # visible blind spots \u2014 the count is always reported
 `;
-function shippedVersion() {
-  try {
-    const here = dirname3(fileURLToPath(import.meta.url));
-    for (const rel of ["../package.json", "../../package.json", "../../../package.json"]) {
-      try {
-        const pkg = JSON.parse(readFileSync11(join10(here, rel), "utf8"));
-        if (pkg.name === "tamperward" && pkg.version) return pkg.version;
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return "latest";
-}
-var TW_VERSION = shippedVersion();
-var HOOK_CMD = `npx --yes tamperward@${TW_VERSION} hook claude`;
-var SWEEP_CMD = `npx --yes tamperward@${TW_VERSION} sweep claude`;
-var PRECOMMIT_CMD = `npx --yes tamperward@${TW_VERSION} check --staged`;
 function pinOf(command) {
   const m = command.match(OURS);
   return m ? m[1] ?? "" : null;
@@ -5184,13 +6751,13 @@ function readWorkflowMark(src) {
   if (!m) return null;
   return { version: m[1], hash: m[2], body: src.replace(WORKFLOW_MARK_RE, "") };
 }
-function toolSet2(matcher2) {
+function toolSet(matcher2) {
   const m = String(matcher2 ?? "").trim();
   if (m === "" || m === "*") return null;
   return new Set(m.split("|").map((t) => t.trim()).filter(Boolean));
 }
 function missingTools(matcher2) {
-  const have = toolSet2(matcher2);
+  const have = toolSet(matcher2);
   if (have === null) return [];
   return PRE_MATCHER.split("|").filter((t) => !have.has(t));
 }
@@ -5210,7 +6777,7 @@ function hooksShapeError(hooks) {
   return null;
 }
 function planPolicy(cwd) {
-  const path = join10(cwd, POLICY_FILE);
+  const path = join11(cwd, POLICY_FILE);
   if (existsSync8(path)) {
     try {
       loadPolicy(cwd);
@@ -5229,12 +6796,12 @@ function planPolicy(cwd) {
 }
 function planClaudeHooks(cwd) {
   const rel = ".claude/settings.json";
-  const path = join10(cwd, rel);
+  const path = join11(cwd, rel);
   let settings = {};
   if (existsSync8(path)) {
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync11(path, "utf8"));
+      parsed = JSON.parse(readFileSync12(path, "utf8"));
     } catch {
       return {
         item: "agent",
@@ -5287,12 +6854,12 @@ function planClaudeHooks(cwd) {
         });
       }
       for (const m of stale) {
-        m.matcher = [...toolSet2(m.matcher) ?? /* @__PURE__ */ new Set(), ...missingTools(m.matcher)].join("|");
+        m.matcher = [...toolSet(m.matcher) ?? /* @__PURE__ */ new Set(), ...missingTools(m.matcher)].join("|");
       }
       if (needStop) {
         (hooks.Stop ??= []).push({ hooks: [{ type: "command", command: SWEEP_CMD }] });
       }
-      mkdirSync5(dirname3(path), { recursive: true });
+      mkdirSync5(dirname4(path), { recursive: true });
       writeFileSync5(path, JSON.stringify(settings, null, 2) + "\n");
     }
   };
@@ -5327,7 +6894,7 @@ function hooksDir(cwd) {
     if (out2) return resolve2(cwd, out2);
   } catch {
   }
-  return existsSync8(join10(cwd, ".git")) ? join10(cwd, ".git", "hooks") : null;
+  return existsSync8(join11(cwd, ".git")) ? join11(cwd, ".git", "hooks") : null;
 }
 function display(cwd, path) {
   const rel = relative3(cwd, path);
@@ -5354,30 +6921,30 @@ function planPreCommit(cwd) {
   const skip = (detail) => ({ item: "pre-commit", path: "(none)", status: "skip", detail });
   let path;
   let note;
-  if (existsSync8(join10(cwd, ".husky"))) {
-    path = join10(cwd, ".husky", "pre-commit");
+  if (existsSync8(join11(cwd, ".husky"))) {
+    path = join11(cwd, ".husky", "pre-commit");
     note = "husky";
   } else {
-    const managed = MANAGED_HOOKS.find((m) => m.configs.some((c) => existsSync8(join10(cwd, c))));
+    const managed = MANAGED_HOOKS.find((m) => m.configs.some((c) => existsSync8(join11(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 = join10(dirname3(dir), "pre-commit");
+    if (basename(dir) === "_" && basename(dirname4(dir)) === ".husky") {
+      path = join11(dirname4(dir), "pre-commit");
       note = "husky";
     } else {
-      path = join10(dir, "pre-commit");
+      path = join11(dir, "pre-commit");
       const rel2 = display(cwd, dir);
-      note = rel2 === join10(".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 === join11(".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);
   if (existsSync8(path) && !statSync5(path).isFile()) {
     return { item: "pre-commit", path: rel, status: "error", detail: "exists but is not a regular file \u2014 refusing to write" };
   }
-  const existing = existsSync8(path) ? readFileSync11(path, "utf8") : null;
+  const existing = existsSync8(path) ? readFileSync12(path, "utf8") : null;
   if (existing === null) {
     return {
       item: "pre-commit",
@@ -5385,7 +6952,7 @@ function planPreCommit(cwd) {
       status: "create",
       detail: `create via ${note}`,
       apply: () => {
-        mkdirSync5(dirname3(path), { recursive: true });
+        mkdirSync5(dirname4(path), { recursive: true });
         writeFileSync5(path, `#!/bin/sh
 ${block.join("\n")}
 `);
@@ -5466,10 +7033,10 @@ ${block.join("\n")}
 function planCodeowners(cwd) {
   const rel = ".github/CODEOWNERS";
   const existingRel = [".github/CODEOWNERS", "CODEOWNERS", "docs/CODEOWNERS"].find(
-    (r) => existsSync8(join10(cwd, r))
+    (r) => existsSync8(join11(cwd, r))
   );
-  const path = join10(cwd, existingRel ?? rel);
-  const existing = existingRel ? readFileSync11(path, "utf8") : null;
+  const path = join11(cwd, existingRel ?? rel);
+  const existing = existingRel ? readFileSync12(path, "utf8") : null;
   const missing = CODEOWNERS_PATHS.filter((p) => existing === null || !coveredBy(existing, p));
   if (missing.length === 0) {
     return { item: "codeowners", path: existingRel, status: "ok", detail: "gate paths already have code owners" };
@@ -5495,16 +7062,16 @@ ${CODEOWNERS_MARK}
       warning: `${inferred.owner} was inferred from the origin remote and is not confirmed to be a user. If "${inferred.owner.slice(1)}" is an organisation, replace it with ${inferred.owner}/<team> in CODEOWNERS: GitHub rejects a bare organisation as an owner, and a rule with an invalid owner protects nothing.`
     } : {},
     apply: () => {
-      mkdirSync5(dirname3(path), { recursive: true });
+      mkdirSync5(dirname4(path), { recursive: true });
       writeFileSync5(path, existing === null ? block.replace(/^\n/, "") : existing.replace(/\n?$/, "\n") + block);
     }
   };
 }
 function planWorkflow(cwd, force) {
   const rel = ".github/workflows/tamperward.yml";
-  const path = join10(cwd, rel);
+  const path = join11(cwd, rel);
   const write = () => {
-    mkdirSync5(dirname3(path), { recursive: true });
+    mkdirSync5(dirname4(path), { recursive: true });
     writeFileSync5(path, workflowFile(WORKFLOW_CONTENT));
   };
   if (!existsSync8(path)) {
@@ -5518,7 +7085,7 @@ function planWorkflow(cwd, force) {
   }
   let src;
   try {
-    src = readFileSync11(path, "utf8");
+    src = readFileSync12(path, "utf8");
   } catch {
     return { item: "ci", path: rel, status: "error", detail: "exists but cannot be read \u2014 refusing to overwrite" };
   }
@@ -5617,15 +7184,15 @@ 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 rmSync3, 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 readFileSync15, 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";
+import { dirname as dirname5, join as join14, resolve as resolve3 } from "node:path";
 
 // src/git/trusted.ts
 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 isAbsolute6, join as join11 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync13 } from "node:fs";
+import { isAbsolute as isAbsolute6, join as join12 } from "node:path";
 function trustedGitEnv() {
   return { ...process.env, GIT_NO_REPLACE_OBJECTS: "1" };
 }
@@ -5638,7 +7205,7 @@ function gitDirOf(cwd) {
       env: trustedGitEnv()
     }).trim();
     if (!d) return null;
-    return isAbsolute6(d) ? d : join11(cwd, d);
+    return isAbsolute6(d) ? d : join12(cwd, d);
   } catch {
     return null;
   }
@@ -5663,9 +7230,9 @@ function objectRewriteState(cwd) {
       parts.push(`${rel}:<no-git-dir>`);
       continue;
     }
-    const p = join11(dir, rel);
+    const p = join12(dir, rel);
     try {
-      parts.push(`${rel}:` + (existsSync9(p) ? readFileSync12(p, "utf8").trim() : ""));
+      parts.push(`${rel}:` + (existsSync9(p) ? readFileSync13(p, "utf8").trim() : ""));
     } catch {
       parts.push(`${rel}:<unreadable>`);
     }
@@ -5676,8 +7243,8 @@ function objectRewriteState(cwd) {
 // src/fingerprint.ts
 import { execFileSync as execFileSync7 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
-import { readdirSync as readdirSync3, readFileSync as readFileSync13, readlinkSync, statSync as statSync6 } from "node:fs";
-import { join as join12 } from "node:path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync14, readlinkSync, statSync as statSync6 } from "node:fs";
+import { join as join13 } from "node:path";
 function treeFingerprint(cwd) {
   const files = execFileSync7("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd,
@@ -5690,7 +7257,7 @@ function treeFingerprint(cwd) {
     h.update(rel);
     h.update("\0");
     try {
-      h.update(readFileSync13(join12(cwd, rel)));
+      h.update(readFileSync14(join13(cwd, rel)));
     } catch {
       h.update("<unreadable>");
     }
@@ -5699,9 +7266,9 @@ function treeFingerprint(cwd) {
   return h.digest("hex");
 }
 function depsFingerprint(cwd) {
-  const root = join12(cwd, "node_modules");
+  const root = join13(cwd, "node_modules");
   const h = createHash7("sha256");
-  const walk = (dir) => {
+  const walk2 = (dir) => {
     let entries;
     try {
       entries = readdirSync3(dir, { withFileTypes: true });
@@ -5709,12 +7276,12 @@ function depsFingerprint(cwd) {
       return;
     }
     for (const e of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-      const p = join12(dir, e.name);
-      if (e.isDirectory()) walk(p);
+      const p = join13(dir, e.name);
+      if (e.isDirectory()) walk2(p);
       else if (e.isFile()) {
         h.update(p);
         try {
-          h.update(readFileSync13(p));
+          h.update(readFileSync14(p));
           h.update(String(statSync6(p).mode));
         } catch {
           h.update("<unreadable>");
@@ -5734,7 +7301,7 @@ function depsFingerprint(cwd) {
   } catch {
     return "none";
   }
-  walk(root);
+  walk2(root);
   return h.digest("hex");
 }
 
@@ -5829,7 +7396,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 = join13(cwd, rel);
+    const src = join14(cwd, rel);
     let st;
     try {
       st = statSync7(src);
@@ -5837,18 +7404,18 @@ function materialize(cwd, dest) {
       continue;
     }
     if (!st.isFile()) continue;
-    const out2 = join13(dest, rel);
-    mkdirSync6(dirname4(out2), { recursive: true });
+    const out2 = join14(dest, rel);
+    mkdirSync6(dirname5(out2), { recursive: true });
     dropSymlink(out2);
     if (lstatSync(src).isSymbolicLink()) {
-      writeFileSync6(out2, readFileSync14(src));
+      writeFileSync6(out2, readFileSync15(src));
     } else {
       cpSync(src, out2, { dereference: true });
     }
     chmodSync2(out2, st.mode);
   }
   const nm = resolve3(cwd, "node_modules");
-  if (existsSync10(nm)) symlinkSync(nm, join13(dest, "node_modules"), "dir");
+  if (existsSync10(nm)) symlinkSync(nm, join14(dest, "node_modules"), "dir");
 }
 function dropSymlink(p) {
   try {
@@ -5863,9 +7430,9 @@ function verifierInputs(cmd, atBase, policy) {
     const tok = raw.replace(/^['"]|['"]$/g, "").replace(/^\.\//, "");
     if (tok && baseFiles.has(tok)) picked.add(tok);
   }
-  const globs3 = policy.verify?.inputs;
-  if (globs3 && globs3.length) {
-    for (const rel of atBase) if (matchesAny(rel, globs3)) picked.add(rel);
+  const globs4 = policy.verify?.inputs;
+  if (globs4 && globs4.length) {
+    for (const rel of atBase) if (matchesAny(rel, globs4)) picked.add(rel);
   }
   return picked;
 }
@@ -5881,11 +7448,11 @@ function overlayDigest(dest, paths) {
   for (const rel of [...paths].sort()) {
     h.update(rel);
     h.update("\0");
-    const p = join13(dest, rel);
+    const p = join14(dest, rel);
     try {
       const st = lstatSync(p);
       h.update(String(st.mode));
-      h.update(st.isSymbolicLink() ? readlinkSync2(p) : readFileSync14(p));
+      h.update(st.isSymbolicLink() ? readlinkSync2(p) : readFileSync15(p));
     } catch {
       h.update("<gone>");
     }
@@ -5908,8 +7475,8 @@ 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 = execFileSync8("git", ["show", `${base}:${e.path}`], { cwd, maxBuffer: 1 << 28, env: trustedGitEnv() });
-    const out2 = join13(dest, e.path);
-    mkdirSync6(dirname4(out2), { recursive: true });
+    const out2 = join14(dest, e.path);
+    mkdirSync6(dirname5(out2), { recursive: true });
     rmSync3(out2, { force: true });
     if (e.mode === "120000") {
       symlinkSync(content.toString("utf8"), out2);
@@ -5923,7 +7490,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;
-    rmSync3(join13(dest, rel), { force: true });
+    rmSync3(join14(dest, rel), { force: true });
     removed++;
   }
   return { restored, removed };
@@ -5965,8 +7532,8 @@ function suiteEnv(scratch) {
     if (DROPPED_ENV.has(k) || PINNED_NPM.test(k)) continue;
     env[k] = v;
   }
-  const userRc = join13(scratch, "npmrc-user");
-  const globalRc = join13(scratch, "npmrc-global");
+  const userRc = join14(scratch, "npmrc-user");
+  const globalRc = join14(scratch, "npmrc-global");
   for (const f of [userRc, globalRc]) writeFileSync6(f, "", { mode: 292 });
   env.npm_config_userconfig = userRc;
   env.npm_config_globalconfig = globalRc;
@@ -5976,8 +7543,8 @@ function suiteEnv(scratch) {
 }
 function runSuite(dir, cmd, budgetSecs) {
   const t0 = Date.now();
-  const outDir = mkdtempSync2(join13(tmpdir2(), "tw-verify-run-"));
-  const outFile = join13(outDir, "result.json");
+  const outDir = mkdtempSync2(join14(tmpdir2(), "tw-verify-run-"));
+  const outFile = join14(outDir, "result.json");
   try {
     spawnSync(process.execPath, ["-e", SUPERVISOR, cmd, String(budgetSecs * 1e3), outFile], {
       cwd: dir,
@@ -5990,7 +7557,7 @@ function runSuite(dir, cmd, budgetSecs) {
     const secs = Math.round((Date.now() - t0) / 1e3);
     let r;
     try {
-      r = JSON.parse(readFileSync14(outFile, "utf8"));
+      r = JSON.parse(readFileSync15(outFile, "utf8"));
     } catch {
       return { exit: null, secs };
     }
@@ -6041,8 +7608,8 @@ function runVerify(opts) {
     out2(`verify: cannot resolve base rev "${opts.base ?? "HEAD"}" \u2014 failing closed`);
     return 2;
   }
-  const visRoot = mkdtempSync2(join13(tmpdir2(), "tw-verify-vis-"));
-  const visDir = join13(visRoot, "t");
+  const visRoot = mkdtempSync2(join14(tmpdir2(), "tw-verify-vis-"));
+  const visDir = join14(visRoot, "t");
   const cleanup = (dirs) => {
     if (opts.keep) return;
     for (const d of dirs) rmSync3(d, { recursive: true, force: true });
@@ -6070,8 +7637,8 @@ function runVerify(opts) {
     out2("pristine run executes through it too. Failing closed, not open.");
     return 2;
   }
-  const priRoot = mkdtempSync2(join13(tmpdir2(), "tw-verify-pri-"));
-  const priDir = join13(priRoot, "t");
+  const priRoot = mkdtempSync2(join14(tmpdir2(), "tw-verify-pri-"));
+  const priDir = join14(priRoot, "t");
   let restored = [];
   let removedAdded = 0;
   try {
@@ -6183,7 +7750,7 @@ function parseVerify(args) {
 
 // src/cli/run.ts
 import { execFileSync as execFileSync9, spawnSync as spawnSync2 } from "node:child_process";
-import { readdirSync as readdirSync4, readFileSync as readFileSync15, realpathSync } from "node:fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync16, realpathSync } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 var out = (s) => process.stdout.write(s + "\n");
 var err = (s) => process.stderr.write(s + "\n");
@@ -6192,7 +7759,7 @@ function git3(args, cwd) {
 }
 function nowTicks() {
   try {
-    return Math.floor(parseFloat(readFileSync15("/proc/uptime", "utf8").split(" ")[0]) * 100);
+    return Math.floor(parseFloat(readFileSync16("/proc/uptime", "utf8").split(" ")[0]) * 100);
   } catch {
     return Number.POSITIVE_INFINITY;
   }
@@ -6222,7 +7789,7 @@ function survivorsHoldingTree(cwd, spawnedAfterTicks) {
     }
     if (held !== real && !held.startsWith(real + "/")) continue;
     try {
-      const stat = readFileSync15(`/proc/${pid}/stat`, "utf8");
+      const stat = readFileSync16(`/proc/${pid}/stat`, "utf8");
       const startTicks = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]);
       if (Number.isFinite(startTicks) && startTicks >= spawnedAfterTicks) out2.push(n);
     } catch {