tamperward 1.8.0 → 1.10.0

package/dist/cli/index.js

@@ -153,7 +153,7 @@ function parseHunk(lines, start) {
   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 = [];
+  const out2 = [];
   let oldLine = oldStart;
   let newLine = newStart;
   let i = start + 1;
@@ -164,20 +164,20 @@ function parseHunk(lines, start) {
     const tag = l[0];
     const content = l.slice(1);
     if (tag === "+") {
-      out.push({ type: "add", content, oldLine: null, newLine });
+      out2.push({ type: "add", content, oldLine: null, newLine });
       newLine++;
     } else if (tag === "-") {
-      out.push({ type: "del", content, oldLine, newLine: null });
+      out2.push({ type: "del", content, oldLine, newLine: null });
       oldLine++;
     } else if (tag === " ") {
-      out.push({ type: "context", content, oldLine, newLine });
+      out2.push({ type: "context", content, oldLine, newLine });
       oldLine++;
       newLine++;
     } else {
       break;
     }
   }
-  return { hunk: { oldStart, oldLines, newStart, newLines, lines: out }, next: i };
+  return { hunk: { oldStart, oldLines, newStart, newLines, lines: out2 }, next: i };
 }
 
 // src/git/build.ts
@@ -190,9 +190,9 @@ function git(args, cwd) {
       stdio: ["ignore", "pipe", "pipe"]
     });
   } catch (e) {
-    const err = e;
-    const detail = String(err.stderr ?? "").trim();
-    throw new Error(detail ? `git ${args[0]}: ${detail}` : err.message ?? `git ${args[0]} failed`);
+    const err2 = e;
+    const detail = String(err2.stderr ?? "").trim();
+    throw new Error(detail ? `git ${args[0]}: ${detail}` : err2.message ?? `git ${args[0]} failed`);
   }
 }
 function blobAt(rev, path, cwd) {
@@ -324,7 +324,7 @@ var noVerify = {
   surface: ["command"],
   certainty: "mechanical",
   run(changes, policy) {
-    const out = [];
+    const out2 = [];
     for (const c of changes) {
       if (c.kind !== "command") continue;
       for (const seg of segments(c.raw)) {
@@ -341,7 +341,7 @@ var noVerify = {
           }
         }
         if (why) {
-          out.push(
+          out2.push(
             makeFinding(RULE, policy, {
               message: `Command bypasses git hooks: ${why}.`,
               evidence: seg,
@@ -351,7 +351,7 @@ var noVerify = {
         }
       }
     }
-    return out;
+    return out2;
   }
 };
 
@@ -373,13 +373,13 @@ import picomatch from "picomatch";
 var POLICY_FILE = ".tamperward.yml";
 var BLOCK_SINCE = {};
 function applyVersionGates(rules, version, gates = BLOCK_SINCE) {
-  const out = { ...rules };
+  const out2 = { ...rules };
   for (const [rule, since] of Object.entries(gates)) {
-    if (since > version && out[rule]?.severity === "block") {
-      out[rule] = { ...out[rule], severity: "warn" };
+    if (since > version && out2[rule]?.severity === "block") {
+      out2[rule] = { ...out2[rule], severity: "warn" };
     }
   }
-  return out;
+  return out2;
 }
 var cache = /* @__PURE__ */ new Map();
 function matcher(glob) {
@@ -410,12 +410,12 @@ function isIgnored(path, policy) {
   return matchesAny(path, policy.ignore);
 }
 function mergeProtected(base, user) {
-  const out = { ...base };
+  const out2 = { ...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))];
+    const have = new Set(out2[cat] ?? []);
+    out2[cat] = [...out2[cat] ?? [], ...(globs ?? []).filter((g) => !have.has(g))];
   }
-  return out;
+  return out2;
 }
 function defaultPolicy(version = 1) {
   const p = {
@@ -522,7 +522,7 @@ var tsAnyCast = {
   surface: ["file"],
   certainty: "mechanical",
   run(changes, policy) {
-    const out = [];
+    const out2 = [];
     for (const c of changes) {
       if (c.kind !== "file" || !isCodeFile(c.path)) continue;
       const inTest = protectedCategory(c.path, policy) === "tests";
@@ -539,7 +539,7 @@ var tsAnyCast = {
         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(
+          out2.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("; ")}.`,
@@ -550,7 +550,7 @@ var tsAnyCast = {
           );
         }
         if (dBroad > 0) {
-          out.push(
+          out2.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>).`,
@@ -564,7 +564,7 @@ var tsAnyCast = {
       }
       for (const l of addedLines(c)) {
         if (NARROW_LINE.test(l.content)) {
-          out.push(
+          out2.push(
             makeFinding(inTest ? WARN_RULE : BLOCK_RULE, policy, {
               file: c.path,
               line: l.newLine ?? void 0,
@@ -575,7 +575,7 @@ var tsAnyCast = {
             })
           );
         } else if (BROAD_LINE.test(l.content)) {
-          out.push(
+          out2.push(
             makeFinding(WARN_RULE, policy, {
               file: c.path,
               line: l.newLine ?? void 0,
@@ -588,7 +588,7 @@ var tsAnyCast = {
         }
       }
     }
-    return out;
+    return out2;
   }
 };
 
@@ -604,13 +604,13 @@ var lintSuppression = {
   surface: ["file"],
   certainty: "mechanical",
   run(changes, policy) {
-    const out = [];
+    const out2 = [];
     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(
+            out2.push(
               makeFinding(RULE2, policy, {
                 file: c.path,
                 line: l.newLine ?? void 0,
@@ -624,7 +624,7 @@ var lintSuppression = {
         }
       }
     }
-    return out;
+    return out2;
   }
 };
 
@@ -647,14 +647,14 @@ var testSkip = {
   surface: ["file"],
   certainty: "mechanical",
   run(changes, policy) {
-    const out = [];
+    const out2 = [];
     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(
+            out2.push(
               makeFinding(RULE3, policy, {
                 file: c.path,
                 line: l.newLine ?? void 0,
@@ -668,7 +668,7 @@ var testSkip = {
         }
       }
     }
-    return out;
+    return out2;
   }
 };
 
@@ -691,7 +691,7 @@ function numericOf(e) {
 }
 function metricsOf(obj) {
   if (!ts2.isObjectLiteralExpression(obj)) return void 0;
-  const out = {};
+  const out2 = {};
   let any = false;
   for (const p of obj.properties) {
     if (!ts2.isPropertyAssignment(p)) continue;
@@ -699,10 +699,10 @@ function metricsOf(obj) {
     if (k === null || !isMetric(k)) continue;
     const n = numericOf(p.initializer);
     if (n === void 0) continue;
-    out[k] = n;
+    out2[k] = n;
     any = true;
   }
-  return any ? out : void 0;
+  return any ? out2 : void 0;
 }
 function underCoverageKey(node) {
   for (let p = node.parent; p; p = p.parent) {
@@ -744,41 +744,41 @@ function parseThresholds(src) {
   return res;
 }
 var eff = (t, path) => t.paths.get(norm(path)) ?? t.global;
-function compareMetrics(scope, before, after, out) {
+function compareMetrics(scope, before, after, out2) {
   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}`);
+    if (av === void 0) out2.push(`${scope} ${m} threshold removed (was ${bv})`);
+    else if (av < bv) out2.push(`${scope} ${m} threshold lowered ${bv} \u2192 ${av}`);
   }
 }
 function weakenings(before, after) {
-  const out = [];
+  const out2 = [];
   if (before.present && !after.present) {
-    out.push("the coverage threshold gate was removed");
-    return out;
+    out2.push("the coverage threshold gate was removed");
+    return out2;
   }
-  compareMetrics("global", before.global, after.global, out);
+  compareMetrics("global", before.global, after.global, out2);
   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);
+    compareMetrics(`required coverage for ${p}:`, eff(before, p), eff(after, p), out2);
   }
-  return out;
+  return out2;
 }
 var coverageLowering = {
   id: RULE4,
   surface: ["file"],
   certainty: "mechanical",
   run(changes, policy) {
-    const out = [];
+    const out2 = [];
     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(
+          out2.push(
             makeFinding(RULE4, policy, {
               file: c.path,
               message: `Coverage gate weakened: ${reason}.`,
@@ -789,7 +789,7 @@ var coverageLowering = {
         }
       } else if (c.op === "delete" || c.after === "" && (c.before ?? "").length > 0) {
         if (parseThresholds(c.before ?? "").present) {
-          out.push(
+          out2.push(
             makeFinding(RULE4, policy, {
               file: c.path,
               message: "Coverage gate weakened: the coverage config was deleted.",
@@ -803,7 +803,7 @@ var coverageLowering = {
       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(
+        out2.push(
           makeFinding(RULE4, policy, {
             file: c.path,
             message: "The --coverage flag was removed from a test script.",
@@ -814,7 +814,7 @@ var coverageLowering = {
       }
       for (const l of added) {
         if (/--passWithNoTests\b/.test(l.content)) {
-          out.push(
+          out2.push(
             makeFinding(RULE4, policy, {
               file: c.path,
               line: l.newLine ?? void 0,
@@ -837,7 +837,7 @@ var coverageLowering = {
           if (!m) continue;
           const ov = oldNums.get(m[1]);
           if (ov !== void 0 && Number(m[2]) < ov) {
-            out.push(
+            out2.push(
               makeFinding(RULE4, policy, {
                 file: c.path,
                 line: l.newLine ?? void 0,
@@ -851,7 +851,7 @@ var coverageLowering = {
       }
     }
     const seen = /* @__PURE__ */ new Set();
-    return out.filter((f) => {
+    return out2.filter((f) => {
       const k = `${f.rule}|${f.message}`;
       if (seen.has(k)) return false;
       seen.add(k);
@@ -894,7 +894,7 @@ var ciTampering = {
   surface: ["file"],
   certainty: "mechanical",
   run(changes, policy) {
-    const out = [];
+    const out2 = [];
     for (const c of changes) {
       if (c.kind !== "file") continue;
       if (!isProtected(c.path, policy, "ci")) continue;
@@ -902,7 +902,7 @@ var ciTampering = {
         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(
+          out2.push(
             makeFinding(RULE5, policy, {
               file: c.path,
               line: l.newLine ?? void 0,
@@ -912,7 +912,7 @@ var ciTampering = {
             })
           );
         } else if (cond && isAlwaysFalse(cond[1])) {
-          out.push(
+          out2.push(
             makeFinding(RULE5, policy, {
               file: c.path,
               line: l.newLine ?? void 0,
@@ -931,7 +931,7 @@ var ciTampering = {
         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;
         if (afterCores.has(commandCore(l.content))) continue;
-        out.push(
+        out2.push(
           makeFinding(RULE5, policy, {
             file: c.path,
             message: isUsesLine ? "A CI check step (test/lint/typecheck) was removed." : "A CI check command was removed from a run block.",
@@ -941,7 +941,7 @@ var ciTampering = {
         );
       }
     }
-    return out;
+    return out2;
   }
 };
 
@@ -1014,6 +1014,24 @@ function policyWeakening(before, after) {
   if (be.requiredFor.includes("block") && !new Set(ae.requiredFor).has("block")) {
     reasons.push("sign-off no longer required for blocking findings");
   }
+  const bv = b.verify;
+  const av = a.verify;
+  if (bv?.command) {
+    if (!av?.command) {
+      reasons.push("verify block removed \u2014 pristine-suite re-execution disabled");
+    } else {
+      if (av.command !== bv.command) {
+        reasons.push(
+          `verify.command changed ("${bv.command}" \u2192 "${av.command}") \u2014 the re-executed suite is no longer the one that was configured`
+        );
+      }
+      const bb = bv.budget ?? 300;
+      const ab = av.budget ?? 300;
+      if (ab < bb) {
+        reasons.push(`verify.budget lowered ${bb}s \u2192 ${ab}s \u2014 starving the budget turns "cannot verify" into a pressure point`);
+      }
+    }
+  }
   return reasons;
 }
 
@@ -1026,13 +1044,13 @@ var hookTampering = {
   surface: ["file", "command"],
   certainty: "mechanical",
   run(changes, policy) {
-    const out = [];
+    const out2 = [];
     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(
+          out2.push(
             makeFinding(RULE6, policy, {
               file: c.path,
               message: "A protected hook/policy file was deleted.",
@@ -1041,7 +1059,7 @@ var hookTampering = {
             })
           );
         } else if (c.op === "rename") {
-          out.push(
+          out2.push(
             makeFinding(RULE6, policy, {
               file: c.path,
               message: `A protected hook/policy file was renamed (${c.oldPath} \u2192 ${c.path}).`,
@@ -1051,7 +1069,7 @@ var hookTampering = {
           );
         } 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(
+            out2.push(
               makeFinding(RULE6, policy, {
                 file: c.path,
                 message: `The policy was weakened: ${reason}.`,
@@ -1066,7 +1084,7 @@ var hookTampering = {
           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(
+            out2.push(
               makeFinding(RULE6, policy, {
                 file: c.path,
                 line: earlyExit.newLine ?? void 0,
@@ -1081,7 +1099,7 @@ var hookTampering = {
             const m = l.content.match(HOOK_INVOCATION);
             if (!m) continue;
             if (live.some((a) => a.content.includes(m[0]))) continue;
-            out.push(
+            out2.push(
               makeFinding(RULE6, policy, {
                 file: c.path,
                 message: `A check invocation (\`${m[0]}\`) was removed from a protected hook.`,
@@ -1101,7 +1119,7 @@ var hookTampering = {
           for (const l of addedLines(c)) {
             const m = l.content.match(INLINE);
             if (m && m[2] === "warn" && removedSeverity.get(m[1]) === "block") {
-              out.push(
+              out2.push(
                 makeFinding(RULE6, policy, {
                   file: c.path,
                   line: l.newLine ?? void 0,
@@ -1111,7 +1129,7 @@ var hookTampering = {
                 })
               );
             } else if (/enabled:\s*false\b/.test(l.content)) {
-              out.push(
+              out2.push(
                 makeFinding(RULE6, policy, {
                   file: c.path,
                   line: l.newLine ?? void 0,
@@ -1140,7 +1158,7 @@ var hookTampering = {
             why = "a shell rewrite (tee/sed/cp/dd/install/mv) replaces a protected hook in place";
           }
           if (why) {
-            out.push(
+            out2.push(
               makeFinding(RULE6, policy, {
                 message: `Hook tampering via shell: ${why}.`,
                 evidence: seg,
@@ -1151,7 +1169,7 @@ var hookTampering = {
         }
       }
     }
-    return out;
+    return out2;
   }
 };
 
@@ -1179,19 +1197,19 @@ function countTestBlocks(src) {
   return n;
 }
 function significantLines(src) {
-  const out = /* @__PURE__ */ new Set();
+  const out2 = /* @__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);
+    if (l.length >= 10 && !/^(import\b|export\s|\/\/|\*|\/\*|}\)?;?$)/.test(l)) out2.add(l);
   }
-  return out;
+  return out2;
 }
 var testDeletion = {
   id: RULE7,
   surface: ["file", "command"],
   certainty: "mechanical",
   run(changes, policy) {
-    const out = [];
+    const out2 = [];
     const addedTestLines = /* @__PURE__ */ new Set();
     let addedTestBlocks = 0;
     for (const c of changes) {
@@ -1212,7 +1230,7 @@ var testDeletion = {
         const isTest = isProtected(c.path, policy, "tests");
         if (c.op === "delete" && isTest) {
           if (c.before != null && isRelocation(c.before)) continue;
-          out.push(
+          out2.push(
             makeFinding(RULE7, policy, {
               file: c.path,
               message: "A test file was deleted.",
@@ -1221,7 +1239,7 @@ var testDeletion = {
             })
           );
         } else if (c.op === "rename" && c.oldPath && isProtected(c.oldPath, policy, "tests") && !isTest) {
-          out.push(
+          out2.push(
             makeFinding(RULE7, policy, {
               file: c.path,
               message: `A test file was renamed out of the test glob (${c.oldPath} \u2192 ${c.path}).`,
@@ -1233,7 +1251,7 @@ var testDeletion = {
           const before = countTestBlocks(c.before);
           const after = countTestBlocks(c.after);
           if (after < before) {
-            out.push(
+            out2.push(
               makeFinding(RULE7, policy, {
                 file: c.path,
                 message: `Test blocks removed: ${before} \u2192 ${after} it()/test() in this spec.`,
@@ -1268,7 +1286,7 @@ var testDeletion = {
             }
           }
           if (why) {
-            out.push(
+            out2.push(
               makeFinding(RULE7, policy, {
                 message: `Test removed via shell: ${why}.`,
                 evidence,
@@ -1279,7 +1297,7 @@ var testDeletion = {
         }
       }
     }
-    return out;
+    return out2;
   }
 };
 
@@ -1288,19 +1306,19 @@ var RULE8 = "test-content-removal";
 var MIN_REMOVED_LINES = 3;
 var ws = (s) => s.replace(/\s+/g, "");
 function significantLinesOrdered(src) {
-  const out = [];
+  const out2 = [];
   for (const raw of src.split("\n")) {
     const l = raw.trim();
-    if (l.length >= 10 && !/^(import\b|export\s|\/\/|\*|\/\*|}\)?;?$)/.test(l)) out.push(l);
+    if (l.length >= 10 && !/^(import\b|export\s|\/\/|\*|\/\*|}\)?;?$)/.test(l)) out2.push(l);
   }
-  return out;
+  return out2;
 }
 var testContentRemoval = {
   id: RULE8,
   surface: ["file"],
   certainty: "mechanical",
   run(changes, policy) {
-    const out = [];
+    const out2 = [];
     let keptPool = "";
     for (const c of changes) {
       if (c.kind === "file" && c.after != null && isProtected(c.path, policy, "tests")) {
@@ -1323,7 +1341,7 @@ var testContentRemoval = {
         gone.push(line);
       }
       if (gone.length >= MIN_REMOVED_LINES && netDrop >= MIN_REMOVED_LINES) {
-        out.push(
+        out2.push(
           makeFinding(RULE8, policy, {
             file: c.path,
             message: `Test content removed from a surviving spec: ${gone.length} significant line(s) gone with no test block deleted.`,
@@ -1333,7 +1351,7 @@ var testContentRemoval = {
         );
       }
     }
-    return out;
+    return out2;
   }
 };
 
@@ -1356,8 +1374,8 @@ var snapshotRewrite = {
   surface: ["command", "file"],
   certainty: "mechanical",
   run(changes, policy) {
-    const out = [];
-    const warn = (input) => out.push(makeFinding(RULE9, policy, { ...input, defaultSeverity: "warn" }));
+    const out2 = [];
+    const warn = (input) => out2.push(makeFinding(RULE9, policy, { ...input, defaultSeverity: "warn" }));
     for (const c of changes) {
       if (c.kind === "command") {
         for (const seg of segments(c.raw)) {
@@ -1390,7 +1408,7 @@ var snapshotRewrite = {
         remediation: "If the intended output genuinely changed, a human should confirm the new expectation against the requirement; if the test was failing, fix the code instead of re-recording the expectation from it."
       });
     }
-    return out;
+    return out2;
   }
 };
 
@@ -1456,18 +1474,18 @@ function activeChanges(changes, policy) {
 }
 function evaluate(changes, policy, detectors = allDetectors, view) {
   const active = activeChanges(changes, policy);
-  const out = [];
+  const out2 = [];
   for (const d of detectors) {
     if (!isEnabled(d.id, policy)) continue;
     try {
-      out.push(...d.run(active, policy, view));
+      out2.push(...d.run(active, policy, view));
     } catch (e) {
       process.stderr.write(`tamperward: detector "${d.id}" errored and was skipped: ${String(e)}
 `);
     }
   }
   const seen = /* @__PURE__ */ new Set();
-  const deduped = out.filter((f) => {
+  const deduped = out2.filter((f) => {
     const k = key(f);
     if (seen.has(k)) return false;
     seen.add(k);
@@ -1511,7 +1529,8 @@ function parsePolicy(raw) {
     signoff: {
       requiredFor: r.signoff?.required_for ?? r.signoff?.requiredFor ?? base.signoff.requiredFor,
       ledger: r.signoff?.ledger ?? base.signoff.ledger
-    }
+    },
+    ...r.verify?.command ? { verify: { command: r.verify.command, budget: r.verify.budget ?? 300 } } : {}
   };
 }
 function parseOrThrow(src, where) {
@@ -1552,16 +1571,16 @@ function ledgerPath(cwd, policy) {
 function readLedger(cwd, policy) {
   const p = ledgerPath(cwd, policy);
   if (!existsSync2(p)) return [];
-  const out = [];
+  const out2 = [];
   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);
+      if (e && typeof e.fingerprint === "string") out2.push(e);
     } catch {
     }
   }
-  return out;
+  return out2;
 }
 function appendEntry(cwd, policy, e) {
   const p = ledgerPath(cwd, policy);
@@ -1620,18 +1639,18 @@ function paint(s, code, on) {
   return on ? code + s + RESET : s;
 }
 function wrap(text, width) {
-  const out = [];
+  const out2 = [];
   let cur = "";
   for (const w of text.split(/\s+/).filter(Boolean)) {
     if (cur === "") cur = w;
     else if (cur.length + 1 + w.length <= width) cur += " " + w;
     else {
-      out.push(cur);
+      out2.push(cur);
       cur = w;
     }
   }
-  if (cur) out.push(cur);
-  return out.length ? out : [""];
+  if (cur) out2.push(cur);
+  return out2.length ? out2 : [""];
 }
 function clip(s, max) {
   const one = s.replace(/\s+/g, " ").trim();
@@ -1663,15 +1682,15 @@ function renderText(input, opts) {
   const blocks = findings.filter((f) => f.severity === "block");
   const warns = findings.filter((f) => f.severity === "warn");
   const c = opts.colour;
-  const out = [];
+  const out2 = [];
   if (findings.length === 0) {
     return `${paint("tamperward: clean", GREEN, c)} \u2014 no integrity findings (${scopePhrase(scanned, ignoredFiles)}).
 `;
   }
   const headColour = blocks.length ? RED : YELLOW;
-  out.push(paint(`tamperward: ${countsPhrase(blocks.length, warns.length)}`, BOLD + headColour, c));
-  out.push(paint(`(${scopePhrase(scanned, ignoredFiles)})`, DIM, c));
-  out.push("");
+  out2.push(paint(`tamperward: ${countsPhrase(blocks.length, warns.length)}`, BOLD + headColour, c));
+  out2.push(paint(`(${scopePhrase(scanned, ignoredFiles)})`, DIM, c));
+  out2.push("");
   const LABEL = "sign-off".length;
   const pad = (k) => (k + " ".repeat(LABEL)).slice(0, LABEL);
   const body = Math.max(20, opts.width - LABEL - 6);
@@ -1679,22 +1698,22 @@ function renderText(input, opts) {
     const isBlock = f.severity === "block";
     const mark = paint(isBlock ? "BLOCK" : "warn ", isBlock ? BOLD + RED : YELLOW, c);
     const loc = f.file ? `${f.file}${f.line ? `:${f.line}` : ""}` : "(command)";
-    out.push(`  ${mark}  ${paint(f.rule, BOLD, c)}  ${paint(loc, DIM, c)}`);
-    for (const l of wrap(f.message, opts.width - 4)) out.push(`    ${l}`);
+    out2.push(`  ${mark}  ${paint(f.rule, BOLD, c)}  ${paint(loc, DIM, c)}`);
+    for (const l of wrap(f.message, opts.width - 4)) out2.push(`    ${l}`);
     const row = (key2, lines) => {
-      lines.forEach((l, i) => out.push(`    ${paint(pad(i === 0 ? key2 : ""), DIM, c)}  ${l}`));
+      lines.forEach((l, i) => out2.push(`    ${paint(pad(i === 0 ? key2 : ""), DIM, c)}  ${l}`));
     };
     row("evidence", [paint(clip(f.evidence, body), DIM, c)]);
     row("instead", wrap(f.remediation, body));
     if (f.signoff.required) row("sign-off", [f.signoff.command]);
-    out.push("");
+    out2.push("");
   }
   if (blocks.length > 0) {
-    out.push(
+    out2.push(
       wrap(SIGNOFF_NOTE, opts.width - 2).map((l) => paint(l, DIM, c)).join("\n")
     );
   }
-  return out.join("\n").replace(/\n+$/, "") + "\n";
+  return out2.join("\n").replace(/\n+$/, "") + "\n";
 }
 
 // src/cli/render/github.ts
@@ -1742,7 +1761,7 @@ function renderSummary(input, env = process.env) {
 No integrity findings (${scope}).
 `;
   }
-  const out = [
+  const out2 = [
     `## Tamperward: ${countsPhrase(blocks.length, warns.length)}`,
     "",
     `${scope}. Every finding below is also annotated on the diff in **Files changed**.`,
@@ -1752,21 +1771,21 @@ No integrity findings (${scope}).
   ];
   for (const f of findings) {
     const sev = f.severity === "block" ? "**BLOCK**" : "warn";
-    out.push(
+    out2.push(
       `| ${sev} | \`${cell(f.rule)}\` | ${locationCell(f, env)} | ${cell(f.message)} | ${cell(f.remediation)} |`
     );
   }
   const needSignoff = findings.filter((f) => f.signoff.required);
   if (needSignoff.length) {
-    out.push("", "### Clearing a blocking finding", "", SIGNOFF_NOTE, "");
+    out2.push("", "### Clearing a blocking finding", "", SIGNOFF_NOTE, "");
     const seen = /* @__PURE__ */ new Set();
     for (const f of needSignoff) {
       if (seen.has(f.signoff.command)) continue;
       seen.add(f.signoff.command);
-      out.push(`- \`${cell(f.signoff.command)}\``);
+      out2.push(`- \`${cell(f.signoff.command)}\``);
     }
   }
-  return out.join("\n") + "\n";
+  return out2.join("\n") + "\n";
 }
 function writeSummary(md, env = process.env) {
   const path = env.GITHUB_STEP_SUMMARY;
@@ -1920,8 +1939,8 @@ function synthFileChange(displayPath, before, 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) : "";
+      const err2 = e;
+      raw = err2.stdout ? String(err2.stdout) : "";
     }
   } finally {
     rmSync(dir, { recursive: true, force: true });
@@ -2055,7 +2074,7 @@ function ptreePath(cwd, sessionId) {
 }
 var sha = (buf) => createHash2("sha256").update(buf).digest("hex").slice(0, 16);
 function snapshotProtected(cwd, policy, prev) {
-  const out = {};
+  const out2 = {};
   const walk = (rel) => {
     const abs2 = rel ? join6(cwd, rel) : cwd;
     let names;
@@ -2077,7 +2096,7 @@ function snapshotProtected(cwd, policy, prev) {
       else if (st.isFile() && isProtected(r, policy)) {
         const p = prev?.[r];
         if (p && p.mtimeMs === st.mtimeMs && p.size === st.size && p.mode === st.mode) {
-          out[r] = p;
+          out2[r] = p;
         } else {
           let hash = "";
           try {
@@ -2085,13 +2104,13 @@ function snapshotProtected(cwd, policy, prev) {
           } catch {
             hash = "unreadable";
           }
-          out[r] = { hash, mode: st.mode, size: st.size, mtimeMs: st.mtimeMs };
+          out2[r] = { hash, mode: st.mode, size: st.size, mtimeMs: st.mtimeMs };
         }
       }
     }
   };
   walk("");
-  return out;
+  return out2;
 }
 function driftBetween(expected, current) {
   const changed = [];
@@ -2218,9 +2237,9 @@ function runWatch(args) {
     else if (args[i] === "--log" && args[i + 1]) log = args[++i];
   }
   const policy = loadPolicy(dir);
-  const out = log ?? defaultEventLog(dir);
-  startWatcher(dir, out, policy);
-  process.stdout.write(`tamperward watch: recording protected-file events under ${dir} -> ${out}
+  const out2 = log ?? defaultEventLog(dir);
+  startWatcher(dir, out2, policy);
+  process.stdout.write(`tamperward watch: recording protected-file events under ${dir} -> ${out2}
 `);
   return -1;
 }
@@ -2255,7 +2274,7 @@ function transientFindings(events, persistentPaths, policy, finalHash) {
     arr.push(e);
     byPath.set(e.path, arr);
   }
-  const out = [];
+  const out2 = [];
   const strict = process.env.TAMPERWARD_TRANSIENT === "block";
   for (const [path, evs] of byPath) {
     if (persistentPaths.has(path)) continue;
@@ -2278,9 +2297,9 @@ function transientFindings(events, persistentPaths, policy, finalHash) {
       f.severity = "block";
       f.signoff.required = true;
     }
-    out.push(f);
+    out2.push(f);
   }
-  return out;
+  return out2;
 }
 
 // src/cli/hook.ts
@@ -2728,6 +2747,241 @@ tamperward init: ${changed} change(s) applied. Commit them so the gate travels w
   return 0;
 }
 
+// src/cli/verify.ts
+import { execFileSync as execFileSync4, spawnSync } from "node:child_process";
+import { chmodSync as chmodSync2, cpSync, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync2, rmSync as rmSync2, statSync as statSync5, symlinkSync, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname as dirname4, join as join9 } from "node:path";
+var OVERLAY_CLASSES = ["tests", "snapshots", "config"];
+function git2(args, cwd) {
+  return execFileSync4("git", args, { cwd, encoding: "utf8", maxBuffer: 1 << 28 });
+}
+function resolveBase(base, cwd) {
+  const rev = git2(["rev-parse", "--verify", `${base}^{commit}`], cwd).trim();
+  try {
+    return git2(["merge-base", rev, "HEAD"], cwd).trim();
+  } catch {
+    return rev;
+  }
+}
+function materialize(cwd, dest) {
+  const listed = git2(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], cwd).split("\0").filter(Boolean);
+  for (const rel of listed) {
+    const src = join9(cwd, rel);
+    let st;
+    try {
+      st = statSync5(src);
+    } catch {
+      continue;
+    }
+    if (!st.isFile()) continue;
+    const out2 = join9(dest, rel);
+    mkdirSync6(dirname4(out2), { recursive: true });
+    cpSync(src, out2);
+    chmodSync2(out2, st.mode);
+  }
+  const nm = join9(cwd, "node_modules");
+  if (existsSync8(nm)) symlinkSync(nm, join9(dest, "node_modules"), "dir");
+}
+function overlayPristine(cwd, base, dest, policy) {
+  const atBase = git2(["ls-tree", "-r", "--name-only", "-z", base], cwd).split("\0").filter(Boolean);
+  const isOverlay = (p) => OVERLAY_CLASSES.some((c) => isProtected(p, policy, c));
+  let restored = 0;
+  const baseProtected = /* @__PURE__ */ new Set();
+  for (const rel of atBase) {
+    if (!isOverlay(rel)) continue;
+    baseProtected.add(rel);
+    const content = execFileSync4("git", ["show", `${base}:${rel}`], { cwd, maxBuffer: 1 << 28 });
+    const out2 = join9(dest, rel);
+    mkdirSync6(dirname4(out2), { recursive: true });
+    writeFileSync6(out2, content);
+    restored++;
+  }
+  let kept = 0;
+  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)) kept++;
+  return [restored, kept];
+}
+function runSuite(dir, cmd, budgetSecs) {
+  const t0 = Date.now();
+  const r = spawnSync("sh", ["-c", cmd], {
+    cwd: dir,
+    stdio: "ignore",
+    timeout: budgetSecs * 1e3,
+    killSignal: "SIGKILL"
+  });
+  const secs = Math.round((Date.now() - t0) / 1e3);
+  if (r.error && r.error.code === "ETIMEDOUT") return { exit: null, secs };
+  if (r.status === null && r.signal) return { exit: null, secs };
+  return { exit: r.status ?? 2, secs };
+}
+function runVerify(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const out2 = (s) => void process.stdout.write(s + "\n");
+  let policy;
+  try {
+    policy = loadPolicy(cwd);
+  } catch (e) {
+    out2(`verify: cannot load policy (${e instanceof Error ? e.message : String(e)}) \u2014 failing closed`);
+    return 2;
+  }
+  const cmd = opts.cmd ?? policy.verify?.command;
+  if (!cmd) {
+    out2("verify: no suite command \u2014 set policy `verify: { command: ... }` or pass --cmd");
+    return 2;
+  }
+  const budget = opts.budget ?? policy.verify?.budget ?? 300;
+  let base;
+  try {
+    base = resolveBase(opts.base ?? "HEAD", cwd);
+  } catch {
+    out2(`verify: cannot resolve base rev "${opts.base ?? "HEAD"}" \u2014 failing closed`);
+    return 2;
+  }
+  const work = mkdtempSync2(join9(tmpdir2(), "tw-verify-"));
+  const visDir = join9(work, "visible");
+  const priDir = join9(work, "pristine");
+  let restored = 0;
+  let kept = 0;
+  try {
+    mkdirSync6(visDir);
+    mkdirSync6(priDir);
+    materialize(cwd, visDir);
+    materialize(cwd, priDir);
+    [restored, kept] = overlayPristine(cwd, base, priDir, policy);
+  } catch (e) {
+    if (!opts.keep) rmSync2(work, { recursive: true, force: true });
+    out2(`verify: could not materialize (${e instanceof Error ? e.message : String(e)}) \u2014 failing closed`);
+    return 2;
+  }
+  const visible = runSuite(visDir, cmd, budget);
+  const pristine = runSuite(priDir, cmd, budget);
+  if (!opts.keep) rmSync2(work, { recursive: true, force: true });
+  let verdict2;
+  let code;
+  if (visible.exit === null || pristine.exit === null) {
+    verdict2 = "BUDGET_EXCEEDED";
+    code = 2;
+  } else if (visible.exit === 0 && pristine.exit === 0) {
+    verdict2 = "VERIFIED";
+    code = 0;
+  } else if (visible.exit === 0) {
+    verdict2 = "MASKED_FAILURE";
+    code = 1;
+  } else {
+    verdict2 = "SUITE_RED";
+    code = 1;
+  }
+  if (opts.json) {
+    out2(
+      JSON.stringify({
+        verdict: verdict2,
+        base,
+        command: cmd,
+        budget_secs: budget,
+        visible: { exit: visible.exit, secs: visible.secs },
+        pristine: { exit: pristine.exit, secs: pristine.secs },
+        protected_restored: restored,
+        added_protected_kept: kept,
+        ...opts.keep ? { workdir: work } : {}
+      })
+    );
+  } else {
+    const lines = {
+      VERIFIED: `verified: the suite passes, and still passes with all ${restored} protected files restored from ${base.slice(0, 10)}.`,
+      MASKED_FAILURE: `MASKED FAILURE: the visible suite passes, but with the ${restored} protected files restored from ${base.slice(0, 10)} it FAILS (exit ${pristine.exit}). Something weakened the checks; the code does not pass the original suite.`,
+      SUITE_RED: `suite red: the visible suite fails (exit ${visible.exit}) \u2014 fix the code first (pristine exit ${pristine.exit}).`,
+      BUDGET_EXCEEDED: `budget exceeded (${budget}s): could not verify \u2014 failing closed, not open.`
+    };
+    out2(`tamperward verify \u2014 ${lines[verdict2]}`);
+    if (kept > 0) out2(`(${kept} protected file(s) added since ${base.slice(0, 10)} were kept in the pristine run.)`);
+  }
+  return code;
+}
+function parseVerify(args) {
+  const o = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--base" && args[i + 1]) o.base = args[++i];
+    else if (a === "--cmd" && args[i + 1]) o.cmd = args[++i];
+    else if (a === "--budget" && args[i + 1]) o.budget = Number(args[++i]);
+    else if (a === "--json") o.json = true;
+    else if (a === "--keep") o.keep = true;
+    else if (a === "--cwd" && args[i + 1]) o.cwd = args[++i];
+  }
+  return o;
+}
+
+// src/cli/run.ts
+import { execFileSync as execFileSync5, spawnSync as spawnSync2 } from "node:child_process";
+var out = (s) => process.stdout.write(s + "\n");
+var err = (s) => process.stderr.write(s + "\n");
+function git3(args, cwd) {
+  return execFileSync5("git", args, { cwd, encoding: "utf8", maxBuffer: 1 << 28 });
+}
+function runEnvelope(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  if (!opts.argv.length) {
+    err("tamperward run: no agent command given (usage: tamperward run [options] -- <command...>)");
+    return 2;
+  }
+  let base;
+  try {
+    base = git3(["rev-parse", "--verify", `${opts.base ?? "HEAD"}^{commit}`], cwd).trim();
+  } catch {
+    err(`tamperward run: cannot resolve trusted base ${opts.base ?? "HEAD"} \u2014 failing closed.`);
+    return 2;
+  }
+  if (!opts.allowDirty) {
+    const dirty = git3(["status", "--porcelain"], cwd).trim();
+    if (dirty) {
+      err("tamperward run: working tree is dirty before the agent starts \u2014 the envelope cannot");
+      err("attribute changes. Commit or stash first, or pass --allow-dirty to own the risk.");
+      return 2;
+    }
+  }
+  out(`tamperward run \u2014 trusted base ${base.slice(0, 10)}; agent exit is untrusted.`);
+  const agent = spawnSync2(opts.argv[0], opts.argv.slice(1), { cwd, stdio: "inherit" });
+  const agentExit = agent.status ?? 1;
+  const head = git3(["rev-parse", "HEAD"], cwd).trim();
+  let diffCode = 0;
+  if (head !== base) {
+    out(`
+[envelope] policy check over committed changes (${base.slice(0, 10)}...${head.slice(0, 10)}):`);
+    diffCode = runCheck({ diff: `${base}...${head}`, cwd });
+  }
+  out("\n[envelope] policy check over the working tree:");
+  const workCode = runCheck({ worktree: true, cwd });
+  out("\n[envelope] pristine verification against the trusted base:");
+  const verifyCode = runVerify({ cwd, base, cmd: opts.cmd, budget: opts.budget });
+  const cannot = diffCode === 2 || workCode === 2 || verifyCode === 2;
+  const blocked = diffCode === 1 || workCode === 1 || verifyCode === 1;
+  const enforcement = cannot ? 2 : blocked ? 1 : 0;
+  const verdict2 = enforcement === 2 ? "CANNOT_ADJUDICATE (fail closed)" : enforcement === 1 ? "ENFORCEMENT_FAILED \u2014 the tree the runtime released does not stand" : agentExit !== 0 ? `agent exited ${agentExit} (enforcement clean)` : "GREEN MEANS GREEN";
+  out(`
+tamperward run \u2014 agent exit ${agentExit}; checks diff=${diffCode} worktree=${workCode} verify=${verifyCode} \u2192 ${verdict2}`);
+  return enforcement !== 0 ? enforcement : agentExit;
+}
+function parseRun(args) {
+  const o = { argv: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--") {
+      o.argv = args.slice(i + 1);
+      break;
+    } else if (a === "--base") o.base = args[++i];
+    else if (a === "--cmd") o.cmd = args[++i];
+    else if (a === "--budget") o.budget = Number(args[++i]);
+    else if (a === "--allow-dirty") o.allowDirty = true;
+    else if (a === "--cwd") o.cwd = args[++i];
+    else {
+      o.argv = args.slice(i);
+      break;
+    }
+  }
+  return o;
+}
+
 // src/cli/index.ts
 function parseAllow(args) {
   const o = {};
@@ -2803,6 +3057,19 @@ Formats:
   tamperward watch [--dir D] [--log F]      filesystem-event observer daemon: records
                                             protected-file events so the sweep can
                                             observe supported transient effects
+  tamperward verify [--base R] [--cmd C]    pristine-suite re-execution: run the suite
+             [--budget S] [--json] [--keep] as-is AND with protected files restored
+                                            from the trusted base; a visible-green /
+                                            pristine-red result is a MASKED FAILURE
+                                            (exit 1); cannot-verify fails closed (2)
+  tamperward run [opts] -- <agent cmd...>   enforcement envelope: record the trusted
+             [--base R] [--cmd C]           base, run the agent, treat its exit as
+             [--budget S] [--allow-dirty]   untrusted, then re-adjudicate the tree it
+                                            left (policy over base...HEAD and the
+                                            worktree, plus verify). Exit: agent's code
+                                            when clean; 1 on any blocking finding or
+                                            masked failure; 2 when it cannot
+                                            adjudicate (fails closed)
   tamperward allow <rule> --reason "..."    record a human sign-off (local audit ledger)
   tamperward init [--dry-run]               wire the policy file plus every
                                             enforcement point: Claude Code hooks,
@@ -2826,6 +3093,10 @@ function main(argv2) {
       return runAllow(parseAllow(rest));
     case "init":
       return runInit(parseInit(rest));
+    case "verify":
+      return runVerify(parseVerify(rest));
+    case "run":
+      return runEnvelope(parseRun(rest));
     case void 0:
     case "-h":
     case "--help":

package/package.json

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