tamperward 2.5.0 → 2.6.0

package/dist/cli/index.js

@@ -330,26 +330,52 @@ function diffWorktree(opts = {}) {
     (c) => enrich(c, (p) => blobAt("HEAD", p, opts.cwd), (p) => fromDisk(p, opts.cwd))
   );
 }
+function addOf(rel, cwd) {
+  const after = fromDisk(rel, cwd);
+  return {
+    kind: "file",
+    path: rel,
+    oldPath: null,
+    op: "add",
+    before: null,
+    after,
+    binary: false,
+    hunks: after == null ? [] : addHunks(after)
+  };
+}
 function untrackedAdds(opts = {}, keep, exclude) {
   const others = git(["ls-files", "--others", "--exclude-standard", "-z"], opts.cwd).split("\0").filter(Boolean);
-  return others.filter((rel) => !exclude?.has(rel) && (!keep || keep(rel))).map((rel) => {
-    const after = fromDisk(rel, opts.cwd);
-    return {
-      kind: "file",
-      path: rel,
-      oldPath: null,
-      op: "add",
-      before: null,
-      after,
-      binary: false,
-      hunks: after == null ? [] : addHunks(after)
-    };
-  });
+  return others.filter((rel) => !exclude?.has(rel) && (!keep || keep(rel))).map((rel) => addOf(rel, opts.cwd));
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".hg", ".svn"]);
+var IGNORED_LS = ["ls-files", "--others", "--ignored", "--exclude-standard", "-z"];
+function underSkippedDir(rel) {
+  return rel.split("/").some((seg) => SKIP_DIRS.has(seg));
+}
+function ignoredPaths(opts = {}, keep) {
+  const files = [];
+  const dirs = [];
+  for (const entry of git([...IGNORED_LS, "--directory"], opts.cwd).split("\0").filter(Boolean)) {
+    if (underSkippedDir(entry)) continue;
+    if (entry.endsWith("/")) dirs.push(entry);
+    else files.push(entry);
+  }
+  if (dirs.length > 0) {
+    const expanded = git([...IGNORED_LS, "--", ...dirs.map((d) => `:(literal)${d}`)], opts.cwd).split("\0").filter(Boolean);
+    for (const rel of expanded) if (!underSkippedDir(rel)) files.push(rel);
+  }
+  return files.filter(keep);
 }
-function diffWorktreeWithUntracked(opts = {}) {
+function ignoredAdds(opts = {}, keep, exclude) {
+  return ignoredPaths(opts, keep).filter((rel) => !exclude?.has(rel)).map((rel) => addOf(rel, opts.cwd));
+}
+function diffWorktreeWithUntracked(opts = {}, keepIgnored) {
   const tracked = diffWorktree(opts);
   const seen = new Set(tracked.filter((c) => c.kind === "file").map((c) => c.path));
-  return [...tracked, ...untrackedAdds(opts, void 0, seen)];
+  const untracked = untrackedAdds(opts, void 0, seen);
+  for (const c of untracked) if (c.kind === "file") seen.add(c.path);
+  const ignored = keepIgnored ? ignoredAdds(opts, keepIgnored, seen) : [];
+  return [...tracked, ...untracked, ...ignored];
 }
 function hiddenTrackedPaths(opts = {}) {
   const out2 = [];
@@ -560,12 +586,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;
 }
@@ -581,9 +607,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;
 }
@@ -628,6 +654,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.*",
@@ -1115,6 +1148,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);
@@ -1173,6 +1225,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;
@@ -1250,18 +1309,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;
@@ -1274,6 +1335,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;
@@ -1299,10 +1397,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;
@@ -1329,16 +1427,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);
@@ -1347,75 +1474,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 off = (s) => new Set(s.split("\n").map((l) => l.match(/^\s*(project|patch):\s*off\b/)?.[1]).filter((x) => !!x));
+    const had = off(before);
+    for (const s of off(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/,
@@ -1454,6 +1659,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"],
@@ -1466,10 +1700,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, {
@@ -1483,7 +1722,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,
@@ -1580,8 +1819,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" };
@@ -1593,15 +1857,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;
@@ -1632,13 +1914,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;
@@ -1648,15 +1930,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);
@@ -1667,8 +1950,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;
   };
@@ -1676,8 +1960,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;
   };
