skalpel 4.0.41 → 4.0.42

package/verify-core.test.mjs

@@ -0,0 +1,186 @@
+// verify-core.test.mjs — pure-function unit tests for the three CRITICAL-LOGIC functions the mutation
+// harness (mutation-check.mjs) targets: detectCompletionClaim, classifyOutcome, classifyConfirm. These
+// are pure (no fs / no network), so they need no HOME isolation. Every assertion here must be tight enough
+// that flipping a predicate/branch in the function under test makes at least one case fail (survivors = 0).
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  detectCompletionClaim,
+  classifyOutcome,
+  classifyConfirm,
+  hasMutatingFlag,
+  urlResponded,
+  shipUrlPass,
+} from "./verify-shadow.mjs";
+
+test("detectCompletionClaim — fires on real completion claims", () => {
+  for (const s of [
+    "All tests pass now.",
+    "I've fixed the bug.",
+    "Done — build is green.",
+    "lgtm",
+    "everything should work now",
+    "ready to merge",
+  ]) {
+    assert.equal(detectCompletionClaim(s).claim, true, `should claim: ${s}`);
+  }
+});
+
+test("detectCompletionClaim — does NOT fire on non-claims", () => {
+  for (const s of [
+    "Let me run the tests and see.",
+    "This might be broken.",
+    "Can you check whether it works?",
+    "",
+    "   ",
+  ]) {
+    assert.equal(detectCompletionClaim(s).claim, false, `should NOT claim: ${s}`);
+  }
+});
+
+test("detectCompletionClaim — returns the specific claim line, bounded to 120 chars", () => {
+  const r = detectCompletionClaim("Here is a summary.\nAll tests pass.\nMore prose.");
+  assert.equal(r.claim, true);
+  assert.equal(r.text, "All tests pass.");
+  const long = "x ".repeat(200) + "all tests pass";
+  assert.ok(detectCompletionClaim(long).text.length <= 120);
+});
+
+test("classifyOutcome — no error is a PASS", () => {
+  assert.equal(classifyOutcome(null, ""), "PASS");
+  assert.equal(classifyOutcome(undefined, "anything"), "PASS");
+});
+
+test("classifyOutcome — a real non-zero exit is a GENUINE_FAIL", () => {
+  assert.equal(classifyOutcome({ code: 1 }, "2 failed, 3 passed"), "GENUINE_FAIL");
+  assert.equal(
+    classifyOutcome({ code: 2 }, "AssertionError: expected 1 to equal 2"),
+    "GENUINE_FAIL",
+  );
+});
+
+test("classifyOutcome — broken harness is NEVER a lie (HARNESS_ERROR)", () => {
+  assert.equal(classifyOutcome({ killed: true, signal: "SIGTERM" }, "..."), "HARNESS_ERROR"); // timeout
+  assert.equal(classifyOutcome({ code: "ENOENT" }, "..."), "HARNESS_ERROR"); // missing binary/cwd
+  assert.equal(classifyOutcome({ code: 127 }, "..."), "HARNESS_ERROR"); // command not found
+  assert.equal(classifyOutcome({ code: 126 }, "..."), "HARNESS_ERROR"); // not executable
+  assert.equal(classifyOutcome({ code: 1 }, 'npm error Missing script: "test"'), "HARNESS_ERROR");
+  assert.equal(classifyOutcome({ code: 1 }, "bash: pytest: command not found"), "HARNESS_ERROR");
+});
+
+test("classifyConfirm — 2/2 GENUINE_FAIL is the ONLY confirmed catch", () => {
+  const two = classifyConfirm("GENUINE_FAIL", "GENUINE_FAIL");
+  assert.deepEqual(two, { needsConfirm: true, confirmedFail: true, unconfirmedFail: false });
+});
+
+test("classifyConfirm — a single un-reproduced fail is UNCONFIRMED (never a red)", () => {
+  for (const second of ["PASS", "HARNESS_ERROR", "REFUSED", null, undefined]) {
+    const r = classifyConfirm("GENUINE_FAIL", second);
+    assert.equal(r.needsConfirm, true, `needsConfirm for second=${second}`);
+    assert.equal(r.confirmedFail, false, `NOT confirmed for second=${second}`);
+    assert.equal(r.unconfirmedFail, true, `unconfirmed for second=${second}`);
+  }
+});
+
+test("classifyConfirm — a non-fail first run needs no confirm and is never a catch", () => {
+  for (const first of ["PASS", "HARNESS_ERROR", "REFUSED"]) {
+    const r = classifyConfirm(first, "GENUINE_FAIL");
+    assert.deepEqual(
+      r,
+      { needsConfirm: false, confirmedFail: false, unconfirmedFail: false },
+      `first=${first}`,
+    );
+  }
+});
+
+// ---- Fix 2: negation / hedge guard — a negated claim is NOT a completion claim ----
+test("detectCompletionClaim — NEGATED / hedged lines are NOT completion claims (no self-contradicting red)", () => {
+  for (const s of [
+    "not done yet, still working on it",
+    "it isn't done",
+    "this isn't fixed",
+    "won't be fixed in this PR",
+    "not fixed yet",
+    "the tests are still failing",
+    "still broken, needs another pass",
+    "tests are still red",
+    "TODO: implement the parser",
+    "to-do: wire the handler",
+    "almost done",
+    "not quite passing yet",
+    "the build does not pass",
+  ]) {
+    assert.equal(detectCompletionClaim(s).claim, false, `should NOT claim (negated): ${s}`);
+  }
+});
+
+test("detectCompletionClaim — a genuine claim still fires even alongside a negated line", () => {
+  assert.equal(detectCompletionClaim("I've fixed the bug and it works now.").claim, true);
+  const r = detectCompletionClaim("The refactor is done.\nThe auth part is not done yet.");
+  assert.equal(r.claim, true);
+  assert.equal(r.text, "The refactor is done.", "picks the non-negated positive line");
+});
+
+// ---- Fix 3: mutating-flag guard — a proof that rewrites files is refused ----
+test("hasMutatingFlag — flags that REWRITE files are caught", () => {
+  for (const [cmd, args] of [
+    ["eslint", ["--fix"]],
+    ["eslint", ["src", "--fix"]],
+    ["ruff", ["check", "--fix"]],
+    ["ruff", ["format"]],
+    ["ruff", ["format", "app.py"]],
+    ["jest", ["-u"]],
+    ["jest", ["--updateSnapshot"]],
+    ["vitest", ["--update"]],
+    ["vitest", ["-u"]],
+    ["biome", ["check", "--write"]],
+    ["prettier", ["--write", "."]],
+  ]) {
+    assert.equal(hasMutatingFlag(cmd, args), true, `mutating: ${cmd} ${args.join(" ")}`);
+  }
+});
+
+test("hasMutatingFlag — pure verify runs (and pnpm -w) are NOT mutating", () => {
+  for (const [cmd, args] of [
+    ["eslint", ["."]],
+    ["ruff", ["check"]],
+    ["ruff", ["format", "--check"]],
+    ["ruff", ["format", "--diff"]],
+    ["jest", []],
+    ["vitest", ["run"]],
+    ["biome", ["check"]],
+    ["pnpm", ["-w", "test"]], // -w = workspace-root, NOT write
+    ["npm", ["test"]],
+  ]) {
+    assert.equal(hasMutatingFlag(cmd, args), false, `NOT mutating: ${cmd} ${args.join(" ")}`);
+  }
+});
+
+// ---- Fix 1: SHIP-STATUS URL reachability — any HTTP status = live (never a red) ----
+test("shipUrlPass — any HTTP status means REACHABLE/live → NO red", () => {
+  for (const code of [200, 301, 302, 401, 403, 404, 429, 500, 502, 503]) {
+    assert.equal(shipUrlPass(`http_code=${code}`, null), true, `HTTP ${code} → reachable (no red)`);
+  }
+});
+
+test("shipUrlPass — a red requires 2/2 NO-RESPONSE; a single transient blip does not", () => {
+  assert.equal(
+    shipUrlPass("curl error: timeout", "curl error: Could not resolve host"),
+    false,
+    "2/2 no-response → decisive unreachable (red)",
+  );
+  assert.equal(
+    shipUrlPass("curl error: timeout", "http_code=200"),
+    true,
+    "no-response then response → live (no red)",
+  );
+  assert.equal(shipUrlPass("no http code: 000", "no http code: 000"), false, "000 twice → red");
+});
+
+test("urlResponded — http_code=<n> means the server answered; curl errors do not", () => {
+  assert.equal(urlResponded("http_code=503"), true);
+  assert.equal(urlResponded("http_code=200"), true);
+  assert.equal(urlResponded("curl error: timeout"), false);
+  assert.equal(urlResponded("no http code: 000"), false);
+  assert.equal(urlResponded(""), false);
+});

