skalpel 4.0.40 → 4.0.42

package/skalpel-setup.mjs

@@ -22,6 +22,7 @@ import { fileURLToPath } from "node:url";
 import { spawn, spawnSync } from "node:child_process";
 import { identity as authIdentity, cliAuthPath } from "./auth.mjs";
 import { isGenuineUserTurn } from "./session-turns.mjs";
+import { appendAdjudication, suppressProof, lastReveal, parseArmToken } from "./insights.mjs";
 
 // CLI (the `skalpel` bin): `skalpel setup [--api https://graph.skalpel.ai]
 // [--user <id>]`, plus `skalpel uninstall` and `skalpel login`. A bare invocation
@@ -65,6 +66,9 @@ const KNOWN_SUBS = new Set([
   "card",
   "ledger",
   "analytics",
+  "verify",
+  "yes",
+  "no",
   "__build",
   "__verify-report",
 ]);
@@ -83,6 +87,8 @@ usage:
   skalpel card [--last|--id <id>] [--md]        share one verified catch: the claim + its own failing proof
   skalpel ledger                                your running tally: N "done"s checked, M verified FALSE
   skalpel analytics                             interactive local analytics — caught lies, measured cost, steers, re-asks
+  skalpel verify on|off|status                  arm/disarm the live catch (re-runs your own proof on a "done" claim)
+  skalpel yes | skalpel no                      was the last catch right? (feeds precision; "no" stops that proof this session)
   skalpel uninstall [--purge]                   remove the hooks + local data from this machine
 
 options:
@@ -157,6 +163,84 @@ function fileCfg() {
 }
 const API = process.env.SKALPEL_API || apiFlag || fileCfg().api || DEFAULT_API;
 
+// writeVerifyConfig(state) — persist the CONSENTED arming for the live catch to ~/.skalpel/client.json.
+// state ∈ { "on", "off" }. On "on" we stamp verify_armed_at (a REAL timestamp) only if not already armed,
+// so re-confirming never resets the honest "armed N days" clock; on "off" we clear it. This is the ONLY
+// writer of the `verify` key; insights.mjs's resolver is the only reader — one key, no drift. Never throws.
+function writeVerifyConfig(state) {
+  const cfgDir = join(homedir(), ".skalpel");
+  const cfgPath = join(cfgDir, "client.json");
+  let cfg = {};
+  try {
+    cfg = JSON.parse(readFileSync(cfgPath, "utf8")) || {};
+  } catch {
+    /* fresh config */
+  }
+  const wasOn = parseArmToken(cfg.verify) === true;
+  cfg.verify = state === "on" ? "on" : "off";
+  if (state === "on") {
+    if (!wasOn || !cfg.verify_armed_at) cfg.verify_armed_at = new Date().toISOString();
+  } else {
+    delete cfg.verify_armed_at;
+  }
+  mkdirSync(cfgDir, { recursive: true });
+  writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+}
+
+// promptVerifyConsent() — the ONE honest consent line at setup. The prompt DEFAULTS TO THE EXISTING
+// SETTING so a setup re-run never silently flips a deliberate choice: a user who ran `skalpel verify off`
+// and re-runs setup + Enter STAYS OFF; unset/on defaults to on (the activation intent). Non-interactive /
+// CI must NOT hang: no TTY → leave the config untouched and return. The copy is accurate, not hype: the
+// re-run is only the session's OWN already-executed command (reconstructed from its Bash tool calls) —
+// never a new class of side effect. Best-effort: never breaks setup.
+// resolveConsentChoice(current, answerRaw) → "on" | "off". The prompt DEFAULTS TO THE EXISTING SETTING so
+// an empty Enter never silently flips a deliberate choice: current "off" → stays off unless explicitly
+// re-enabled (y/yes/on); current "on"/unset → the activation default, on unless declined (n/no/off).
+export function resolveConsentChoice(current, answerRaw) {
+  const defaultOn = parseArmToken(current) !== false; // off → default off; on/unset → default on
+  const t = String(answerRaw || "")
+    .trim()
+    .toLowerCase();
+  if (defaultOn) return t === "n" || t === "no" || t === "off" ? "off" : "on";
+  return t === "y" || t === "yes" || t === "on" ? "on" : "off"; // stays off unless explicitly turned on
+}
+
+async function promptVerifyConsent() {
+  try {
+    const interactive = process.stdin.isTTY && process.stdout.isTTY && !process.env.CI;
+    if (!interactive || process.env.SKALPEL_DEMO || process.env.SKALPEL_SKIP_VERIFY_CONSENT === "1")
+      return; // CI / piped / demo → leave config untouched, never block
+    // Default the prompt to the EXISTING setting: off → Enter keeps off; on/unset → Enter accepts.
+    const current = fileCfg().verify; // "on" | "off" | undefined
+    const defaultOn = parseArmToken(current) !== false;
+    console.log(
+      `   ${B}The live catch${X}\n` +
+        `   ${D}When your agent says "done / tests pass", skalpel re-runs the SAME test/build command\n` +
+        `   it just ran, in the same directory, and shows you the real result. It only ever re-runs\n` +
+        `   your session's own command — never anything new.${X}`,
+    );
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const promptLine = defaultOn ? `[Enter = on · n = off]` : `[Enter = keep off · y = on]`;
+    const ans = await new Promise((res) =>
+      rl.question(`   ${B}${promptLine}${X} `, (a) => {
+        rl.close();
+        res(a);
+      }),
+    );
+    // Resolve against the existing setting so an empty Enter preserves the current choice.
+    const choice = resolveConsentChoice(current, ans);
+    const on = choice === "on";
+    writeVerifyConfig(choice);
+    console.log(
+      on
+        ? `   ${G}✓${X} ${D}Live catch on — it'll re-run your own proof and flag a false "done". ${X}skalpel verify off${D} anytime.${X}\n`
+        : `   ${D}Live catch off. Turn it on anytime with ${X}skalpel verify on${D}.${X}\n`,
+    );
+  } catch {
+    /* consent is best-effort — never break setup */
+  }
+}
+
 // who's signed in — the session saved by the login flow (~/.skalpel/auth.json). Its `uid` keys the
 // hosted graph; `access_token` authenticates the upload. SKALPEL_USER overrides for dev (no token).
 // Uses auth.mjs's REFRESH-CAPABLE identity() so a token that expired since login (Supabase tokens