@@ -1688,14 +1973,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;
       }
     }
   };
@@ -1720,6 +2009,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;
@@ -1736,7 +2038,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();
@@ -1744,7 +2046,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):/;
@@ -1758,7 +2060,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++) {
@@ -1776,13 +2092,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;
@@ -1818,8 +2149,9 @@ 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 ?? []);
@@ -1829,36 +2161,80 @@ function parseTriggers(src) {
 }
 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) {
     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}`);
   }
+  for (const [e, list] 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(list, opts.sources)) out2.push(`on.${e}.paths matches no source file (now [${list.join(", ")}]) \u2014 the workflow never runs on code`);
+  }
+  for (const [e, list] 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 (!list.some((t) => PR_CODE_TYPES.test(t))) out2.push(`on.${e}.types no longer includes opened/synchronize (now [${list.join(", ")}]) \u2014 the workflow does not run on the pull request's code`);
+  }
   for (const [e, list] 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 (list.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)) {
@@ -1881,6 +2257,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, {
@@ -1938,25 +2318,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(
@@ -1964,7 +2354,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;
@@ -1985,11 +2375,11 @@ var ciTampering = {
 
 // src/detectors/hook-tampering.ts
 import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { isAbsolute, join as join2, relative } from "node:path";
 
 // src/detectors/policy-diff.ts
 import { parse } from "yaml";
-var globs = (list) => Array.isArray(list) ? list.filter((g) => typeof g === "string").map(normalizeGlob) : [];
+var globs2 = (list) => Array.isArray(list) ? list.filter((g) => typeof g === "string").map(normalizeGlob) : [];
 function safeParse(src) {
   try {
     const v = parse(src);
@@ -2006,13 +2396,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, list]) => [cat, globs2(list)])) : 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
@@ -2495,9 +2885,22 @@ function chmodDropsExec(toks) {
   return false;
 }
 var WRAPPERS = /^(?:sudo|command|exec|time|nice|env|[A-Za-z_][A-Za-z0-9_]*=\S*)$/;
+var REDIRECT_TARGET = /(?:^|\s)\d*>{1,2}\|?\s*(\S+)/g;
+var hookPath = (t) => t.replace(/^["']|["']$/g, "").replace(/^\.\//, "");
+function shellHookTarget(seg, toks, policy) {
+  for (const m of seg.matchAll(REDIRECT_TARGET)) {
+    const t = hookPath(m[1]);
+    if (isProtected(t, policy, "hooks")) return t;
+  }
+  for (const tok of toks) {
+    const t = hookPath(tok.replace(/^of=/, ""));
+    if (isProtected(t, policy, "hooks")) return t;
+  }
+  return null;
+}
 function shellWritesHook(seg, toks, policy) {
   const hook = (t) => isProtected(t.replace(/^\.\//, ""), policy, "hooks");
-  for (const m of seg.matchAll(/(?:^|\s)\d*>{1,2}\|?\s*(\S+)/g)) {
+  for (const m of seg.matchAll(REDIRECT_TARGET)) {
     if (hook(m[1].replace(/^["']|["']$/g, ""))) return "a redirect empties or rewrites a protected hook";
   }
   let at = 0;
@@ -2631,11 +3034,11 @@ function settingsWeakening(before, after, sibling) {
     }
     if (now !== "none" || !declares(after, event)) continue;
     if (before !== null && declares(before, event)) continue;
-    const empty = (eventEntries(after, event) ?? []).length === 0;
+    const empty2 = (eventEntries(after, event) ?? []).length === 0;
     const shadowed = sibling !== null && gateWiring(sibling, event).length > 0;
-    if (empty || shadowed) {
+    if (empty2 || 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" : "")
+        `${event} hooks declared ${empty2 ? "empty" : "without the tamperward entry"} in an override file` + (shadowed ? " \u2014 this shadows the gate the sibling settings file wires" : "")
       );
     }
   }
@@ -2708,14 +3111,24 @@ function configFindings(c, policy) {
 function updateIndexHiding(toks, policy) {
   if (!toks.some((t) => t === "git" || t.endsWith("/git")) || !toks.includes("update-index")) return null;
   const hide = toks.find((t) => /^--(?:skip-worktree|assume-unchanged)$/.test(t));
-  if (hide && toks.some((t) => isProtected(t, policy))) {
-    return `git update-index ${hide} hides a protected file from every git diff \u2014 edits to it no longer reach the sweep or the pre-commit gate`;
+  const hidden = hide ? toks.find((t) => isProtected(t, policy)) : void 0;
+  if (hide && hidden) {
+    return {
+      reason: `git update-index ${hide} hides a protected file from every git diff \u2014 edits to it no longer reach the sweep or the pre-commit gate`,
+      file: hidden
+    };
   }
-  if (toks.some((t) => /^--chmod=-x$/.test(t)) && toks.some((t) => isProtected(t, policy, "hooks"))) {
-    return "git update-index --chmod=-x clears the execute bit on a protected hook through the index, which disables it";
+  const hook = toks.some((t) => /^--chmod=-x$/.test(t)) ? toks.find((t) => isProtected(t, policy, "hooks")) : void 0;
+  if (hook) {
+    return { reason: "git update-index --chmod=-x clears the execute bit on a protected hook through the index, which disables it", file: hook };
   }
   return null;
 }
+function repoRelative(path, ctx) {
+  if (!ctx?.cwd || !isAbsolute(path)) return path;
+  const rel = relative(ctx.cwd, path);
+  return rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : path;
+}
 var hookTampering = {
   id: RULE6,
   surface: ["file", "command"],
@@ -2865,7 +3278,8 @@ var hookTampering = {
           if (hiding) {
             out2.push(
               makeFinding(RULE6, policy, {
-                message: `Hook tampering via shell: ${hiding}.`,
+                file: repoRelative(hiding.file, ctx),
+                message: `Hook tampering via shell: ${hiding.reason}.`,
                 evidence: seg,
                 remediation: "Leave protected files visible to git. Hiding one from the diff hides it from the gate, which is the tamper \u2014 use `--no-skip-worktree` / `--no-assume-unchanged` to undo it."
               })
@@ -2874,8 +3288,10 @@ var hookTampering = {
           }
           const why = shellWritesHook(seg, toks, policy);
           if (why) {
+            const target = shellHookTarget(seg, toks, policy);
             out2.push(
               makeFinding(RULE6, policy, {
+                ...target ? { file: repoRelative(target, ctx) } : {},
                 message: `Hook tampering via shell: ${why}.`,
                 evidence: seg,
                 remediation: "Leave the hooks in place. Mutating them from the shell is still tampering."
@@ -2919,67 +3335,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 list = [];
+    for (const el of e.elements) {
+      if (ts3.isObjectLiteralExpression(el)) list.push(collect(el, runner));
+      else sel.opaque = true;
+    }
+    sel.projects = list;
+    if (list.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 list = [];
+        for (const el of arr.elements) {
+          if (ts3.isObjectLiteralExpression(el)) list.push(collect(el, runner));
+          else sel.opaque = true;
         }
-      }
-      ts3.forEachChild(node, visit);
-    };
-    visit(sf);
+        sel.projects = list;
+        sel.present = true;
+        if (list.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 });
@@ -2989,6 +3485,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 {
@@ -2999,29 +3500,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);
@@ -3053,6 +3569,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 };
@@ -3067,7 +3595,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];
@@ -3078,23 +3606,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") {
@@ -3109,7 +3647,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;
@@ -3117,6 +3655,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("/")) {
@@ -3148,11 +3714,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) => {
@@ -3199,7 +3765,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, {
@@ -3210,6 +3776,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 = "";
@@ -3223,15 +3799,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] ?? "";
@@ -3242,8 +3828,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";
@@ -3298,7 +3887,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 {
@@ -3312,10 +3901,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;
       }
@@ -3370,12 +3958,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."
           })
@@ -3572,7 +4161,7 @@ function hasBlocking(findings) {
 
 // src/policy-load.ts
 import { readFileSync as readFileSync3, existsSync as existsSync2 } from "node:fs";
-import { isAbsolute, join as join3, posix } from "node:path";
+import { isAbsolute as isAbsolute2, join as join3, posix } from "node:path";
 import { parse as parse2 } from "yaml";
 var PolicyError = class extends Error {
 };
@@ -3589,7 +4178,7 @@ var isStringList = (v) => Array.isArray(v) && v.every((s) => typeof s === "strin
 var isMapping = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["version", "protected", "rules", "ignore", "signoff", "verify"]);
 function ledgerInsideRepo(ledger) {
-  if (!ledger.trim() || isAbsolute(ledger) || /^[A-Za-z]:[\\/]/.test(ledger)) return false;
+  if (!ledger.trim() || isAbsolute2(ledger) || /^[A-Za-z]:[\\/]/.test(ledger)) return false;
   const norm2 = posix.normalize(ledger.replace(/\\/g, "/"));
   return norm2 !== ".." && !norm2.startsWith("../") && !norm2.startsWith("/");
 }
@@ -3620,8 +4209,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) {
@@ -3653,10 +4242,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 = (list) => list?.map(normalizeGlob);
+  const userProtected = r.protected ? Object.fromEntries(Object.entries(r.protected).map(([cat, list]) => [cat, globs4(list) ?? []])) : 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,
@@ -3666,7 +4255,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
@@ -4043,7 +4632,8 @@ function check(opts) {
     layer = "local";
     view = "staged";
   } else if (opts.worktree) {
-    changes = opts.includeUntracked ? diffWorktreeWithUntracked({ cwd: opts.cwd }) : diffWorktree({ cwd: opts.cwd });
+    const p = policy;
+    changes = opts.includeUntracked ? diffWorktreeWithUntracked({ cwd: opts.cwd }, (rel) => isProtected(rel, p)) : diffWorktree({ cwd: opts.cwd });
     layer = opts.ciLayer ? "ci" : "local";
     view = "worktree";
   } else if (opts.diff) {
@@ -4102,7 +4692,7 @@ import { join as join9 } from "node:path";
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { readFileSync as readFileSync5, existsSync as existsSync4, writeFileSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { isAbsolute as isAbsolute2, join as join5, relative, resolve } from "node:path";
+import { isAbsolute as isAbsolute3, join as join5, relative as relative2, resolve } from "node:path";
 function asStr(v) {
   return typeof v === "string" ? v : "";
 }
@@ -4117,8 +4707,8 @@ function abs(path, cwd) {
   return resolve(cwd, path);
 }
 function relForDisplay(path, cwd) {
-  const rel = relative(cwd, path);
-  return rel && !rel.startsWith("..") && !isAbsolute2(rel) ? rel : path;
+  const rel = relative2(cwd, path);
+  return rel && !rel.startsWith("..") && !isAbsolute3(rel) ? rel : path;
 }
 function applyEdit(content, oldStr, newStr) {
   if (content === null) return newStr;
@@ -4261,11 +4851,11 @@ function advanceTurnBaseline(cwd, sessionId) {
 
 // src/effect.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync7, statSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { isAbsolute as isAbsolute3, join as join7 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync7, renameSync, rmSync as rmSync2, statSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { isAbsolute as isAbsolute4, join as join7 } from "node:path";
 import { execFileSync as execFileSync4 } from "node:child_process";
 var UNSAFE2 = /[^A-Za-z0-9._-]/g;
-var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".hg", ".svn"]);
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([".git", "node_modules", ".hg", ".svn"]);
 function gitDir2(cwd) {
   try {
     const d = execFileSync4("git", ["rev-parse", "--git-dir"], {
@@ -4274,7 +4864,7 @@ function gitDir2(cwd) {
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
     if (!d) return null;
-    return isAbsolute3(d) ? d : join7(cwd, d);
+    return isAbsolute4(d) ? d : join7(cwd, d);
   } catch {
     return null;
   }
@@ -4307,7 +4897,7 @@ function snapshotProtected(cwd, policy, prev) {
       return;
     }
     for (const name of names) {
-      if (SKIP_DIRS.has(name)) continue;
+      if (SKIP_DIRS2.has(name)) continue;
       const r = rel ? `${rel}/${name}` : name;
       let st;
       try {
@@ -4333,12 +4923,16 @@ function snapshotProtected(cwd, policy, prev) {
 function driftBetween(expected, current) {
   const changed = [];
   const deleted = [];
+  const added = [];
   for (const [path, e] of Object.entries(expected)) {
     const c = current[path];
     if (!c) deleted.push(path);
     else if (c.hash !== e.hash || c.mode !== e.mode) changed.push(path);
   }
-  return { changed, deleted };
+  for (const path of Object.keys(current)) {
+    if (!expected[path]) added.push(path);
+  }
+  return { changed, deleted, added };
 }
 function loadTree(p) {
   if (!p || !existsSync6(p)) return null;
@@ -4352,7 +4946,16 @@ function saveTree(p, tree) {
   if (!p) return;
   try {
     mkdirSync3(join7(p, ".."), { recursive: true });
-    writeFileSync3(p, JSON.stringify(tree));
+    const tmp = `${p}.${process.pid}.tmp`;
+    writeFileSync3(tmp, JSON.stringify(tree));
+    renameSync(tmp, p);
+  } catch {
+  }
+}
+function dropTree(p) {
+  if (!p) return;
+  try {
+    rmSync2(p, { force: true });
   } catch {
   }
 }
@@ -4368,6 +4971,9 @@ function loadTurnTree(cwd, sessionId) {
 function saveTurnTree(cwd, sessionId, tree) {
   saveTree(turnTreePath(cwd, sessionId), tree);
 }
+function dropTurnTree(cwd, sessionId) {
+  dropTree(turnTreePath(cwd, sessionId));
+}
 
 // src/cli/watch.ts
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync8, statSync as statSync2, watch } from "node:fs";
@@ -4612,17 +5218,26 @@ function turnView(cwd, sessionId, policy, base) {
     if (c.oldPath) seen.add(c.oldPath);
   }
   const turnTree = loadTurnTree(cwd, sessionId);
-  const untracked = untrackedAdds({ cwd }, (rel) => isProtected(rel, policy), seen).filter(
-    (c) => c.kind !== "file" || !turnTree || turnTree[c.path]?.hash !== hashOnDisk(cwd, c.path)
-  );
+  const ptree = loadPtree(cwd, sessionId);
+  const keep = (rel) => isProtected(rel, policy);
+  const untouched = (rel, disk) => disk != null && turnTree?.[rel]?.hash === disk && ptree?.[rel]?.hash === disk;
+  const untracked = untrackedAdds({ cwd }, keep, seen).filter((c) => c.kind !== "file" || !untouched(c.path, hashOnDisk(cwd, c.path)));
   for (const c of fileChanges(untracked)) seen.add(c.path);
+  const ignored = ignoredAdds({ cwd }, keep, seen).filter((c) => {
+    if (c.kind !== "file") return false;
+    const disk = hashOnDisk(cwd, c.path);
+    if (untouched(c.path, disk)) return false;
+    const sanctioned = ptree?.[c.path];
+    return !(sanctioned && disk != null && sanctioned.hash !== disk);
+  });
+  for (const c of fileChanges(ignored)) seen.add(c.path);
   const trusted = base ?? "HEAD";
   const hidden = [];
   for (const rel of hiddenTrackedPaths({ cwd })) {
     if (seen.has(rel) || !isProtected(rel, policy)) continue;
     hidden.push(...synthFileChange(rel, fileAt(trusted, rel, { cwd }), fileOnDisk(rel, { cwd })));
   }
-  return [...tracked, ...untracked, ...hidden];
+  return [...tracked, ...untracked, ...ignored, ...hidden];
 }
 function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree) {
   const d = driftBetween(expected, current);
@@ -4640,7 +5255,7 @@ function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree)
     const after = fileOnDisk(rel, { cwd });
     const trustedBlob = fileAt(trusted, rel, { cwd });
     const atGitState = after != null && trustedBlob != null && contentHash(after) === contentHash(trustedBlob);
-    const atTurnStart = current[rel] != null && turnTree?.[rel]?.hash === current[rel].hash;
+    const atTurnStart = current[rel] != null && expected[rel]?.mtimeMs === -1 && turnTree?.[rel]?.hash === current[rel].hash;
     if ((atGitState || atTurnStart) && current[rel] && expected[rel] && current[rel].mode === expected[rel].mode) {
       continue;
     }
@@ -4683,6 +5298,23 @@ function uncoveredDrift(cwd, policy, expected, current, covered, base, turnTree)
       });
     }
   }
+  for (const rel of d.added) {
+    if (seen.has(rel)) continue;
+    const after = fileOnDisk(rel, { cwd });
+    if (after == null) {
+      blocks.push({
+        rule: "hidden-drift",
+        severity: "block",
+        file: rel,
+        message: `Protected file ${rel} appeared outside git's view and cannot be read to judge it.`,
+        evidence: rel,
+        remediation: "Remove the file, or make it readable and bring it into git's view; create protected files through a tool call the gate can see.",
+        signoff: { required: true, command: `tamperward allow hidden-drift --file ${rel} --reason "..."` }
+      });
+      continue;
+    }
+    changes.push(...synthFileChange(rel, null, after));
+  }
   return { changes, blocks };
 }
 function effectDriftBlocks(cwd, sessionId, policy) {
@@ -4691,17 +5323,18 @@ function effectDriftBlocks(cwd, sessionId, policy) {
   const current = snapshotProtected(cwd, policy, expected ?? void 0);
   if (!expected) {
     savePtree(cwd, sessionId, current);
-    if (!loadTurnTree(cwd, sessionId)) saveTurnTree(cwd, sessionId, current);
+    if (loadTurnTree(cwd, sessionId)) dropTurnTree(cwd, sessionId);
+    else saveTurnTree(cwd, sessionId, current);
     return null;
   }
   const d = driftBetween(expected, current);
-  if (d.changed.length === 0 && d.deleted.length === 0) {
+  if (d.changed.length === 0 && d.deleted.length === 0 && d.added.length === 0) {
     savePtree(cwd, sessionId, current);
     return null;
   }
   const base = turnBaseline(cwd, sessionId);
   const all = turnView(cwd, sessionId, policy, base);
-  const drifted = /* @__PURE__ */ new Set([...d.changed, ...d.deleted]);
+  const drifted = /* @__PURE__ */ new Set([...d.changed, ...d.deleted, ...d.added]);
   const scoped = all.filter(
     (c) => c.kind === "file" && (drifted.has(c.path) || c.oldPath != null && drifted.has(c.oldPath))
   );
@@ -4916,7 +5549,7 @@ Honored at LOCAL pre-commit only. The agent-layer hook ignores this file; CI req
 import { execFileSync as execFileSync5 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5, chmodSync, statSync as statSync5 } from "node:fs";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute4, join as join10, relative as relative2, resolve as resolve2 } from "node:path";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute5, join as join10, relative as relative3, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var errText2 = (e) => (e instanceof Error ? e.message : String(e)).replace(/\s+/g, " ").trim();
 var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -5234,8 +5867,8 @@ function hooksDir(cwd) {
   return existsSync8(join10(cwd, ".git")) ? join10(cwd, ".git", "hooks") : null;
 }
 function display(cwd, path) {
-  const rel = relative2(cwd, path);
-  return rel && !rel.startsWith("..") && !isAbsolute4(rel) ? rel : path;
+  const rel = relative3(cwd, path);
+  return rel && !rel.startsWith("..") && !isAbsolute5(rel) ? rel : path;
 }
 function unconditionalExitAt(lines) {
   let depth = 0;
@@ -5521,7 +6154,7 @@ tamperward init: ${changed} change(s) applied. Commit them so the gate travels w
 // src/cli/verify.ts
 import { execFileSync as execFileSync8, spawnSync } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
-import { chmodSync as chmodSync2, cpSync, lstatSync, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync2, readFileSync as readFileSync14, readlinkSync as readlinkSync2, rmSync as rmSync2, statSync as statSync7, symlinkSync, writeFileSync as writeFileSync6, existsSync as existsSync10 } from "node:fs";
+import { chmodSync as chmodSync2, cpSync, lstatSync, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync2, readFileSync as readFileSync14, readlinkSync as readlinkSync2, rmSync as rmSync3, statSync as statSync7, symlinkSync, writeFileSync as writeFileSync6, existsSync as existsSync10 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { dirname as dirname4, join as join13, resolve as resolve3 } from "node:path";
 
@@ -5529,7 +6162,7 @@ import { dirname as dirname4, join as join13, resolve as resolve3 } from "node:p
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync9, readFileSync as readFileSync12 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join11 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join11 } from "node:path";
 function trustedGitEnv() {
   return { ...process.env, GIT_NO_REPLACE_OBJECTS: "1" };
 }
@@ -5542,7 +6175,7 @@ function gitDirOf(cwd) {
       env: trustedGitEnv()
     }).trim();
     if (!d) return null;
-    return isAbsolute5(d) ? d : join11(cwd, d);
+    return isAbsolute6(d) ? d : join11(cwd, d);
   } catch {
     return null;
   }
@@ -5756,7 +6389,7 @@ function materialize(cwd, dest) {
 }
 function dropSymlink(p) {
   try {
-    if (lstatSync(p).isSymbolicLink()) rmSync2(p, { force: true });
+    if (lstatSync(p).isSymbolicLink()) rmSync3(p, { force: true });
   } catch {
   }
 }
@@ -5767,9 +6400,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;
 }
@@ -5814,7 +6447,7 @@ function overlayPristine(cwd, base, dest, policy, cmd) {
     const content = execFileSync8("git", ["show", `${base}:${e.path}`], { cwd, maxBuffer: 1 << 28, env: trustedGitEnv() });
     const out2 = join13(dest, e.path);
     mkdirSync6(dirname4(out2), { recursive: true });
-    rmSync2(out2, { force: true });
+    rmSync3(out2, { force: true });
     if (e.mode === "120000") {
       symlinkSync(content.toString("utf8"), out2);
     } else {
@@ -5827,7 +6460,7 @@ function overlayPristine(cwd, base, dest, policy, cmd) {
   const inCopy = git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
   for (const rel of inCopy) {
     if (!isOverlay(rel) || baseProtected.has(rel)) continue;
-    rmSync2(join13(dest, rel), { force: true });
+    rmSync3(join13(dest, rel), { force: true });
     removed++;
   }
   return { restored, removed };
@@ -5902,7 +6535,7 @@ function runSuite(dir, cmd, budgetSecs) {
     if (r.exit === null || r.exit === void 0) return { exit: null, secs };
     return { exit: r.exit, secs };
   } finally {
-    rmSync2(outDir, { recursive: true, force: true });
+    rmSync3(outDir, { recursive: true, force: true });
   }
 }
 function runVerify(opts) {
@@ -5949,7 +6582,7 @@ function runVerify(opts) {
   const visDir = join13(visRoot, "t");
   const cleanup = (dirs) => {
     if (opts.keep) return;
-    for (const d of dirs) rmSync2(d, { recursive: true, force: true });
+    for (const d of dirs) rmSync3(d, { recursive: true, force: true });
   };
   const treeBefore = treeFingerprint(cwd);
   const depsBefore = depsFingerprint(cwd);