package/verify-integration.test.mjs

@@ -0,0 +1,194 @@
+// verify-integration.test.mjs — END-TO-END proofs that drive the REAL engine: recordVerifyShadow
+// reconstructs the session's own `npm test`, re-runs it for real (execFile, allowlist, 60s cap), and the
+// false-accusation safeguards gate the REAL reveal state file. Also exercises the real `skalpel yes|no`
+// CLI. HOME-isolated (import "./_test-home.mjs" FIRST). Requires `npm` on PATH (present in node:20/22).
+import "./_test-home.mjs";
+import { test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, readFileSync, existsSync, rmSync, mkdirSync } from "node:fs";
+import { tmpdir, homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { recordVerifyShadow } from "./verify-shadow.mjs";
+import { appendAdjudication } from "./insights.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const DIR = join(homedir(), ".skalpel");
+const REVEAL = join(DIR, "verify-reveal.json");
+const LOG = join(DIR, "verify-shadow.log");
+const INSIGHTS = join(DIR, "insights.ndjson");
+const ADJ = join(DIR, "verify-adjudications.ndjson");
+const SUPPRESS = join(DIR, "verify-suppressed.ndjson");
+
+beforeEach(() => {
+  rmSync(DIR, { recursive: true, force: true });
+  mkdirSync(DIR, { recursive: true });
+  process.env.SKALPEL_VERIFY_REVEAL = "1"; // ARMED for these end-to-end tests
+});
+
+// A temp project whose `npm test` outcome we control via a `mode` file + a per-run counter.
+function makeProject(mode) {
+  const p = mkdtempSync(join(tmpdir(), "skalpel-proj-"));
+  writeFileSync(
+    join(p, "package.json"),
+    JSON.stringify({ name: "t", version: "1.0.0", scripts: { test: "node run-test.js" } }),
+  );
+  writeFileSync(
+    join(p, "run-test.js"),
+    `const fs=require("fs");const mode=fs.readFileSync("mode","utf8").trim();
+let n=0;try{n=parseInt(fs.readFileSync("n","utf8"),10)||0;}catch{}
+n++;fs.writeFileSync("n",String(n));
+if(mode==="always_fail"){console.log("assertion failed on run "+n);process.exit(1);}
+if(mode==="flake"){if(n===1){console.log("assertion failed on run "+n);process.exit(1);}console.log("ok "+n);process.exit(0);}
+console.log("ok "+n);process.exit(0);`,
+  );
+  writeFileSync(join(p, "mode"), mode);
+  return p;
+}
+
+// A minimal Claude transcript: a Bash tool_use that ran `npm test`, then an assistant completion claim.
+function writeTranscript(proj, claimText) {
+  const t = join(proj, "transcript.jsonl");
+  const rows = [
+    {
+      type: "assistant",
+      cwd: proj,
+      message: {
+        role: "assistant",
+        content: [{ type: "tool_use", name: "Bash", id: "tool_1", input: { command: "npm test" } }],
+      },
+    },
+    {
+      type: "user",
+      message: {
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: "tool_1", content: "ran" }],
+      },
+    },
+    {
+      type: "assistant",
+      message: { role: "assistant", content: [{ type: "text", text: claimText }] },
+    },
+  ];
+  writeFileSync(t, rows.map((r) => JSON.stringify(r)).join("\n") + "\n");
+  return t;
+}
+
+const lastRow = () => {
+  const ls = readFileSync(LOG, "utf8").trim().split("\n");
+  return JSON.parse(ls[ls.length - 1]);
+};
+const insightKinds = () => {
+  try {
+    return readFileSync(INSIGHTS, "utf8")
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((l) => JSON.parse(l));
+  } catch {
+    return [];
+  }
+};
+
+async function drive(mode, { session, claim }) {
+  rmSync(REVEAL, { force: true });
+  const proj = makeProject(mode);
+  const tp = writeTranscript(proj, claim);
+  await recordVerifyShadow({ transcriptPath: tp, session, cwd: proj });
+  return { revealed: existsSync(REVEAL), row: lastRow() };
+}
+
+test("2/2 flake-confirm — a confirmed fail SURFACES a red", async () => {
+  const r = await drive("always_fail", { session: "s-fail", claim: "All tests pass. Done." });
+  assert.equal(r.revealed, true, "confirmed 2/2 fail → red reveal written");
+  assert.equal(r.row.mismatch, true);
+  assert.equal(r.row.outcome, "GENUINE_FAIL");
+  assert.equal(r.row.confirm_outcome, "GENUINE_FAIL");
+  assert.equal(r.row.unconfirmed_fail, false);
+});
+
+test("2/2 flake-confirm — a single un-reproduced fail NEVER surfaces (flake, logged UNCONFIRMED)", async () => {
+  const r = await drive("flake", { session: "s-flake", claim: "All tests pass now." });
+  assert.equal(r.revealed, false, "1-fail-then-pass → NO red");
+  assert.equal(r.row.mismatch, false);
+  assert.equal(r.row.outcome, "GENUINE_FAIL");
+  assert.equal(r.row.confirm_outcome, "PASS");
+  assert.equal(r.row.unconfirmed_fail, true, "recorded for the instrument, never shown");
+});
+
+test("2/2 flake-confirm — a clean PASS surfaces no red (green verdict path)", async () => {
+  const r = await drive("always_pass", { session: "s-pass", claim: "Done — all green." });
+  assert.equal(r.revealed, false);
+  assert.equal(r.row.outcome, "PASS");
+  assert.equal(r.row.confirm_outcome, null, "no confirm run needed on a pass");
+});
+
+test("suppression — `skalpel no` stops that exact proof re-accusing for the session", async () => {
+  // Run 1: a confirmed fail surfaces the red and logs a shown-reveal row for the CLI to adjudicate.
+  const first = await drive("always_fail", { session: "s1", claim: "All tests pass." });
+  assert.equal(first.revealed, true);
+
+  // The user hits `skalpel no` (the REAL CLI) — appends the adjudication + suppresses (s1, npm test).
+  const no = spawnSync("node", [join(HERE, "skalpel-setup.mjs"), "no"], {
+    env: process.env,
+    encoding: "utf8",
+  });
+  assert.equal(no.status, 0, no.stderr);
+  const adj = readFileSync(ADJ, "utf8").trim();
+  assert.match(adj, /"verdict":"no"/);
+  assert.ok(existsSync(SUPPRESS), "suppress file written");
+  assert.match(readFileSync(SUPPRESS, "utf8"), /npm test/);
+
+  // Run 2: SAME session, a DIFFERENT claim (so it isn't deduped) — still a confirmed 2/2 fail, but the
+  // proof is suppressed → NO new red, and a reveal_suppressed insight explains why.
+  const second = await drive("always_fail", { session: "s1", claim: "The build is green now." });
+  assert.equal(second.row.mismatch, true, "still a real confirmed catch in the instrument");
+  assert.equal(second.revealed, false, "…but suppressed → no red shown");
+  const supp = insightKinds().filter(
+    (i) => i.kind === "reveal_suppressed" && i.reason === "adjudicated_no",
+  );
+  assert.ok(supp.length >= 1, "reveal_suppressed(adjudicated_no) recorded");
+});
+
+test("auto-darken — <90% over >=10 adjudications pauses the LIVE red (falls back to retro)", async () => {
+  // 8 right / 2 wrong = 80% over 10 rows → derived auto-darken = true.
+  for (let i = 0; i < 8; i++) appendAdjudication({ verdict: "yes" });
+  for (let i = 0; i < 2; i++) appendAdjudication({ verdict: "no" });
+
+  const r = await drive("always_fail", { session: "s-dark", claim: "All tests pass." });
+  assert.equal(r.row.mismatch, true, "still a real confirmed catch in the instrument");
+  assert.equal(r.revealed, false, "auto-darkened → no live red");
+  const supp = insightKinds().filter(
+    (i) => i.kind === "reveal_suppressed" && i.reason === "auto_darken",
+  );
+  assert.ok(supp.length >= 1, "reveal_suppressed(auto_darken) recorded");
+});
+
+test("`skalpel yes` — records a real catch toward precision (no suppression)", async () => {
+  await drive("always_fail", { session: "s-yes", claim: "All tests pass." });
+  const yes = spawnSync("node", [join(HERE, "skalpel-setup.mjs"), "yes"], {
+    env: process.env,
+    encoding: "utf8",
+  });
+  assert.equal(yes.status, 0, yes.stderr);
+  assert.match(readFileSync(ADJ, "utf8"), /"verdict":"yes"/);
+  assert.equal(existsSync(SUPPRESS), false, "a `yes` never suppresses");
+});
+
+test("`skalpel no` with nothing to adjudicate is honest, not an error", () => {
+  const no = spawnSync("node", [join(HERE, "skalpel-setup.mjs"), "no"], {
+    env: process.env,
+    encoding: "utf8",
+  });
+  assert.equal(no.status, 0);
+  assert.match(no.stdout, /No recent skalpel catch/i);
+  assert.equal(existsSync(ADJ), false);
+});
+
+test("fail-open — the detached worker never throws on a broken transcript, surfaces nothing", async () => {
+  await assert.doesNotReject(
+    recordVerifyShadow({ transcriptPath: "/no/such/transcript.jsonl", session: "x", cwd: "/tmp" }),
+  );
+  assert.equal(existsSync(REVEAL), false, "no red on a broken input");
+});

