tamperward 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,1833 @@
+#!/usr/bin/env node
+
+// src/git/build.ts
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/diff/parse.ts
+var HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+var C_ESCAPES = { a: 7, b: 8, f: 12, n: 10, r: 13, t: 9, v: 11, "\\": 92, '"': 34 };
+function unquotePath(p) {
+  if (p.length < 2 || !p.startsWith('"') || !p.endsWith('"')) return p;
+  const body = p.slice(1, -1);
+  const bytes = [];
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] !== "\\") {
+      for (const b of Buffer.from(body[i], "utf8")) bytes.push(b);
+      continue;
+    }
+    const oct = body.slice(i + 1, i + 4);
+    if (/^[0-7]{3}$/.test(oct)) {
+      bytes.push(parseInt(oct, 8));
+      i += 3;
+      continue;
+    }
+    const esc = C_ESCAPES[body[i + 1]];
+    if (esc !== void 0) {
+      bytes.push(esc);
+      i += 1;
+      continue;
+    }
+    bytes.push(92);
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+function endOfQuoted(s) {
+  for (let i = 1; i < s.length; i++) {
+    if (s[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (s[i] === '"') return i;
+  }
+  return -1;
+}
+function headerPaths(line) {
+  let rest = line.slice("diff --git ".length);
+  let first = null;
+  if (rest.startsWith('"')) {
+    const end = endOfQuoted(rest);
+    if (end > 0) {
+      first = rest.slice(0, end + 1);
+      rest = rest.slice(end + 1).trimStart();
+    }
+  }
+  if (first === null) {
+    const q = rest.indexOf(' "b/');
+    if (q >= 0) {
+      first = rest.slice(0, q);
+      rest = rest.slice(q + 1);
+    } else {
+      const m = rest.match(/^(.*) (b\/.*)$/);
+      if (!m) return [null, null];
+      first = m[1];
+      rest = m[2];
+    }
+  }
+  return [stripAB(first), stripAB(rest)];
+}
+function stripAB(p) {
+  if (p === null) return null;
+  const u = unquotePath(p);
+  if (u === "/dev/null") return null;
+  return u.replace(/^[ab]\//, "");
+}
+function parseDiff(diff) {
+  const lines = diff.split("\n");
+  const changes = [];
+  let i = 0;
+  while (i < lines.length) {
+    if (!lines[i].startsWith("diff --git ")) {
+      i++;
+      continue;
+    }
+    const [headerOld, headerNew] = headerPaths(lines[i]);
+    i++;
+    let op = "modify";
+    let binary = false;
+    let renameFrom = null;
+    let renameTo = null;
+    let minusPath = null;
+    let plusPath = null;
+    const hunks = [];
+    while (i < lines.length && !lines[i].startsWith("diff --git ")) {
+      const l = lines[i];
+      if (l.startsWith("@@")) {
+        const parsed = parseHunk(lines, i);
+        if (parsed) {
+          hunks.push(parsed.hunk);
+          i = parsed.next;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (l.startsWith("new file mode")) op = "add";
+      else if (l.startsWith("deleted file mode")) op = "delete";
+      else if (l.startsWith("rename from ")) {
+        renameFrom = unquotePath(l.slice(12));
+        op = "rename";
+      } else if (l.startsWith("rename to ")) {
+        renameTo = unquotePath(l.slice(10));
+        op = "rename";
+      } else if (l.startsWith("copy from ")) {
+        renameFrom = unquotePath(l.slice(10));
+        if (op === "modify") op = "rename";
+      } else if (l.startsWith("copy to ")) {
+        renameTo = unquotePath(l.slice(8));
+        if (op === "modify") op = "rename";
+      } else if (l.startsWith("Binary files ") || l.startsWith("GIT binary patch")) binary = true;
+      else if (l.startsWith("--- ")) minusPath = l.slice(4);
+      else if (l.startsWith("+++ ")) plusPath = l.slice(4);
+      i++;
+    }
+    let path;
+    let oldPath = null;
+    if (op === "rename") {
+      oldPath = renameFrom ?? stripAB(minusPath) ?? headerOld;
+      path = renameTo ?? stripAB(plusPath) ?? headerNew ?? oldPath ?? "";
+    } else if (op === "delete") {
+      path = stripAB(minusPath) ?? headerOld ?? "";
+    } else {
+      path = stripAB(plusPath) ?? headerNew ?? headerOld ?? "";
+    }
+    const change = {
+      kind: "file",
+      path,
+      oldPath,
+      op,
+      before: null,
+      after: null,
+      binary,
+      hunks
+    };
+    changes.push(change);
+  }
+  return changes;
+}
+function parseHunk(lines, start) {
+  const m = lines[start].match(HUNK_RE);
+  if (!m) return null;
+  const oldStart = Number(m[1]);
+  const oldLines = m[2] !== void 0 ? Number(m[2]) : 1;
+  const newStart = Number(m[3]);
+  const newLines = m[4] !== void 0 ? Number(m[4]) : 1;
+  const out = [];
+  let oldLine = oldStart;
+  let newLine = newStart;
+  let i = start + 1;
+  for (; i < lines.length; i++) {
+    const l = lines[i];
+    if (l.startsWith("@@") || l.startsWith("diff --git ")) break;
+    if (l.startsWith("\\")) continue;
+    const tag = l[0];
+    const content = l.slice(1);
+    if (tag === "+") {
+      out.push({ type: "add", content, oldLine: null, newLine });
+      newLine++;
+    } else if (tag === "-") {
+      out.push({ type: "del", content, oldLine, newLine: null });
+      oldLine++;
+    } else if (tag === " ") {
+      out.push({ type: "context", content, oldLine, newLine });
+      oldLine++;
+      newLine++;
+    } else {
+      break;
+    }
+  }
+  return { hunk: { oldStart, oldLines, newStart, newLines, lines: out }, next: i };
+}
+
+// src/git/build.ts
+function git(args, cwd) {
+  return execFileSync("git", args, { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+}
+function blobAt(rev, path, cwd) {
+  try {
+    return git(["show", `${rev}:${path}`], cwd);
+  } catch {
+    return null;
+  }
+}
+function fromDisk(path, cwd) {
+  try {
+    return readFileSync(join(cwd ?? process.cwd(), path), "utf8");
+  } catch {
+    return null;
+  }
+}
+function enrich(c, beforeReader, afterReader) {
+  if (c.kind !== "file" || c.binary) return c;
+  const before = c.op !== "add" ? beforeReader(c.oldPath ?? c.path) : null;
+  const after = c.op !== "delete" ? afterReader(c.path) : null;
+  return { ...c, before, after };
+}
+function mergeBaseOf(base, head, opts = {}) {
+  try {
+    return git(["merge-base", base, head], opts.cwd).trim() || base;
+  } catch {
+    return base;
+  }
+}
+function fileAt(rev, path, opts = {}) {
+  return blobAt(rev, path, opts.cwd);
+}
+function isGitRepo(cwd) {
+  try {
+    git(["rev-parse", "--git-dir"], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function gitDir(cwd) {
+  try {
+    return git(["rev-parse", "--absolute-git-dir"], cwd).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function headSha(cwd) {
+  try {
+    return git(["rev-parse", "HEAD"], cwd).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function diffSince(rev, opts = {}) {
+  const raw = git(["diff", "--no-color", "-M", rev], opts.cwd);
+  return parseDiff(raw).map(
+    (c) => enrich(c, (p) => blobAt(rev, p, opts.cwd), (p) => fromDisk(p, opts.cwd))
+  );
+}
+function diffRange(base, head, opts = {}) {
+  const raw = git(["diff", "--no-color", "-M", `${base}...${head}`], opts.cwd);
+  const mergeBase = mergeBaseOf(base, head, opts);
+  return parseDiff(raw).map(
+    (c) => enrich(c, (p) => blobAt(mergeBase, p, opts.cwd), (p) => blobAt(head, p, opts.cwd))
+  );
+}
+function diffStaged(opts = {}) {
+  const raw = git(["diff", "--no-color", "-M", "--cached"], opts.cwd);
+  return parseDiff(raw).map(
+    (c) => enrich(c, (p) => blobAt("HEAD", p, opts.cwd), (p) => blobAt("", p, opts.cwd))
+  );
+}
+function diffWorktree(opts = {}) {
+  const raw = git(["diff", "--no-color", "-M", "HEAD"], opts.cwd);
+  return parseDiff(raw).map(
+    (c) => enrich(c, (p) => blobAt("HEAD", p, opts.cwd), (p) => fromDisk(p, opts.cwd))
+  );
+}
+
+// src/detectors/finding.ts
+function severityOf(rule, policy, fallback = "block") {
+  return policy.rules?.[rule]?.severity ?? fallback;
+}
+function isEnabled(rule, policy) {
+  const r = policy.rules?.[rule];
+  return !r || r.enabled !== false;
+}
+function makeFinding(rule, policy, input) {
+  const severity = severityOf(rule, policy, input.defaultSeverity ?? "block");
+  const required = (policy.signoff?.requiredFor ?? ["block"]).includes(severity);
+  return {
+    rule,
+    severity,
+    ...input.file !== void 0 ? { file: input.file } : {},
+    ...input.line !== void 0 ? { line: input.line } : {},
+    message: input.message,
+    evidence: input.evidence,
+    remediation: input.remediation,
+    signoff: {
+      required,
+      command: `tamperward allow ${rule}${input.file ? ` --file ${input.file}` : ""} --reason "..."`
+    }
+  };
+}
+
+// src/detectors/command.ts
+function segments(raw) {
+  return raw.split(/(?:&&|\|\||[;&|\n])+/).map((s) => s.trim()).filter(Boolean);
+}
+function tokens(seg) {
+  return seg.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [];
+}
+function unquote(t) {
+  return t.replace(/^['"]+|['"]+$/g, "");
+}
+
+// src/detectors/no-verify.ts
+var RULE = "no-verify";
+var LITERAL = [
+  { re: /(?:^|\s)--no-verify(?:\s|$)/, why: "--no-verify skips the pre-commit/pre-push hooks" },
+  { re: /(?:^|\s)--no-hooks(?:\s|$)/, why: "--no-hooks disables hook execution" },
+  { re: /(?:^|[\s;&|=])HUSKY=0(?:\s|$)/, why: "HUSKY=0 disables all Husky hooks" },
+  { re: /\bHUSKY_SKIP_HOOKS=1\b/, why: "HUSKY_SKIP_HOOKS=1 skips Husky hooks" }
+];
+var SHORT_N = /^-[a-z]*n[a-z]*$/i;
+var noVerify = {
+  id: RULE,
+  surface: ["command"],
+  certainty: "mechanical",
+  run(changes, policy) {
+    const out = [];
+    for (const c of changes) {
+      if (c.kind !== "command") continue;
+      for (const seg of segments(c.raw)) {
+        let why = null;
+        for (const p of LITERAL) {
+          if (p.re.test(seg)) {
+            why = p.why;
+            break;
+          }
+        }
+        if (!why && /\bgit\b/.test(seg) && /\bcommit\b/.test(seg)) {
+          if (tokens(seg).some((t) => SHORT_N.test(t))) {
+            why = "git commit -n skips the pre-commit hook";
+          }
+        }
+        if (why) {
+          out.push(
+            makeFinding(RULE, policy, {
+              message: `Command bypasses git hooks: ${why}.`,
+              evidence: seg,
+              remediation: "Let the hooks run and fix what they catch. Skipping verification is exactly the move this gate blocks \u2014 editing the hook and --no-hooks are blocked too."
+            })
+          );
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// src/detectors/ts-any-cast.ts
+import ts from "typescript";
+
+// src/diff/select.ts
+function addedLines(c) {
+  if (c.kind !== "file") return [];
+  return c.hunks.flatMap((h) => h.lines.filter((l) => l.type === "add"));
+}
+function removedLines(c) {
+  if (c.kind !== "file") return [];
+  return c.hunks.flatMap((h) => h.lines.filter((l) => l.type === "del"));
+}
+
+// src/policy.ts
+import picomatch from "picomatch";
+var POLICY_FILE = ".tamperward.yml";
+var cache = /* @__PURE__ */ new Map();
+function matcher(glob) {
+  let m = cache.get(glob);
+  if (!m) {
+    m = picomatch(glob, { dot: true });
+    cache.set(glob, m);
+  }
+  return m;
+}
+function matchesAny(path, globs) {
+  return !!globs && globs.some((g) => matcher(g)(path));
+}
+function protectedCategory(path, policy) {
+  for (const [cat, globs] of Object.entries(policy.protected ?? {})) {
+    if (matchesAny(path, globs)) return cat;
+  }
+  return null;
+}
+function isProtected(path, policy, category) {
+  if (category) return matchesAny(path, policy.protected?.[category]);
+  return protectedCategory(path, policy) !== null;
+}
+function isPolicyFile(path) {
+  return path === POLICY_FILE || path.endsWith("/" + POLICY_FILE);
+}
+function isIgnored(path, policy) {
+  return matchesAny(path, policy.ignore);
+}
+function mergeProtected(base, user) {
+  const out = { ...base };
+  for (const [cat, globs] of Object.entries(user ?? {})) {
+    const have = new Set(out[cat] ?? []);
+    out[cat] = [...out[cat] ?? [], ...(globs ?? []).filter((g) => !have.has(g))];
+  }
+  return out;
+}
+function defaultPolicy() {
+  return {
+    version: 1,
+    protected: {
+      // Cover every JS/TS test extension, not just .test.ts — the multi-repo FP study found
+      // .test.tsx/.spec.tsx (hono, zustand) slipped the glob, so legit test-file casts blocked
+      // instead of warning. Kept ADDITIVE (originals + new extensions) so the policy-diff sees a
+      // strengthening, not a narrowing. picomatch expands the brace.
+      tests: ["**/*.test.ts", "**/*.spec.ts", "**/*.{test,spec}.{tsx,cts,mts,js,jsx,cjs,mjs}", "**/__tests__/**"],
+      config: [
+        "**/jest.config.*",
+        "**/vitest.config.*",
+        "**/tsconfig*.json",
+        "**/.eslintrc*",
+        "**/eslint.config.*",
+        "**/package.json"
+      ],
+      ci: [".github/workflows/**"],
+      hooks: [".husky/**", "**/lefthook.*", ".tamperward.yml", "**/.tamperward.yml"]
+    },
+    rules: {
+      "test-deletion": { severity: "block" },
+      "test-skip": { severity: "block" },
+      "ts-any-cast": { severity: "block" },
+      // the unambiguous explicit casts + ts-suppression directives
+      // broad any in annotation/generic position is common in legit code (measured ~84-100% FP as a
+      // block rule on real TS), so it WARNs until a semantic (error-silencing-aware) signal earns block.
+      "ts-any-launder": { severity: "warn" },
+      "lint-suppression": { severity: "block" },
+      "coverage-lowering": { severity: "block" },
+      "ci-tampering": { severity: "block" },
+      "hook-tampering": { severity: "block" },
+      "no-verify": { severity: "block" },
+      // heuristic — warn until precision is measured (SPEC §7)
+      "assertion-weakening": { severity: "warn" },
+      "guard-removal": { severity: "warn" }
+    },
+    ignore: [],
+    signoff: { requiredFor: ["block"], ledger: ".tamperward/ledger.jsonl" }
+  };
+}
+
+// src/detectors/files.ts
+var CODE = /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+function isCodeFile(path) {
+  return CODE.test(path);
+}
+
+// src/detectors/ts-any-cast.ts
+var BLOCK_RULE = "ts-any-cast";
+var WARN_RULE = "ts-any-launder";
+var DOUBLE_CAST = /\bas\s+unknown\s+as\b/g;
+var SUPPRESS = /@ts-(?:ignore|expect-error|nocheck)\b/g;
+var countMatches = (s, re) => (s.match(re) || []).length;
+function countAny(src) {
+  const r = { cast: 0, broad: 0 };
+  try {
+    const sf = ts.createSourceFile("f.ts", src, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const visit = (node) => {
+      if (node.kind === ts.SyntaxKind.AnyKeyword) {
+        const p = node.parent;
+        const isCast = p && ts.isAsExpression(p) && p.type === node || p && ts.isTypeAssertionExpression(p) && p.type === node;
+        if (isCast) r.cast++;
+        else r.broad++;
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sf);
+  } catch {
+  }
+  return r;
+}
+var NARROW_LINE = /\bas\s+any\b|<\s*any\s*>|\bas\s+unknown\s+as\b|@ts-(?:ignore|expect-error|nocheck)\b/;
+var BROAD_LINE = /:\s*any\b|<[^<>]*\bany\b[^<>]*>/;
+var BLOCK_REMEDIATION = "Fix the underlying type instead of silencing the checker; do not cast to `any`.";
+var WARN_REMEDIATION = "Prefer a precise type or `unknown` + a guard over `any` here \u2014 flagged for review.";
+var tsAnyCast = {
+  id: BLOCK_RULE,
+  surface: ["file"],
+  certainty: "mechanical",
+  run(changes, policy) {
+    const out = [];
+    for (const c of changes) {
+      if (c.kind !== "file" || !isCodeFile(c.path)) continue;
+      const inTest = protectedCategory(c.path, policy) === "tests";
+      if (c.after != null && c.op !== "delete") {
+        const before = c.before ?? "";
+        const a = countAny(c.after);
+        const b = countAny(before);
+        const dCast = a.cast - b.cast;
+        const dBroad = a.broad - b.broad;
+        const dDouble = countMatches(c.after, DOUBLE_CAST) - countMatches(before, DOUBLE_CAST);
+        const dSuppr = countMatches(c.after, SUPPRESS) - countMatches(before, SUPPRESS);
+        const blockReasons = [];
+        if (dCast > 0) blockReasons.push("`as any` cast");
+        if (dDouble > 0) blockReasons.push("`as unknown as` double cast");
+        if (dSuppr > 0) blockReasons.push("@ts-ignore/@ts-expect-error/@ts-nocheck suppression");
+        if (blockReasons.length) {
+          out.push(
+            makeFinding(inTest ? WARN_RULE : BLOCK_RULE, policy, {
+              file: c.path,
+              message: inTest ? `Type-checker escape in a test file: ${blockReasons.join("; ")} (test infrastructure \u2014 flagged, not blocked).` : `Type safety discarded: ${blockReasons.join("; ")}.`,
+              evidence: blockReasons[0],
+              remediation: inTest ? WARN_REMEDIATION : BLOCK_REMEDIATION,
+              defaultSeverity: inTest ? "warn" : "block"
+            })
+          );
+        }
+        if (dBroad > 0) {
+          out.push(
+            makeFinding(WARN_RULE, policy, {
+              file: c.path,
+              message: `Type laundered to \`any\`: introduces ${dBroad} new \`any\`-typed value(s) in a type/generic position (e.g. : any, Record<string, any>).`,
+              evidence: "net-new `any` in a type position",
+              remediation: WARN_REMEDIATION,
+              defaultSeverity: "warn"
+            })
+          );
+        }
+        continue;
+      }
+      for (const l of addedLines(c)) {
+        if (NARROW_LINE.test(l.content)) {
+          out.push(
+            makeFinding(inTest ? WARN_RULE : BLOCK_RULE, policy, {
+              file: c.path,
+              line: l.newLine ?? void 0,
+              message: inTest ? "Type-checker escape in a test file (test infrastructure \u2014 flagged, not blocked)." : "Type safety discarded: an explicit cast/suppression was added.",
+              evidence: l.content.trim(),
+              remediation: inTest ? WARN_REMEDIATION : BLOCK_REMEDIATION,
+              defaultSeverity: inTest ? "warn" : "block"
+            })
+          );
+        } else if (BROAD_LINE.test(l.content)) {
+          out.push(
+            makeFinding(WARN_RULE, policy, {
+              file: c.path,
+              line: l.newLine ?? void 0,
+              message: "Type laundered to `any` in a type/generic position.",
+              evidence: l.content.trim(),
+              remediation: WARN_REMEDIATION,
+              defaultSeverity: "warn"
+            })
+          );
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// src/detectors/lint-suppression.ts
+var RULE2 = "lint-suppression";
+var PATTERNS = [
+  { re: /eslint-disable(?:-next-line|-line)?\b/, why: "eslint-disable suppresses lint rules" },
+  { re: /\bprettier-ignore\b/, why: "prettier-ignore suppresses formatting checks" },
+  { re: /\bbiome-ignore\b/, why: "biome-ignore suppresses Biome diagnostics" }
+];
+var lintSuppression = {
+  id: RULE2,
+  surface: ["file"],
+  certainty: "mechanical",
+  run(changes, policy) {
+    const out = [];
+    for (const c of changes) {
+      if (c.kind !== "file" || !isCodeFile(c.path)) continue;
+      for (const l of addedLines(c)) {
+        for (const p of PATTERNS) {
+          if (p.re.test(l.content)) {
+            out.push(
+              makeFinding(RULE2, policy, {
+                file: c.path,
+                line: l.newLine ?? void 0,
+                message: `Lint suppression added: ${p.why}.`,
+                evidence: l.content.trim(),
+                remediation: "Resolve the finding rather than suppressing the rule."
+              })
+            );
+            break;
+          }
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// src/detectors/test-skip.ts
+var RULE3 = "test-skip";
+var PATTERNS2 = [
+  { re: /\b(?:it|test|describe)\.(?:skip|only|todo)\b/, why: "a .skip/.only/.todo marker" },
+  { re: /\b(?:xit|xtest|xdescribe)\b/, why: "an x-prefixed disabled test" },
+  { re: /\b(?:fit|ftest|fdescribe)\b/, why: "an f-prefixed focused test (narrows the suite)" },
+  { re: /\bpending\(\s*\)/, why: "a pending() marker" }
+];
+var testSkip = {
+  id: RULE3,
+  surface: ["file"],
+  certainty: "mechanical",
+  run(changes, policy) {
+    const out = [];
+    for (const c of changes) {
+      if (c.kind !== "file") continue;
+      if (!isProtected(c.path, policy, "tests")) continue;
+      for (const l of addedLines(c)) {
+        for (const p of PATTERNS2) {
+          if (p.re.test(l.content)) {
+            out.push(
+              makeFinding(RULE3, policy, {
+                file: c.path,
+                line: l.newLine ?? void 0,
+                message: `Test skipped or narrowed: ${p.why}.`,
+                evidence: l.content.trim(),
+                remediation: "Make the test pass rather than skipping it. If it is genuinely obsolete, a human must sign off."
+              })
+            );
+            break;
+          }
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// src/detectors/coverage-lowering.ts
+import ts2 from "typescript";
+var RULE4 = "coverage-lowering";
+var METRICS = ["branches", "functions", "lines", "statements"];
+var isMetric = (k) => METRICS.includes(k);
+var norm = (p) => p.replace(/^\.\//, "");
+function keyName(name) {
+  if (ts2.isIdentifier(name) || ts2.isStringLiteral(name) || ts2.isNumericLiteral(name)) return name.text;
+  return null;
+}
+function numericOf(e) {
+  if (ts2.isNumericLiteral(e)) return Number(e.text);
+  if (ts2.isPrefixUnaryExpression(e) && e.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(e.operand)) {
+    return -Number(e.operand.text);
+  }
+  return void 0;
+}
+function metricsOf(obj) {
+  if (!ts2.isObjectLiteralExpression(obj)) return void 0;
+  const out = {};
+  let any = false;
+  for (const p of obj.properties) {
+    if (!ts2.isPropertyAssignment(p)) continue;
+    const k = keyName(p.name);
+    if (k === null || !isMetric(k)) continue;
+    const n = numericOf(p.initializer);
+    if (n === void 0) continue;
+    out[k] = n;
+    any = true;
+  }
+  return any ? out : void 0;
+}
+function underCoverageKey(node) {
+  for (let p = node.parent; p; p = p.parent) {
+    if (ts2.isPropertyAssignment(p) && keyName(p.name) === "coverage") return true;
+  }
+  return false;
+}
+function parseThresholds(src) {
+  const res = { paths: /* @__PURE__ */ new Map(), present: false };
+  try {
+    const sf = ts2.createSourceFile("cfg.ts", src, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
+    const visit = (node) => {
+      if (ts2.isPropertyAssignment(node) && ts2.isObjectLiteralExpression(node.initializer)) {
+        const key2 = keyName(node.name);
+        if (key2 === "coverageThreshold" || key2 === "thresholds" && underCoverageKey(node)) {
+          res.present = true;
+          const flat = metricsOf(node.initializer);
+          if (flat) res.global = { ...res.global ?? {}, ...flat };
+          for (const p of node.initializer.properties) {
+            if (!ts2.isPropertyAssignment(p)) continue;
+            const k = keyName(p.name);
+            if (k === null || isMetric(k)) continue;
+            const m = metricsOf(p.initializer);
+            if (!m) continue;
+            if (k === "global") res.global = { ...res.global ?? {}, ...m };
+            else res.paths.set(norm(k), m);
+          }
+        }
+      }
+      ts2.forEachChild(node, visit);
+    };
+    visit(sf);
+  } catch {
+  }
+  return res;
+}
+var eff = (t, path) => t.paths.get(norm(path)) ?? t.global;
+function compareMetrics(scope, before, after, out) {
+  if (!before) return;
+  for (const m of METRICS) {
+    const bv = before[m];
+    if (bv === void 0) continue;
+    const av = after?.[m];
+    if (av === void 0) out.push(`${scope} ${m} threshold removed (was ${bv})`);
+    else if (av < bv) out.push(`${scope} ${m} threshold lowered ${bv} \u2192 ${av}`);
+  }
+}
+function weakenings(before, after) {
+  const out = [];
+  if (before.present && !after.present) {
+    out.push("the coverage threshold gate was removed");
+    return out;
+  }
+  compareMetrics("global", before.global, after.global, out);
+  const paths = /* @__PURE__ */ new Set([...before.paths.keys(), ...after.paths.keys()]);
+  for (const p of paths) {
+    compareMetrics(`required coverage for ${p}:`, eff(before, p), eff(after, p), out);
+  }
+  return out;
+}
+var coverageLowering = {
+  id: RULE4,
+  surface: ["file"],
+  certainty: "mechanical",
+  run(changes, policy) {
+    const out = [];
+    for (const c of changes) {
+      if (c.kind !== "file") continue;
+      if (!isProtected(c.path, policy, "config")) continue;
+      if (c.after != null && c.op !== "delete") {
+        for (const reason of weakenings(parseThresholds(c.before ?? ""), parseThresholds(c.after))) {
+          out.push(
+            makeFinding(RULE4, policy, {
+              file: c.path,
+              message: `Coverage gate weakened: ${reason}.`,
+              evidence: reason,
+              remediation: "Raise real coverage by adding tests; do not lower or exempt the gate to pass."
+            })
+          );
+        }
+      } else if (c.op === "delete" || c.after === "" && (c.before ?? "").length > 0) {
+        if (parseThresholds(c.before ?? "").present) {
+          out.push(
+            makeFinding(RULE4, policy, {
+              file: c.path,
+              message: "Coverage gate weakened: the coverage config was deleted.",
+              evidence: c.path,
+              remediation: "Restore the coverage config; raise real coverage instead of removing the gate."
+            })
+          );
+        }
+      }
+      const added = addedLines(c);
+      const removed = removedLines(c);
+      const removedCoverage = removed.find((l) => /--coverage\b/.test(l.content));
+      if (removedCoverage && !added.some((l) => /--coverage\b/.test(l.content))) {
+        out.push(
+          makeFinding(RULE4, policy, {
+            file: c.path,
+            message: "The --coverage flag was removed from a test script.",
+            evidence: removedCoverage.content.trim(),
+            remediation: "Keep coverage reporting on; do not strip the flag to dodge the gate."
+          })
+        );
+      }
+      for (const l of added) {
+        if (/--passWithNoTests\b/.test(l.content)) {
+          out.push(
+            makeFinding(RULE4, policy, {
+              file: c.path,
+              line: l.newLine ?? void 0,
+              message: "--passWithNoTests added \u2014 the suite can now pass with zero tests.",
+              evidence: l.content.trim(),
+              remediation: "Remove --passWithNoTests; an empty suite must not be a green check."
+            })
+          );
+        }
+      }
+      if (c.after == null) {
+        const KEY = /\b(branches|functions|lines|statements)\b\s*:\s*(\d+(?:\.\d+)?)/;
+        const oldNums = /* @__PURE__ */ new Map();
+        for (const l of removed) {
+          const m = l.content.match(KEY);
+          if (m) oldNums.set(m[1], Number(m[2]));
+        }
+        for (const l of added) {
+          const m = l.content.match(KEY);
+          if (!m) continue;
+          const ov = oldNums.get(m[1]);
+          if (ov !== void 0 && Number(m[2]) < ov) {
+            out.push(
+              makeFinding(RULE4, policy, {
+                file: c.path,
+                line: l.newLine ?? void 0,
+                message: `Coverage threshold for ${m[1]} lowered ${ov} \u2192 ${m[2]}.`,
+                evidence: l.content.trim(),
+                remediation: "Restore the threshold and raise real coverage; do not lower the gate to pass."
+              })
+            );
+          }
+        }
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    return out.filter((f) => {
+      const k = `${f.rule}|${f.message}`;
+      if (seen.has(k)) return false;
+      seen.add(k);
+      return true;
+    });
+  }
+};
+
+// src/detectors/ci-tampering.ts
+var RULE5 = "ci-tampering";
+var STEP = /^\s*-?\s*(?:run|uses):/;
+var CHECK = /\b(test|tests|lint|typecheck|type-check|tsc|eslint|jest|vitest|playwright|coverage|tamperward)\b/i;
+var YAML_KEY = /^\s*-?\s*[A-Za-z_][\w-]*:\s*(?:$|\S)/;
+var RUNNER = /\b(npm|npx|pnpm|yarn|bun|make|cargo|pytest|python|jest|vitest|eslint|tsc|playwright|tamperward|gradle|mvn|dotnet)\b/;
+var uncommented = (v) => v.replace(/\s+#.*$/, "").trim();
+function isAlwaysFalse(raw) {
+  const v = uncommented(raw);
+  if (/^false$/i.test(v)) return true;
+  const m = v.match(/^\$\{\{\s*(.+?)\s*\}\}$/);
+  if (!m) return false;
+  const e = m[1];
+  if (/^(false|0|''|"")$/i.test(e)) return true;
+  const cmp = e.match(/^(-?\d+)\s*(==|!=)\s*(-?\d+)$/);
+  if (cmp) return cmp[2] === "==" ? cmp[1] !== cmp[3] : cmp[1] === cmp[3];
+  return false;
+}
+function isTruthy(raw) {
+  const v = uncommented(raw);
+  if (/^true$/i.test(v)) return true;
+  const m = v.match(/^\$\{\{\s*(.+?)\s*\}\}$/);
+  return !!m && /^(true|1)$/i.test(m[1]);
+}
+var ciTampering = {
+  id: RULE5,
+  surface: ["file"],
+  certainty: "mechanical",
+  run(changes, policy) {
+    const out = [];
+    for (const c of changes) {
+      if (c.kind !== "file") continue;
+      if (!isProtected(c.path, policy, "ci")) continue;
+      for (const l of addedLines(c)) {
+        const coe = l.content.match(/^\s*-?\s*continue-on-error:\s*(.+?)\s*$/);
+        const cond = l.content.match(/^\s*-?\s*if:\s*(.+?)\s*$/);
+        if (coe && isTruthy(coe[1])) {
+          out.push(
+            makeFinding(RULE5, policy, {
+              file: c.path,
+              line: l.newLine ?? void 0,
+              message: "continue-on-error: true added \u2014 failures will no longer fail the job.",
+              evidence: l.content.trim(),
+              remediation: "Remove it. A check that cannot fail is not a check."
+            })
+          );
+        } else if (cond && isAlwaysFalse(cond[1])) {
+          out.push(
+            makeFinding(RULE5, policy, {
+              file: c.path,
+              line: l.newLine ?? void 0,
+              message: `if: ${uncommented(cond[1])} added \u2014 this step can never run.`,
+              evidence: l.content.trim(),
+              remediation: "Re-enable the step instead of conditioning it off."
+            })
+          );
+        }
+      }
+      const stillPresent = new Set(addedLines(c).map((l) => l.content.trim()));
+      for (const l of removedLines(c)) {
+        if (stillPresent.has(l.content.trim())) continue;
+        const isStepLine = STEP.test(l.content) && CHECK.test(l.content);
+        const isRunBodyLine = !YAML_KEY.test(l.content) && RUNNER.test(l.content) && CHECK.test(l.content);
+        if (!isStepLine && !isRunBodyLine) continue;
+        out.push(
+          makeFinding(RULE5, policy, {
+            file: c.path,
+            message: isStepLine ? "A CI check step (test/lint/typecheck) was removed." : "A CI check command was removed from a run block.",
+            evidence: l.content.trim(),
+            remediation: "Restore the step. Removing the check that protects main is itself the tamper."
+          })
+        );
+      }
+    }
+    return out;
+  }
+};
+
+// src/detectors/policy-diff.ts
+import { parse } from "yaml";
+function safeParse(src) {
+  try {
+    const v = parse(src);
+    if (v && typeof v === "object" && !Array.isArray(v)) return v;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function effective(raw) {
+  const base = defaultPolicy();
+  return {
+    rules: { ...base.rules, ...raw.rules ?? {} },
+    ignore: raw.ignore ?? base.ignore ?? [],
+    protected: mergeProtected(base.protected, raw.protected),
+    requiredFor: raw.signoff?.required_for ?? raw.signoff?.requiredFor ?? base.signoff.requiredFor
+  };
+}
+function policyWeakening(before, after) {
+  const b = safeParse(before);
+  if (b === null) return null;
+  const a = safeParse(after);
+  if (a === null) return ["the policy no longer parses as a valid policy (emptied or corrupted)"];
+  const be = effective(b);
+  const ae = effective(a);
+  const reasons = [];
+  for (const name of /* @__PURE__ */ new Set([...Object.keys(be.rules), ...Object.keys(ae.rules)])) {
+    const br = be.rules[name];
+    const ar = ae.rules[name];
+    if (!br) continue;
+    if (!ar) {
+      reasons.push(`rule "${name}" removed from policy`);
+      continue;
+    }
+    if (br.severity === "block" && ar.severity === "warn") {
+      reasons.push(`rule "${name}" lowered block \u2192 warn`);
+    }
+    if (ar.enabled === false && br.enabled !== false) {
+      reasons.push(`rule "${name}" disabled (enabled: false)`);
+    }
+  }
+  const beforeIgnore = new Set(be.ignore);
+  const addedIgnore = ae.ignore.filter((g) => !beforeIgnore.has(g));
+  if (addedIgnore.length) {
+    reasons.push(`ignore globs added (${addedIgnore.join(", ")}) \u2014 disables detection on those paths`);
+  }
+  for (const cat of /* @__PURE__ */ new Set([...Object.keys(be.protected), ...Object.keys(ae.protected)])) {
+    const stillThere = new Set(ae.protected[cat] ?? []);
+    const removed = (be.protected[cat] ?? []).filter((g) => !stillThere.has(g));
+    if (removed.length) reasons.push(`protected.${cat} narrowed (removed ${removed.join(", ")})`);
+  }
+  if (be.requiredFor.includes("block") && !new Set(ae.requiredFor).has("block")) {
+    reasons.push("sign-off no longer required for blocking findings");
+  }
+  return reasons;
+}
+
+// src/detectors/hook-tampering.ts
+var RULE6 = "hook-tampering";
+var HOOK_INVOCATION = /\b(tamperward|npx|npm|pnpm|yarn|bun|jest|vitest|eslint|tsc|lefthook|husky|lint-staged|make|cargo|pytest)\b/;
+var isShellComment = (s) => /^\s*#/.test(s);
+var hookTampering = {
+  id: RULE6,
+  surface: ["file", "command"],
+  certainty: "mechanical",
+  run(changes, policy) {
+    const out = [];
+    for (const c of changes) {
+      if (c.kind === "file") {
+        const targetsHook = isProtected(c.path, policy, "hooks") || (c.oldPath ? isProtected(c.oldPath, policy, "hooks") : false);
+        if (!targetsHook) continue;
+        if (c.op === "delete") {
+          out.push(
+            makeFinding(RULE6, policy, {
+              file: c.path,
+              message: "A protected hook/policy file was deleted.",
+              evidence: c.path,
+              remediation: "Restore it. The hooks and the policy are protected assets, not obstacles to remove."
+            })
+          );
+        } else if (c.op === "rename") {
+          out.push(
+            makeFinding(RULE6, policy, {
+              file: c.path,
+              message: `A protected hook/policy file was renamed (${c.oldPath} \u2192 ${c.path}).`,
+              evidence: `${c.oldPath} \u2192 ${c.path}`,
+              remediation: "Renaming a hook out of place disables it. Restore the original path."
+            })
+          );
+        } else if (c.path.endsWith(POLICY_FILE) && c.before != null && c.after != null && policyWeakening(c.before, c.after) !== null) {
+          for (const reason of policyWeakening(c.before, c.after) ?? []) {
+            out.push(
+              makeFinding(RULE6, policy, {
+                file: c.path,
+                message: `The policy was weakened: ${reason}.`,
+                evidence: reason,
+                remediation: "A change that weakens the guardrail is a high-risk edit requiring human sign-off, not an automated pass."
+              })
+            );
+          }
+        } else if (!c.path.endsWith(POLICY_FILE)) {
+          const added = addedLines(c);
+          const removed = removedLines(c);
+          const live = added.filter((l) => !isShellComment(l.content));
+          const earlyExit = added.find((l) => /^\s*exit\s+0\s*$/.test(l.content));
+          if (earlyExit) {
+            out.push(
+              makeFinding(RULE6, policy, {
+                file: c.path,
+                line: earlyExit.newLine ?? void 0,
+                message: "An early `exit 0` was inserted into a protected hook \u2014 it now passes everything.",
+                evidence: earlyExit.content.trim(),
+                remediation: "Remove the early exit. A hook that always succeeds is a disabled hook."
+              })
+            );
+          }
+          for (const l of removed) {
+            if (isShellComment(l.content) || !l.content.trim()) continue;
+            const m = l.content.match(HOOK_INVOCATION);
+            if (!m) continue;
+            if (live.some((a) => a.content.includes(m[0]))) continue;
+            out.push(
+              makeFinding(RULE6, policy, {
+                file: c.path,
+                message: `A check invocation (\`${m[0]}\`) was removed from a protected hook.`,
+                evidence: l.content.trim(),
+                remediation: "Restore the check. Removing or commenting out the gate's invocation disables it just as surely as deleting the hook."
+              })
+            );
+            break;
+          }
+        } else {
+          const INLINE = /^\s*([A-Za-z0-9_-]+):\s*\{[^}]*\bseverity:\s*(block|warn)\b/;
+          const removedSeverity = /* @__PURE__ */ new Map();
+          for (const l of removedLines(c)) {
+            const m = l.content.match(INLINE);
+            if (m) removedSeverity.set(m[1], m[2]);
+          }
+          for (const l of addedLines(c)) {
+            const m = l.content.match(INLINE);
+            if (m && m[2] === "warn" && removedSeverity.get(m[1]) === "block") {
+              out.push(
+                makeFinding(RULE6, policy, {
+                  file: c.path,
+                  line: l.newLine ?? void 0,
+                  message: `Rule "${m[1]}" was lowered from block to warn in the policy.`,
+                  evidence: l.content.trim(),
+                  remediation: "Do not weaken the policy to pass. Lowering a gate is a human sign-off decision."
+                })
+              );
+            } else if (/enabled:\s*false\b/.test(l.content)) {
+              out.push(
+                makeFinding(RULE6, policy, {
+                  file: c.path,
+                  line: l.newLine ?? void 0,
+                  message: "A rule was disabled (enabled: false) in the policy.",
+                  evidence: l.content.trim(),
+                  remediation: "Re-enable the rule. Disabling the check to pass is the tamper."
+                })
+              );
+            }
+          }
+        }
+      } else {
+        for (const seg of segments(c.raw)) {
+          const hitsHook = tokens(seg).map(unquote).some((t) => isProtected(t, policy, "hooks"));
+          if (!hitsHook) continue;
+          const octal = seg.match(/\bchmod\b[^|;&]*?(?:^|\s)([0-7]{3,4})(?:\s|$)/);
+          const octalDropsExec = octal ? (Number(octal[1].slice(-3)[0]) & 1) === 0 : false;
+          let why = null;
+          if (/\bchmod\b/.test(seg) && (/(?:^|\s)[-+=]?[a-z]*x/i.test(seg) || octalDropsExec)) {
+            why = "chmod alters execute permission on a hook, which can disable it";
+          } else if (/\brm\b/.test(seg)) {
+            why = "rm deletes a protected hook";
+          } else if (/\btruncate\b/.test(seg) || /(?:^|\s)>\s*\S/.test(seg)) {
+            why = "a redirect/truncate empties a protected hook";
+          } else if (/\b(tee|sed|cp|dd|install|mv)\b/.test(seg)) {
+            why = "a shell rewrite (tee/sed/cp/dd/install/mv) replaces a protected hook in place";
+          }
+          if (why) {
+            out.push(
+              makeFinding(RULE6, policy, {
+                message: `Hook tampering via shell: ${why}.`,
+                evidence: seg,
+                remediation: "Leave the hooks in place. Mutating them from the shell is still tampering."
+              })
+            );
+          }
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// src/detectors/test-deletion.ts
+import ts3 from "typescript";
+var RULE7 = "test-deletion";
+function calleeName(expr) {
+  if (ts3.isIdentifier(expr)) return expr.text;
+  if (ts3.isPropertyAccessExpression(expr) && ts3.isIdentifier(expr.expression)) {
+    return expr.expression.text;
+  }
+  return null;
+}
+function countTestBlocks(src) {
+  const sf = ts3.createSourceFile("spec.ts", src, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
+  let n = 0;
+  const visit = (node) => {
+    if (ts3.isCallExpression(node)) {
+      const name = calleeName(node.expression);
+      if (name === "it" || name === "test") n++;
+    }
+    ts3.forEachChild(node, visit);
+  };
+  visit(sf);
+  return n;
+}
+function significantLines(src) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of src.split("\n")) {
+    const l = raw.trim();
+    if (l.length >= 10 && !/^(import\b|export\s|\/\/|\*|\/\*|}\)?;?$)/.test(l)) out.add(l);
+  }
+  return out;
+}
+var testDeletion = {
+  id: RULE7,
+  surface: ["file", "command"],
+  certainty: "mechanical",
+  run(changes, policy) {
+    const out = [];
+    const addedTestLines = /* @__PURE__ */ new Set();
+    let addedTestBlocks = 0;
+    for (const c of changes) {
+      if (c.kind === "file" && c.op === "add" && c.after != null && isProtected(c.path, policy, "tests")) {
+        for (const l of significantLines(c.after)) addedTestLines.add(l);
+        addedTestBlocks += countTestBlocks(c.after);
+      }
+    }
+    const isRelocation = (before) => {
+      const sig = significantLines(before);
+      if (sig.size === 0 || addedTestLines.size === 0) return false;
+      let hit = 0;
+      for (const l of sig) if (addedTestLines.has(l)) hit++;
+      return hit / sig.size >= 0.6 && addedTestBlocks >= countTestBlocks(before);
+    };
+    for (const c of changes) {
+      if (c.kind === "file") {
+        const isTest = isProtected(c.path, policy, "tests");
+        if (c.op === "delete" && isTest) {
+          if (c.before != null && isRelocation(c.before)) continue;
+          out.push(
+            makeFinding(RULE7, policy, {
+              file: c.path,
+              message: "A test file was deleted.",
+              evidence: c.path,
+              remediation: "Fix the code under test, not the suite. Deleting a failing test to pass is the move this blocks."
+            })
+          );
+        } else if (c.op === "rename" && c.oldPath && isProtected(c.oldPath, policy, "tests") && !isTest) {
+          out.push(
+            makeFinding(RULE7, policy, {
+              file: c.path,
+              message: `A test file was renamed out of the test glob (${c.oldPath} \u2192 ${c.path}).`,
+              evidence: `${c.oldPath} \u2192 ${c.path}`,
+              remediation: "Restoring the path. Renaming a spec out of the glob silently removes it from the suite."
+            })
+          );
+        } else if (c.op === "modify" && isTest && c.before != null && c.after != null) {
+          const before = countTestBlocks(c.before);
+          const after = countTestBlocks(c.after);
+          if (after < before) {
+            out.push(
+              makeFinding(RULE7, policy, {
+                file: c.path,
+                message: `Test blocks removed: ${before} \u2192 ${after} it()/test() in this spec.`,
+                evidence: `${before - after} test block(s) removed from ${c.path}`,
+                remediation: "Keep the assertions and fix the code. Removing test blocks to go green is the tamper."
+              })
+            );
+          }
+        }
+      } else {
+        for (const seg of segments(c.raw)) {
+          const toks = tokens(seg).map(unquote);
+          const testToks = toks.filter((t) => isProtected(t, policy, "tests"));
+          if (testToks.length === 0) continue;
+          let why = null;
+          let evidence = seg;
+          const redirectTarget = seg.match(/>\s*(\S+)/)?.[1];
+          const redirectsOntoTest = redirectTarget ? isProtected(unquote(redirectTarget), policy, "tests") : false;
+          if (/\brm\b/.test(seg)) {
+            why = "rm deletes a test file";
+          } else if (/\bsed\b/.test(seg) && /(?:^|\s)-i\b/.test(seg)) {
+            why = "sed -i rewrites a test file in place";
+          } else if (/\btruncate\b/.test(seg)) {
+            why = "truncate empties a test file";
+          } else if (redirectsOntoTest) {
+            why = "a redirect overwrites/empties a test file";
+          } else if (/\bmv\b/.test(seg)) {
+            const dest = toks[toks.length - 1];
+            if (dest && !isProtected(dest, policy, "tests")) {
+              why = "mv renames a test file out of the test glob";
+              evidence = `${testToks[0]} \u2192 ${dest}`;
+            }
+          }
+          if (why) {
+            out.push(
+              makeFinding(RULE7, policy, {
+                message: `Test removed via shell: ${why}.`,
+                evidence,
+                remediation: "Fix the code under test. Mutating a spec from the shell is still deleting the test \u2014 and is blocked the same way."
+              })
+            );
+          }
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// src/detectors/index.ts
+var allDetectors = [
+  noVerify,
+  tsAnyCast,
+  lintSuppression,
+  testSkip,
+  coverageLowering,
+  ciTampering,
+  hookTampering,
+  testDeletion
+];
+
+// src/engine.ts
+function key(f) {
+  return `${f.rule}|${f.file ?? ""}|${f.line ?? ""}|${f.evidence}`;
+}
+function isSuppressed(c, policy) {
+  if (c.kind !== "file") return false;
+  if (isPolicyFile(c.path) || c.oldPath != null && isPolicyFile(c.oldPath)) return false;
+  return isIgnored(c.path, policy);
+}
+function activeChanges(changes, policy) {
+  return changes.filter((c) => !isSuppressed(c, policy));
+}
+function evaluate(changes, policy, detectors = allDetectors) {
+  const active = activeChanges(changes, policy);
+  const out = [];
+  for (const d of detectors) {
+    if (!isEnabled(d.id, policy)) continue;
+    try {
+      out.push(...d.run(active, policy));
+    } catch (e) {
+      process.stderr.write(`tamperward: detector "${d.id}" errored and was skipped: ${String(e)}
+`);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return out.filter((f) => {
+    const k = key(f);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+function hasBlocking(findings) {
+  return findings.some((f) => f.severity === "block");
+}
+
+// src/policy-load.ts
+import { readFileSync as readFileSync2, existsSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { parse as parse2 } from "yaml";
+var PolicyError = class extends Error {
+};
+function parsePolicy(raw) {
+  const base = defaultPolicy();
+  const r = raw ?? {};
+  return {
+    version: 1,
+    // Merge with the baseline, never replace. For an integrity tool, a config that sets
+    // one rule's severity must NOT silently drop the other nine — nor may naming one
+    // protected glob wipe out the rest of its category (see mergeProtected).
+    protected: mergeProtected(base.protected, r.protected),
+    rules: { ...base.rules, ...r.rules ?? {} },
+    ignore: r.ignore ?? base.ignore,
+    signoff: {
+      requiredFor: r.signoff?.required_for ?? r.signoff?.requiredFor ?? base.signoff.requiredFor,
+      ledger: r.signoff?.ledger ?? base.signoff.ledger
+    }
+  };
+}
+function parseOrThrow(src, where) {
+  let raw;
+  try {
+    raw = parse2(src);
+  } catch (e) {
+    throw new PolicyError(`${where} is not valid YAML: ${e.message}`);
+  }
+  if (raw !== null && raw !== void 0 && (typeof raw !== "object" || Array.isArray(raw))) {
+    throw new PolicyError(`${where} is not a policy mapping`);
+  }
+  return parsePolicy(raw);
+}
+function loadPolicy(cwd = process.cwd()) {
+  const path = join2(cwd, POLICY_FILE);
+  if (!existsSync(path)) return defaultPolicy();
+  return parseOrThrow(readFileSync2(path, "utf8"), POLICY_FILE);
+}
+function loadPolicyAt(rev, cwd) {
+  const src = fileAt(rev, POLICY_FILE, { cwd });
+  if (src == null) return null;
+  return parseOrThrow(src, `${POLICY_FILE} at ${rev}`);
+}
+
+// src/signoff.ts
+import { createHash } from "node:crypto";
+import { appendFileSync, mkdirSync, readFileSync as readFileSync3, existsSync as existsSync2 } from "node:fs";
+import { dirname, join as join3 } 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);
+}
+var fingerprintOf = (f) => fingerprint(f.rule, f.file, f.evidence);
+function ledgerPath(cwd, policy) {
+  return join3(cwd, policy.signoff?.ledger ?? ".tamperward/ledger.jsonl");
+}
+function readLedger(cwd, policy) {
+  const p = ledgerPath(cwd, policy);
+  if (!existsSync2(p)) return [];
+  const out = [];
+  for (const line of readFileSync3(p, "utf8").split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const e = JSON.parse(line);
+      if (e && typeof e.fingerprint === "string") out.push(e);
+    } catch {
+    }
+  }
+  return out;
+}
+function appendEntry(cwd, policy, e) {
+  const p = ledgerPath(cwd, policy);
+  mkdirSync(dirname(p), { recursive: true });
+  appendFileSync(p, JSON.stringify(e) + "\n");
+}
+function makeEntry(f, reason, now, ttlMs = DEFAULT_TTL_MS) {
+  return { rule: f.rule, file: f.file, fingerprint: fingerprintOf(f), reason, recordedAt: now, expiresAt: now + ttlMs };
+}
+function applyLocalSignoffs(findings, cwd, policy, now = Date.now()) {
+  const ledger = readLedger(cwd, policy).filter((e) => e.expiresAt > now);
+  const valid = new Set(ledger.map((e) => e.fingerprint));
+  const cleared = [];
+  const remaining = [];
+  for (const f of findings) {
+    if (f.severity === "block" && valid.has(fingerprintOf(f))) cleared.push(f);
+    else remaining.push(f);
+  }
+  return { findings: remaining, cleared };
+}
+function applyOobSignoffs(findings, oob) {
+  const set = new Set(oob.map((s) => s.trim()).filter(Boolean));
+  const cleared = [];
+  const remaining = [];
+  for (const f of findings) {
+    const ok = f.severity === "block" && (set.has(f.rule) || (f.file ? set.has(`${f.rule}:${f.file}`) : false));
+    if (ok) cleared.push(f);
+    else remaining.push(f);
+  }
+  return { findings: remaining, cleared };
+}
+function oobFromEnv(env = process.env) {
+  return (env.TAMPERWARD_OOB_SIGNOFF ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+}
+
+// src/cli/report.ts
+function report(input) {
+  const { findings, scanned, ignoredFiles } = input;
+  if (input.json) {
+    process.stdout.write(JSON.stringify({ findings, scanned, ignoredFiles }, null, 2) + "\n");
+    return;
+  }
+  const ignoredNote = ignoredFiles > 0 ? `, ${ignoredFiles} file(s) ignored by policy` : "";
+  if (findings.length === 0) {
+    process.stdout.write(`tamperward: clean \u2014 no integrity findings (${scanned} change(s) scanned${ignoredNote}).
+`);
+    return;
+  }
+  const blocks = findings.filter((f) => f.severity === "block");
+  const warns = findings.filter((f) => f.severity === "warn");
+  for (const f of findings) {
+    const mark = f.severity === "block" ? "BLOCK" : "warn";
+    const loc = f.file ? ` ${f.file}${f.line ? `:${f.line}` : ""}` : "";
+    process.stdout.write(`
+[${mark}] ${f.rule}${loc}
+`);
+    process.stdout.write(`  ${f.message}
+`);
+    process.stdout.write(`  evidence: ${f.evidence}
+`);
+    process.stdout.write(`  fix:      ${f.remediation}
+`);
+    if (f.signoff.required) process.stdout.write(`  sign-off: ${f.signoff.command}
+`);
+  }
+  process.stdout.write(
+    `
+tamperward: ${blocks.length} blocking, ${warns.length} warning (${scanned} change(s) scanned${ignoredNote}).
+`
+  );
+  if (blocks.length > 0) {
+    process.stdout.write(
+      "A blocking finding clears only with a human sign-off. In CI, sign-off is out-of-band (a reviewed PR label), never a committed file \u2014 see SPEC \xA75.4.\n"
+    );
+  }
+}
+
+// src/cli/check.ts
+function check(opts) {
+  let policy = loadPolicy(opts.cwd);
+  const cwd = opts.cwd ?? process.cwd();
+  let changes;
+  let layer;
+  if (opts.staged) {
+    changes = diffStaged({ cwd: opts.cwd });
+    layer = "local";
+  } else if (opts.worktree) {
+    changes = diffWorktree({ cwd: opts.cwd });
+    layer = "local";
+  } else if (opts.diff) {
+    const [base, head] = opts.diff.split(/\.{2,3}/);
+    if (!base || !head) {
+      process.stderr.write(`tamperward: invalid --diff range "${opts.diff}" (expected <base>...<head>)
+`);
+      return 2;
+    }
+    changes = diffRange(base, head, { cwd: opts.cwd });
+    layer = "ci";
+    policy = loadPolicyAt(mergeBaseOf(base, head, { cwd: opts.cwd }), opts.cwd) ?? defaultPolicy();
+  } else {
+    process.stderr.write("tamperward: specify --staged, --worktree, or --diff <base>...<head>\n");
+    return 2;
+  }
+  const ignoredFiles = changes.filter((c) => isSuppressed(c, policy)).length;
+  let findings = evaluate(changes, policy);
+  const { findings: remaining, cleared } = layer === "local" ? applyLocalSignoffs(findings, cwd, policy) : applyOobSignoffs(findings, oobFromEnv());
+  findings = remaining;
+  if (cleared.length) {
+    const how = layer === "local" ? "local human sign-off (ledger)" : "out-of-band approval";
+    process.stderr.write(`tamperward: ${cleared.length} blocking finding(s) cleared by ${how}: ${cleared.map((f) => f.rule + (f.file ? `(${f.file})` : "")).join(", ")}
+`);
+  }
+  report({ findings, scanned: changes.length, ignoredFiles, json: opts.json });
+  return hasBlocking(findings) ? 1 : 0;
+}
+function runCheck(opts) {
+  try {
+    return check(opts);
+  } catch (e) {
+    if (e instanceof PolicyError) {
+      process.stderr.write(`tamperward: ${e.message}
+`);
+      return 2;
+    }
+    throw e;
+  }
+}
+
+// src/cli/hook.ts
+import { readFileSync as readFileSync6, appendFileSync as appendFileSync2 } from "node:fs";
+
+// src/adapters/claude/changes.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { readFileSync as readFileSync4, existsSync as existsSync3, writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join4, isAbsolute } from "node:path";
+function asStr(v) {
+  return typeof v === "string" ? v : "";
+}
+function readDisk(path) {
+  try {
+    return existsSync3(path) ? readFileSync4(path, "utf8") : null;
+  } catch {
+    return null;
+  }
+}
+function abs(path, cwd) {
+  return isAbsolute(path) ? path : join4(cwd, path);
+}
+function relForDisplay(path, cwd) {
+  return path.startsWith(cwd + "/") ? path.slice(cwd.length + 1) : path;
+}
+function applyEdit(content, oldStr, newStr) {
+  if (content === null) return newStr;
+  return content.replace(oldStr, () => newStr);
+}
+function synthFileChange(displayPath, before, after) {
+  if (before === after) return [];
+  let op;
+  if (before === null) op = "add";
+  else if (after === null) op = "delete";
+  else op = "modify";
+  const dir = mkdtempSync(join4(tmpdir(), "hf-"));
+  let raw = "";
+  try {
+    const a = join4(dir, "a");
+    const b = join4(dir, "b");
+    writeFileSync(a, before ?? "");
+    writeFileSync(b, after ?? "");
+    try {
+      raw = execFileSync2("git", ["diff", "--no-index", "--no-color", a, b], { encoding: "utf8" });
+    } catch (e) {
+      const err = e;
+      raw = err.stdout ? String(err.stdout) : "";
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  const first = parseDiff(raw)[0];
+  const hunks = first && first.kind === "file" ? first.hunks : [];
+  return [{ kind: "file", path: displayPath, oldPath: null, op, before, after, binary: false, hunks }];
+}
+function changesFromClaudeHook(input, cwd) {
+  const ti = input.tool_input ?? {};
+  switch (input.tool_name) {
+    case "Bash": {
+      const raw = asStr(ti.command);
+      return raw ? [{ kind: "command", raw, argv: raw.split(/\s+/) }] : [];
+    }
+    case "Write": {
+      const fp = asStr(ti.file_path);
+      if (!fp) return [];
+      const before = readDisk(abs(fp, cwd));
+      return synthFileChange(relForDisplay(abs(fp, cwd), cwd), before, asStr(ti.content));
+    }
+    case "Edit": {
+      const fp = asStr(ti.file_path);
+      if (!fp) return [];
+      const before = readDisk(abs(fp, cwd));
+      const after = applyEdit(before, asStr(ti.old_string), asStr(ti.new_string));
+      return synthFileChange(relForDisplay(abs(fp, cwd), cwd), before, after);
+    }
+    case "MultiEdit": {
+      const fp = asStr(ti.file_path);
+      if (!fp) return [];
+      const before = readDisk(abs(fp, cwd));
+      let after = before;
+      const edits = Array.isArray(ti.edits) ? ti.edits : [];
+      for (const raw of edits) {
+        const ed = raw;
+        after = applyEdit(after, ed.old_string ?? "", ed.new_string ?? "");
+      }
+      return synthFileChange(relForDisplay(abs(fp, cwd), cwd), before, after);
+    }
+    case "NotebookEdit": {
+      const fp = asStr(ti.notebook_path);
+      const src = asStr(ti.new_source);
+      if (!fp || !src) return [];
+      return synthFileChange(relForDisplay(abs(fp, cwd), cwd), "", src);
+    }
+    default:
+      return [];
+  }
+}
+
+// src/adapters/claude/deny.ts
+function formatDenial(blocks) {
+  const lead = blocks[0];
+  const lines = ["Tamperward blocked this change \u2014 it weakens a protected safety net to pass checks.", ""];
+  for (const f of blocks) {
+    const loc = f.file ? ` (${f.file}${f.line ? `:${f.line}` : ""})` : "";
+    lines.push(`  \u2022 ${f.rule}${loc}: ${f.message}`);
+  }
+  lines.push("");
+  lines.push(`Fix the underlying failure in the code under test, not the safety net. ${lead.remediation}`);
+  lines.push(
+    "The other shortcuts are blocked too: skipping the hooks, editing the hook or CI workflow, lowering the coverage gate, and rewriting a protected file from the shell will each be denied."
+  );
+  if (blocks.some((b) => b.signoff.required)) {
+    lines.push(`If this change is genuinely correct, a human must sign off: ${lead.signoff.command}`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/session.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join5 } 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 join5(gd, "tamperward", `session-${sessionId.replace(UNSAFE, "")}`);
+}
+function turnBaseline(cwd, sessionId) {
+  if (!sessionId) return null;
+  try {
+    const p = baselinePath(cwd, sessionId);
+    if (!p) return null;
+    if (existsSync4(p)) {
+      const v = readFileSync5(p, "utf8").trim();
+      if (SHA.test(v)) return v;
+    }
+    const head = headSha(cwd);
+    if (!head) return null;
+    mkdirSync2(dirname2(p), { recursive: true });
+    writeFileSync2(p, head);
+    return head;
+  } catch {
+    return null;
+  }
+}
+function advanceTurnBaseline(cwd, sessionId) {
+  if (!sessionId) return;
+  try {
+    const p = baselinePath(cwd, sessionId);
+    const head = headSha(cwd);
+    if (!p || !head) return;
+    mkdirSync2(dirname2(p), { recursive: true });
+    writeFileSync2(p, head);
+  } catch {
+  }
+}
+
+// src/cli/hook.ts
+function readStdin() {
+  try {
+    return readFileSync6(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+function parseInput(raw) {
+  if (!raw.trim()) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function recordDenylog(blocks) {
+  const log = process.env.TAMPERWARD_DENYLOG;
+  if (!log) return;
+  try {
+    appendFileSync2(log, blocks.map((b) => b.rule).join(",") + "\n");
+  } catch {
+  }
+}
+function errText(e) {
+  const m = e instanceof Error ? e.message : String(e);
+  return m.length > 200 ? m.slice(0, 200) + "\u2026" : m;
+}
+function failClosed(kind, detail) {
+  const f = {
+    rule: "tamperward-unavailable",
+    severity: "block",
+    message: `Tamperward could not evaluate this change (${detail}), so it is denied rather than allowed.`,
+    evidence: detail,
+    remediation: "Repair the Tamperward setup \u2014 most often an unparseable .tamperward.yml (check for merge-conflict markers) \u2014 then retry. Do not work around the gate while it is down.",
+    signoff: { required: true, command: 'tamperward allow --reason "..."' }
+  };
+  return verdict([f], kind);
+}
+function verdict(blocks, kind) {
+  if (blocks.length === 0) return { exitCode: 0, stdout: "" };
+  recordDenylog(blocks);
+  const reason = formatDenial(blocks);
+  const payload = kind === "PreToolUse" ? {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: reason
+    }
+  } : { decision: "block", reason };
+  return { exitCode: 0, stdout: JSON.stringify(payload) + "\n" };
+}
+function preToolUseVerdict(input) {
+  try {
+    const cwd = input.cwd ?? process.cwd();
+    turnBaseline(cwd, input.session_id);
+    const changes = changesFromClaudeHook(input, cwd);
+    const blocks = evaluate(changes, loadPolicy(cwd)).filter((f) => f.severity === "block");
+    return verdict(blocks, "PreToolUse");
+  } catch (e) {
+    return failClosed("PreToolUse", errText(e));
+  }
+}
+function stopVerdict(input) {
+  if (input.stop_hook_active) return { exitCode: 0, stdout: "" };
+  const cwd = input.cwd ?? process.cwd();
+  if (!isGitRepo(cwd)) return { exitCode: 0, stdout: "" };
+  let blocks;
+  try {
+    const base = turnBaseline(cwd, input.session_id);
+    const changes = base ? diffSince(base, { cwd }) : diffWorktree({ cwd });
+    blocks = evaluate(changes, loadPolicy(cwd)).filter((f) => f.severity === "block");
+  } catch (e) {
+    return failClosed("Stop", errText(e));
+  }
+  if (blocks.length === 0) advanceTurnBaseline(cwd, input.session_id);
+  return verdict(blocks, "Stop");
+}
+function emit(r) {
+  if (r.stdout) process.stdout.write(r.stdout);
+  return r.exitCode;
+}
+function runHookClaude() {
+  try {
+    return emit(preToolUseVerdict(parseInput(readStdin())));
+  } catch (e) {
+    return emit(failClosed("PreToolUse", errText(e)));
+  }
+}
+function runSweepClaude() {
+  try {
+    return emit(stopVerdict(parseInput(readStdin())));
+  } catch (e) {
+    return emit(failClosed("Stop", errText(e)));
+  }
+}
+
+// src/cli/allow.ts
+function runAllow(opts) {
+  if (!opts.rule) {
+    process.stderr.write('tamperward allow <rule> [--file <path>] --reason "<why>"\n');
+    return 2;
+  }
+  if (!opts.reason) {
+    process.stderr.write("tamperward: a --reason is required \u2014 sign-offs must be justified.\n");
+    return 2;
+  }
+  const cwd = opts.cwd ?? process.cwd();
+  const policy = loadPolicy(cwd);
+  let findings;
+  try {
+    findings = evaluate(diffWorktree({ cwd }), policy);
+  } catch {
+    process.stderr.write("tamperward: cannot read the working tree (not a git repo?).\n");
+    return 2;
+  }
+  const targets = findings.filter(
+    (f) => f.severity === "block" && f.rule === opts.rule && (!opts.file || f.file === opts.file)
+  );
+  if (targets.length === 0) {
+    process.stderr.write(
+      `tamperward: no current blocking "${opts.rule}"${opts.file ? ` (${opts.file})` : ""} finding to sign off \u2014 nothing recorded.
+A sign-off must clear a specific tamper that the gate is currently flagging.
+`
+    );
+    return 2;
+  }
+  const now = Date.now();
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of targets) {
+    const fp = fingerprintOf(f);
+    if (seen.has(fp)) continue;
+    seen.add(fp);
+    appendEntry(cwd, policy, makeEntry(f, opts.reason, now));
+  }
+  process.stdout.write(
+    `Recorded ${seen.size} human sign-off(s) for ${opts.rule}${opts.file ? ` (${opts.file})` : ""}, bound to the current tamper (expires in 30 days).
+Honored at LOCAL pre-commit only. The agent-layer hook ignores this file; CI requires an out-of-band approval, never a committed entry.
+`
+  );
+  return 0;
+}
+
+// src/cli/index.ts
+function parseAllow(args) {
+  const o = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--file") o.file = args[++i];
+    else if (a === "--reason") o.reason = args[++i];
+    else if (a === "--cwd") o.cwd = args[++i];
+    else if (!a.startsWith("--") && !o.rule) o.rule = a;
+  }
+  return o;
+}
+function runAgentCommand(kind, args) {
+  const agent = args[0];
+  if (agent !== "claude") {
+    process.stderr.write(`tamperward: unsupported ${kind} agent "${agent ?? ""}" (only "claude" so far)
+`);
+    return 2;
+  }
+  return kind === "hook" ? runHookClaude() : runSweepClaude();
+}
+function parseCheck(args) {
+  const o = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--staged") o.staged = true;
+    else if (a === "--worktree") o.worktree = true;
+    else if (a === "--json") o.json = true;
+    else if (a === "--diff") o.diff = args[++i];
+    else if (a === "--cwd") o.cwd = args[++i];
+    else {
+      process.stderr.write(`tamperward: unknown flag "${a}"
+`);
+    }
+  }
+  return o;
+}
+function printHelp() {
+  process.stdout.write(`tamperward \u2014 the deterministic agent-integrity gate
+
+Usage:
+  tamperward check --staged                 check staged changes (pre-commit)
+  tamperward check --worktree               check working-tree changes (stop sweep)
+  tamperward check --diff <base>...<head>   check a commit range (CI authority)
+  tamperward check ... --json               machine-readable output
+  tamperward hook claude                    PreToolUse gate (reads hook JSON on stdin)
+  tamperward sweep claude                   Stop sweep (re-scan the turn's working tree)
+  tamperward allow <rule> --reason "..."    record a human sign-off (local audit ledger)
+
+Exit code: check \u2192 1 if any blocking finding. hook/sweep \u2192 always 0; a deny is
+           emitted as JSON on stdout (exit 2 makes Claude Code ignore the JSON).
+`);
+}
+function main(argv) {
+  const [cmd, ...rest] = argv;
+  switch (cmd) {
+    case "check":
+      return runCheck(parseCheck(rest));
+    case "hook":
+      return runAgentCommand("hook", rest);
+    case "sweep":
+      return runAgentCommand("sweep", rest);
+    case "allow":
+      return runAllow(parseAllow(rest));
+    case void 0:
+    case "-h":
+    case "--help":
+      printHelp();
+      return 0;
+    default:
+      process.stderr.write(`tamperward: unknown command "${cmd}"
+`);
+      printHelp();
+      return 2;
+  }
+}
+process.exit(main(process.argv.slice(2)));