@@ -933,6 +1017,66 @@ async function main() {
     spawnSync("node", [join(__dir, "verify-shadow.mjs"), "--xray"], { stdio: "inherit" });
     return;
   }
+  // `skalpel verify on|off|status` — the one-command reverse for the live catch. Local, no network, no
+  // sign-in. `on`/`off` persist the consented arming to client.json (the single writer); `status` (and a
+  // bare `skalpel verify`) render the arming + FIELD-PROOF (real fires, adjudicated precision, armed-days,
+  // auto-darken state) — all from real local rows.
+  if (sub === "verify") {
+    const action = (argv[1] || "status").toLowerCase();
+    if (action === "on" || action === "off") {
+      writeVerifyConfig(action);
+      if (action === "on") {
+        console.log(
+          `\n   ${G}✓${X} Live catch ${B}armed${X}. On a "done" claim, skalpel re-runs your session's own\n` +
+            `   test/build once (twice to confirm before any red) and shows the real result.\n` +
+            `   ${D}Reverse anytime: ${X}skalpel verify off${D}  ·  see the field proof: ${X}skalpel verify status\n`,
+        );
+      } else {
+        console.log(
+          `\n   ${G}✓${X} Live catch ${B}off${X}. ${D}Re-arm anytime: ${X}skalpel verify on\n`,
+        );
+      }
+    } else if (action === "status") {
+      spawnSync("node", [join(__dir, "verify-shadow.mjs"), "--status"], { stdio: "inherit" });
+    } else {
+      console.error(`skalpel verify: unknown action \`${argv[1]}\` (use: on | off | status)`);
+      process.exitCode = 2;
+    }
+    return;
+  }
+  // `skalpel yes` / `skalpel no` — ONE-KEY ADJUDICATION of the most-recent catch (the flight recorder).
+  // Local, no network, no sign-in. Appends one NDJSON row keyed to the reveal you just saw; a "no" also
+  // suppresses that exact proof for the rest of THAT session and counts against precision (feeding the
+  // auto-darken kill-switch). Fail-open: nothing to adjudicate → an honest note, never an error.
+  if (sub === "yes" || sub === "no") {
+    const r = lastReveal();
+    if (!r || !r.proof_command) {
+      console.log(
+        `\n   ${D}No recent skalpel catch to adjudicate — nothing has surfaced yet.${X}\n` +
+          `   ${D}When skalpel flags a false "done", it'll say: was this right? ${X}skalpel yes / skalpel no\n`,
+      );
+      return;
+    }
+    const proofShort = String(r.proof_command).slice(0, 60);
+    appendAdjudication({
+      verdict: sub, // "yes" | "no"
+      reveal_ts: r.ts || null,
+      session: r.session || null,
+      proof: r.proof_command,
+    });
+    if (sub === "no") {
+      suppressProof(r.session || null, r.proof_command);
+      console.log(
+        `\n   ${G}✓${X} Marked ${B}not a real catch${X}. ${D}skalpel won't re-accuse ${X}\`${proofShort}\`${D}\n` +
+          `   for the rest of this session, and it counts against precision.${X}\n`,
+      );
+    } else {
+      console.log(
+        `\n   ${G}✓${X} Marked ${B}a real catch${X}. ${D}Thanks — this counts toward precision.${X}\n`,
+      );
+    }
+    return;
+  }
   // Persist --api/--user to ~/.skalpel/client.json so the hooks can read them without shell-env
   // plumbing (env vars SKALPEL_API / SKALPEL_USER still win at hook runtime).
   if (apiFlag || userFlag) {
@@ -971,6 +1115,10 @@ async function main() {
       `   ${G}✓${X} Signed in as ${D}${id.name ? `${id.name} · ${id.email}` : id.email || id.uid}${X}\n`,
     );
 
+  // CONSENT for the live catch (default-accept). One honest line; persisted to client.json. Non-TTY/CI
+  // never blocks (stays default OFF). Reversible anytime with `skalpel verify off`.
+  await promptVerifyConsent();
+
   // 2) find the real coding sessions in the last 30 days (the client reads; the server builds)
   const s1 = spinner(`Looking through your last ${LOOKBACK_DAYS} days of Claude Code + Codex…`);
   await sleep(500);

package/skalpel-statusline.mjs

@@ -30,7 +30,7 @@ import { readFileSync, rmSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { tailLines } from "./transcript.mjs";
-import { cleanText, REVEAL_PATH, VERDICT_PATH, revealEnabled } from "./insights.mjs";
+import { cleanText, REVEAL_PATH, VERDICT_PATH, revealEnabled, autoDarkened } from "./insights.mjs";
 
 const CYAN = "\x1b[36m";
 const GREEN = "\x1b[32m";
@@ -368,9 +368,23 @@ function main() {
   // SKALPEL_VERIFY_REVEAL — when off (the default) this branch never runs and the bar is byte-identical to
   // the always-on baseline below.
   if (revealEnabled(process.env)) {
+    // AUTO-DARKEN kill-switch: once adjudicated precision drops below 90% over >= 10 `skalpel yes|no`
+    // rows, the LIVE red reveal self-pauses and the bar points at the retro `skalpel catches`
+    // (transcript-grounded — it can't flake) until the user re-arms. autoDarkened() is DERIVED from the
+    // real adjudication rows on every render (never a stored flag), so writer + reader can't drift.
+    if (autoDarkened()) {
+      process.stdout.write(
+        `${BOLD}skalpel${RESET} · ${DIM}live catch paused (precision <90%) · run: skalpel catches${RESET}`,
+      );
+      return;
+    }
     const reveal = revealNote(payload.session_id);
     if (reveal) {
-      process.stdout.write(`${BOLD}${reveal}${RESET}`);
+      // The red carries its one-key adjudication pointer — the flight recorder that feeds precision +
+      // the auto-darken kill-switch. A `skalpel no` also suppresses this exact proof for the session.
+      process.stdout.write(
+        `${BOLD}${reveal}${RESET} ${DIM}· was this right? skalpel yes / skalpel no${RESET}`,
+      );
       return;
     }
     const verdict = verdictNote();

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");
+});