package/verify-safeguards.test.mjs

@@ -0,0 +1,178 @@
+// verify-safeguards.test.mjs — the false-accusation safeguards at the derivation level: the arming
+// resolver precedence, the adjudication ledger + <90% auto-darken derivation, and the session-scoped
+// suppression. HOME-isolated (import "./_test-home.mjs" FIRST) so nothing here can read/clobber a real
+// ~/.skalpel. Every function under test is fail-open: a corrupt file must degrade to safe, never throw.
+import "./_test-home.mjs";
+import { test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { rmSync, mkdirSync, writeFileSync, appendFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveConsentChoice } from "./skalpel-setup.mjs";
+import {
+  revealEnabled,
+  verifySpawnArmed,
+  verifyConfigArmed,
+  adjudicationStats,
+  autoDarkened,
+  appendAdjudication,
+  suppressProof,
+  isProofSuppressed,
+  proofSig,
+  appendRevealLog,
+  lastReveal,
+  verifyArmedAt,
+  AUTO_DARKEN_MIN_ADJ,
+  ADJUDICATIONS_PATH,
+  CLIENT_JSON_PATH,
+  SUPPRESS_PATH,
+} from "./insights.mjs";
+
+const DIR = join(homedir(), ".skalpel");
+beforeEach(() => {
+  rmSync(DIR, { recursive: true, force: true });
+  mkdirSync(DIR, { recursive: true });
+  delete process.env.SKALPEL_VERIFY_REVEAL;
+  delete process.env.SKALPEL_VERIFY_SHADOW;
+});
+const writeCfg = (o) => writeFileSync(CLIENT_JSON_PATH, JSON.stringify(o));
+
+// ---- arming resolver precedence: env > config > default off -------------------------------------
+test("arming — default OFF when config absent and env unset", () => {
+  assert.equal(verifyConfigArmed(), null);
+  assert.equal(revealEnabled({}), false);
+  assert.equal(verifySpawnArmed({}), false);
+});
+
+test("arming — consented config on/off", () => {
+  writeCfg({ verify: "on" });
+  assert.equal(revealEnabled({}), true);
+  assert.equal(verifySpawnArmed({}), true);
+  writeCfg({ verify: "off" });
+  assert.equal(revealEnabled({}), false);
+});
+
+test("arming — env override BEATS config in both directions", () => {
+  writeCfg({ verify: "on" });
+  assert.equal(revealEnabled({ SKALPEL_VERIFY_REVEAL: "0" }), false, "env off beats config on");
+  writeCfg({ verify: "off" });
+  assert.equal(revealEnabled({ SKALPEL_VERIFY_REVEAL: "1" }), true, "env on beats config off");
+});
+
+test("arming — SKALPEL_VERIFY_SHADOW arms the spawn but NOT the reveal", () => {
+  writeCfg({});
+  assert.equal(verifySpawnArmed({ SKALPEL_VERIFY_SHADOW: "1" }), true);
+  assert.equal(revealEnabled({ SKALPEL_VERIFY_SHADOW: "1" }), false);
+});
+
+test("arming — fail-open: a corrupt client.json never throws, resolves OFF", () => {
+  writeFileSync(CLIENT_JSON_PATH, "{ this is not json");
+  assert.doesNotThrow(() => revealEnabled({}));
+  assert.equal(verifyConfigArmed(), null);
+  assert.equal(revealEnabled({}), false);
+});
+
+// ---- adjudication ledger + <90% auto-darken derivation ------------------------------------------
+test("adjudicationStats — precision = right/(right+wrong), null when empty", () => {
+  assert.deepEqual(adjudicationStats(), { right: 0, wrong: 0, total: 0, precision: null });
+  for (let i = 0; i < 9; i++) appendAdjudication({ verdict: "yes" });
+  appendAdjudication({ verdict: "no" });
+  const s = adjudicationStats();
+  assert.equal(s.right, 9);
+  assert.equal(s.wrong, 1);
+  assert.equal(s.total, 10);
+  assert.ok(Math.abs(s.precision - 0.9) < 1e-9);
+});
+
+test("auto-darken — needs BOTH >= min adjudications AND precision < 90%", () => {
+  // 8 wrong of 9 → precision high but too few rows → NOT darkened.
+  appendAdjudication({ verdict: "yes" });
+  for (let i = 0; i < 8; i++) appendAdjudication({ verdict: "no" });
+  assert.equal(adjudicationStats().total, 9);
+  assert.equal(autoDarkened(), false, "9 rows < min → not darkened");
+
+  // Exactly 90% over >= min stays LIVE (only strictly below darkens).
+  rmSync(ADJUDICATIONS_PATH, { force: true });
+  for (let i = 0; i < 9; i++) appendAdjudication({ verdict: "yes" });
+  appendAdjudication({ verdict: "no" }); // 9/10 = 90%
+  assert.equal(autoDarkened(), false, "exactly 90% stays live");
+
+  // 8/10 = 80% over >= min → DARKENED.
+  appendAdjudication({ verdict: "no" }); // now 9 yes / 2 no = 81.8%... push below with more no
+  for (let i = 0; i < 2; i++) appendAdjudication({ verdict: "no" }); // 9 yes / 4 no = 69%
+  assert.ok(adjudicationStats().total >= AUTO_DARKEN_MIN_ADJ);
+  assert.ok(adjudicationStats().precision < 0.9);
+  assert.equal(autoDarkened(), true, "below 90% over min → darkened");
+});
+
+test("auto-darken — fail-open: garbage rows never throw, unparseable → safe (not darkened)", () => {
+  appendFileSync(ADJUDICATIONS_PATH, "not json\n{bad\n");
+  assert.doesNotThrow(() => autoDarkened());
+  assert.equal(autoDarkened(), false);
+});
+
+// ---- session-scoped suppression ------------------------------------------------------------------
+test("suppression — a suppressed (session, proof) matches; a different session/proof does NOT", () => {
+  assert.equal(isProofSuppressed("s1", "npm test"), false);
+  suppressProof("s1", "npm test");
+  assert.equal(isProofSuppressed("s1", "npm test"), true, "same session+proof suppressed");
+  assert.equal(isProofSuppressed("s1", "  npm   test  "), true, "whitespace-normalized match");
+  assert.equal(isProofSuppressed("s2", "npm test"), false, "different session NOT suppressed");
+  assert.equal(isProofSuppressed("s1", "pnpm build"), false, "different proof NOT suppressed");
+});
+
+test("suppression — a null/empty session is never suppressed (no over-suppression)", () => {
+  assert.equal(suppressProof(null, "npm test"), false);
+  assert.equal(suppressProof("s1", ""), false);
+  assert.equal(isProofSuppressed(null, "npm test"), false);
+  assert.equal(isProofSuppressed("", "npm test"), false);
+});
+
+test("suppression — fail-open: a corrupt suppress file never throws", () => {
+  writeFileSync(SUPPRESS_PATH, "garbage\n");
+  assert.doesNotThrow(() => isProofSuppressed("s1", "npm test"));
+  assert.equal(isProofSuppressed("s1", "npm test"), false);
+});
+
+test("proofSig — normalizes whitespace and bounds length", () => {
+  assert.equal(proofSig("  npm   test \n"), "npm test");
+  assert.ok(proofSig("x ".repeat(500)).length <= 200);
+});
+
+// ---- reveal log / lastReveal (the row `skalpel yes|no` adjudicates) ------------------------------
+test("lastReveal — returns the most-recent shown reveal, or null when none", () => {
+  assert.equal(lastReveal(), null);
+  appendRevealLog({ session: "s1", proof_command: "npm test", line: "first" });
+  appendRevealLog({ session: "s2", proof_command: "pnpm build", line: "second" });
+  const r = lastReveal();
+  assert.equal(r.session, "s2");
+  assert.equal(r.proof_command, "pnpm build");
+});
+
+// ---- armed-days source (a recorded real timestamp, not a metric) --------------------------------
+test("verifyArmedAt — reads the recorded ISO stamp, null when absent/garbage", () => {
+  assert.equal(verifyArmedAt(), null);
+  const iso = "2026-01-01T00:00:00.000Z";
+  writeCfg({ verify: "on", verify_armed_at: iso });
+  assert.equal(verifyArmedAt().toISOString(), iso);
+  writeCfg({ verify: "on", verify_armed_at: "not-a-date" });
+  assert.equal(verifyArmedAt(), null);
+});
+
+// ---- Fix 4: `verify off` durable against a setup re-run (default = existing setting) ----
+test("consent — an existing OFF is NEVER silently re-armed by a setup Enter", () => {
+  // The deliberate opt-out: Enter (empty) must KEEP it off.
+  assert.equal(resolveConsentChoice("off", ""), "off", "off + Enter stays off");
+  assert.equal(resolveConsentChoice("off", "n"), "off", "off + n stays off");
+  // …but an explicit yes re-arms.
+  assert.equal(resolveConsentChoice("off", "y"), "on", "off + y turns on");
+  assert.equal(resolveConsentChoice("off", "on"), "on");
+});
+
+test("consent — on/unset default to ON (the activation intent), n declines", () => {
+  assert.equal(resolveConsentChoice(undefined, ""), "on", "unset + Enter → on");
+  assert.equal(resolveConsentChoice(null, ""), "on", "null + Enter → on");
+  assert.equal(resolveConsentChoice("on", ""), "on", "on + Enter stays on");
+  assert.equal(resolveConsentChoice("on", "n"), "off", "on + n turns off");
+  assert.equal(resolveConsentChoice("on", "no"), "off");
+});