skalpel 4.0.56 → 4.0.58

package/anchor-shadow.mjs

@@ -505,11 +505,22 @@ function findPushBranch(text) {
   return { remote, branch };
 }
 
-// findTag(text) → a release tag (vX.Y.Z or a `git tag <t>` / `git push origin <t>` mention). Validated.
+// findTag(text) → a release tag, COMMAND-ANCHORED (2026-07-13 false-accusation incident): a git-tag
+// target may ONLY be minted when the tag token appears on a line that is itself a `git tag` / `git push`
+// COMMAND — NEVER scavenged from arbitrary prose/output. A bare `v26.3.1` in quoted `node --version`
+// output once became a "release tag", probed `git ls-remote --tags origin v26.3.1`, and minted a false
+// SHIP_FAIL on a true claim. Implementation: extract ONLY the candidate lines matching
+// /\bgit\s+(?:tag|push)\b/ and run the (unchanged) tag patterns over those lines alone; no such line →
+// no target, ever (→ NO_TARGET, no probe, no accusation). Validation (SHIP_SAFE_REF) unchanged.
 function findTag(text) {
-  const near = /\bgit\s+(?:tag|push[^\n;&|]*?)\s+(v?\d+\.\d+\.\d+[0-9A-Za-z.\-+]*)\b/i.exec(text);
+  const cmdLines = String(text || "")
+    .split(/\r?\n/)
+    .filter((l) => /\bgit\s+(?:tag|push)\b/i.test(l));
+  if (!cmdLines.length) return null; // no git tag/push command anywhere in context → no tag target
+  const cmds = cmdLines.join("\n");
+  const near = /\bgit\s+(?:tag|push[^\n;&|]*?)\s+(v?\d+\.\d+\.\d+[0-9A-Za-z.\-+]*)\b/i.exec(cmds);
   if (near && SHIP_SAFE_REF.test(near[1])) return near[1];
-  const m = /\b(v\d+\.\d+\.\d+[0-9A-Za-z.\-+]*)\b/.exec(text);
+  const m = /\b(v\d+\.\d+\.\d+[0-9A-Za-z.\-+]*)\b/.exec(cmds);
   return m && SHIP_SAFE_REF.test(m[1]) ? m[1] : null;
 }
 

package/eval-harness.mjs

@@ -1127,6 +1127,7 @@ const SHIP_FIXTURES = [
     expectReprobe: true,
   },
   // (d) TRUE CATCH: pushed-claim + sha NOT on the real remote tip → red (it never left the machine).
+  //     Since the all-reds confirm-gate (2026-07-13 incident), even a hard FAIL must confirm 2/2.
   {
     id: "d",
     label: "pushed + sha-not-on-remote → RED",
@@ -1136,8 +1137,9 @@ const SHIP_FIXTURES = [
     exec: gitRemoteExec({ tip: SHA_OLD, ancestor: false }),
     expectOutcome: "SHIP_FAIL",
     expectRed: true,
+    expectReprobe: true,
   },
-  // (e) TRUE CATCH: merged-claim + PR is OPEN → red.
+  // (e) TRUE CATCH: merged-claim + PR is OPEN → red (confirmed 2/2).
   {
     id: "e",
     label: "merged + PR OPEN → RED",
@@ -1147,6 +1149,7 @@ const SHIP_FIXTURES = [
     exec: ghPrExec("OPEN", null),
     expectOutcome: "SHIP_FAIL",
     expectRed: true,
+    expectReprobe: true,
   },
   // (f) TRUE CATCH: live-claim + confirmed 404 × 2 → red (only the double-negative fires).
   {
@@ -1217,7 +1220,7 @@ const SHIP_FIXTURES = [
     expectRed: true,
     expectReprobe: true,
   },
-  // (l) published + NOT on the registry → red (npm view E404).
+  // (l) published + NOT on the registry → red (npm view E404, confirmed 2/2).
   {
     id: "l",
     label: "published + npm E404 → RED",
@@ -1227,6 +1230,7 @@ const SHIP_FIXTURES = [
     exec: npmExec(false, "9.9.9"),
     expectOutcome: "SHIP_FAIL",
     expectRed: true,
+    expectReprobe: true,
   },
   // (m) published + IS on the registry → NO red.
   {
@@ -1239,7 +1243,7 @@ const SHIP_FIXTURES = [
     expectOutcome: "SHIP_OK",
     expectRed: false,
   },
-  // (n) CI green claim + checks FAILING → red.
+  // (n) CI green claim + checks FAILING → red (confirmed 2/2).
   {
     id: "n",
     label: "ci-green + checks failing → RED",
@@ -1249,6 +1253,7 @@ const SHIP_FIXTURES = [
     exec: ghChecksExec([{ bucket: "pass" }, { bucket: "fail" }]),
     expectOutcome: "SHIP_FAIL",
     expectRed: true,
+    expectReprobe: true,
   },
   // (o) CI green claim + checks passing → NO red.
   {
@@ -1261,7 +1266,7 @@ const SHIP_FIXTURES = [
     expectOutcome: "SHIP_OK",
     expectRed: false,
   },
-  // (p) released (git tag) + tag NOT on origin → red.
+  // (p) released (git tag) + tag NOT on origin → red (confirmed 2/2).
   {
     id: "p",
     label: "released tag + missing on origin → RED",
@@ -1271,6 +1276,7 @@ const SHIP_FIXTURES = [
     exec: gitTagExec(false, "v2.0.0"),
     expectOutcome: "SHIP_FAIL",
     expectRed: true,
+    expectReprobe: true,
   },
   // (q) released (git tag) + tag present on origin → NO red.
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skalpel",
-  "version": "4.0.56",
+  "version": "4.0.58",
   "description": "Behavioral graph for AI-assisted coding — learns how you work and steers Claude Code + Codex in real time.",
   "type": "module",
   "bin": {

package/skalpel-statusline.mjs

@@ -9,42 +9,68 @@
 //     that verifiably happened; else
 //   • the current steer's plain-English label (what skalpel is doing now) — a description, not a number;
 //     else
-//   • the ALWAYS-ON presence line, "skalpel · N steers[ · <time clause>]".
-//     N = steers ACTUALLY applied (fired + not suppressed), counted from the append-only
-//     ~/.skalpel/steers.ndjson — a fresh install reads "0 steers", present, never blank. The optional
-//     TIME clause is chosen by BASELINE_TIME_MODE (Ryan flips one constant):
-//       · <Xm> caught — the CUMULATIVE LIFETIME sum of every real MEASURED red→green delta (each caught
-//         false "done" and the moment that SAME proof, that SAME session, was later logged PASS — real
-//         timestamps; reuses ledger.mjs's buildFixDeltas logic). ALWAYS-ON once real catches exist (it is
-//         skalpel's terminal presence — never gated/hidden). A measured total, NEVER an estimate; a catch
-//         with no later PASS adds 0. Cumulative framing (not present-tense) keeps it honest for old data.
-//       · ~Xm saved — Raahil's #609 estimate: (applied steers) × (the user's OWN median loop cost from
-//         their causal graph). A `~`-prefixed ESTIMATE grounded in their own data, shown only when
-//         saved_min > 0. Never a server wall-clock number; never "skalpel saved you X" as a fact.
+//   • the ALWAYS-ON AMBIENT line: the `🔬 skalpel` wordmark, a dim em-dash, then a COMPOSED body of only
+//     the clauses that have real value (see THE INSTRUMENT LINE below). Nothing yet reads
+//     "🔬 skalpel — watching your agent's claims" — present, quiet, never "0 steers".
+//
+// THE INSTRUMENT LINE (redesign, 2026-07-14 — founder: "the bottom of my terminal is ugly, zero
+// aesthetic, zero gratifying feeling" about `skalpel · 0 steers`). Typography + hierarchy, not
+// decoration. The ambient body composes, in order, ONLY the clauses whose value exists:
+//     clean   → "N claims verified[ · Xm caught][ · N steers]"
+//     caught  → "N checked · M false[ · Xm caught][ · N steers]"
+//     nothing → "watching your agent's claims"   (dim — quiet confidence, NOT a dead zero)
+//   · <Xm> caught — the CUMULATIVE LIFETIME sum of every real MEASURED red→green delta (each caught
+//     false "done" and the moment that SAME proof, that SAME session, was later logged PASS — real
+//     timestamps; reuses ledger.mjs's buildFixDeltas logic). A measured total, NEVER an estimate; a
+//     catch with no later PASS adds 0. Cumulative framing (not present-tense) keeps it honest.
+//   · N steers — steers ACTUALLY applied (fired + not suppressed), counted from the append-only
+//     ~/.skalpel/steers.ndjson.
+// IMMUTABLE ALWAYS-ON COUNTER (owner product decision — unchanged in substance): the counter surfaces
+// (`N steers` when > 0, the measured `Xm caught` whenever it has a value) remain ALWAYS-ON on the
+// ambient line — never gated, never hidden. This redesign only removes DEAD ZEROS: a zero-value clause
+// is omitted, and the always-on presence is carried by the wordmark + the watching line instead of a
+// literal "0 steers". "0 steers" never renders again.
+// COLOR DISCIPLINE (Ive restraint): wordmark bold; live numbers cyan; chrome words dim. The skalpel red
+// is ONE accent used ONCE — only on the `M false` clause when lies > 0. Semantic color only.
 // Every value here is a real count or a real measured timestamp delta (or a clearly `~`-marked estimate).
-// NOTE: this always-on presence line is a DELIBERATE new behavior — origin/main's clean-idle bar emitted
-// ZERO bytes; this emits "skalpel · 0 steers" (Ryan: always-on presence, non-negotiable). Byte-identical
-// to origin/main is preserved ONLY for the untouched reveal / verdict / re-ask surfaces, not clean-idle.
+// Byte-identical to origin/main is preserved for the untouched reveal / verdict surfaces.
 // Fail-open: any error → print nothing (or just the presence line), exit 0. Never blocks the bar.
 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, autoDarkened } from "./insights.mjs";
+import {
+  cleanText,
+  REVEAL_PATH,
+  VERDICT_PATH,
+  revealEnabled,
+  autoDarkened,
+  ADJUDICATIONS_PATH,
+  SUPPRESS_PATH,
+  proofSig,
+} from "./insights.mjs";
 
 const CYAN = "\x1b[36m";
 const GREEN = "\x1b[32m";
 const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";
 const RESET = "\x1b[0m";
+// The skalpel red — the ONE accent, used ONCE per line at most (only on `M false` when lies > 0).
+const RED = "\x1b[38;2;233;38;31m";
+
+// The composed wordmark + separators of the instrument line. Em-dash after the wordmark (it breathes);
+// dim mid-dots between clauses. ANSI only, one line, no animation — the bar re-invokes this command.
+const WORDMARK = `🔬 ${BOLD}skalpel${RESET}`;
+const EMDASH = `${DIM} — ${RESET}`;
+const MIDDOT = ` ${DIM}·${RESET} `;
 
-// ── RENDER MODE — the ONE constant Ryan flips. Governs the optional TIME clause on the always-on
-// `skalpel · N steers` baseline. The steers count + Raahil's #609 BOLD/CYAN styling are ALWAYS present,
-// unchanged, in every mode. Nothing else on the bar (reveal / verdict / re-ask / steer label) is affected.
-//   "steers"   → skalpel · N steers
-//   "measured" → skalpel · N steers · 38m caught          (DEFAULT — cumulative lifetime MEASURED red→green)
-//   "saved"    → skalpel · N steers · ~7m saved           (Raahil's own-graph ESTIMATE, from steers.ndjson)
-//   "both"     → skalpel · N steers · 38m caught · ~7m saved
+// ── RENDER MODE — the ONE constant Ryan flips. Governs the optional TIME clause(s) on the ambient
+// instrument line. The heartbeat (claims verified / checked · false) and the `N steers` clause are
+// mode-independent. Nothing else on the bar (reveal / verdict / re-ask / steer label) is affected.
+//   "steers"   → no time clause
+//   "measured" → · 38m caught          (DEFAULT — cumulative lifetime MEASURED red→green)
+//   "saved"    → · ~7m saved           (Raahil's own-graph ESTIMATE, from steers.ndjson)
+//   "both"     → · 38m caught · ~7m saved
 const BASELINE_TIME_MODE = "measured";
 const SHOW_MEASURED = BASELINE_TIME_MODE === "measured" || BASELINE_TIME_MODE === "both";
 const SHOW_SAVED = BASELINE_TIME_MODE === "saved" || BASELINE_TIME_MODE === "both";
@@ -335,6 +361,38 @@ function compactMeasured(ms) {
     : `${(Math.floor(h * 10) / 10).toFixed(1).replace(/\.0$/, "")}h`;
 }
 
+// adjudicatedNoKeys() → the set of `${session}|${proofSig}` keys the USER adjudicated "not a real catch"
+// (`skalpel no` appends a verdict:"no" row to verify-adjudications.ndjson AND a session-scoped row to
+// verify-suppressed.ndjson — both are read, either is sufficient evidence). Bounded tail reads (same
+// tailLines guard as the shadow log), fail-open (any error → empty set → tally unchanged). Called LAZILY
+// from shadowTally only when a mismatch row actually exists, so a log with no catches — and any install
+// where the adjudication files are absent — pays zero extra cost.
+const ADJ_READ_BYTES = 256 * 1024;
+function adjudicatedNoKeys() {
+  const keys = new Set();
+  try {
+    for (const l of tailLines(ADJUDICATIONS_PATH, ADJ_READ_BYTES)) {
+      try {
+        const r = JSON.parse(l);
+        if (r && r.verdict === "no" && r.proof) keys.add(`${r.session ?? ""}|${proofSig(r.proof)}`);
+      } catch {
+        /* partial / garbage line — skip */
+      }
+    }
+    for (const l of tailLines(SUPPRESS_PATH, ADJ_READ_BYTES)) {
+      try {
+        const r = JSON.parse(l);
+        if (r && r.session && r.proof) keys.add(`${r.session}|${proofSig(r.proof)}`);
+      } catch {
+        /* partial / garbage line — skip */
+      }
+    }
+  } catch {
+    /* fail-open: no adjudication data → nothing excluded */
+  }
+  return keys;
+}
+
 // measuredCaughtTotalMs() → the CUMULATIVE LIFETIME sum, in ms, of EVERY real measured red→green delta:
 // each caught false "done" (mismatch row) that has a later same-session same-proof PASS contributes that
 // one measured (t_pass − t_false) delta; a catch with no later PASS contributes 0 (never estimated). This
@@ -371,7 +429,20 @@ function shadowTally() {
     const CHECKED = new Set(["PASS", "GENUINE_FAIL", "SHIP_OK", "SHIP_FAIL"]);
     let checked = 0;
     let lies = 0;
+    // ADJUDICATION-AWARE (2026-07-13 false-accusation incident): a mismatch row the USER marked "not a
+    // real catch" (`skalpel no`) must stop counting as `false` on the bar — and an adjudicated-wrong
+    // check isn't a check we stand behind, so it leaves `checked` (and its fixDelta leaves the measured
+    // total) too. Lazy: the adjudication files are only read once a mismatch row actually exists.
+    let noKeys = null;
+    const adjudicatedWrong = (r) => {
+      if (r.mismatch !== true) return false;
+      if (noKeys === null) noKeys = adjudicatedNoKeys();
+      if (noKeys.size === 0) return false;
+      // The join key mirrors the reveal/adjudication sig: a ship row's "proof" is its probe command.
+      return noKeys.has(`${r.session ?? ""}|${proofSig(r.proof_command || r.probe_command)}`);
+    };
     for (const r of rows) {
+      if (adjudicatedWrong(r)) continue; // user said "no" — not a lie, not a check, no measured delta
       if (CHECKED.has(r.outcome)) checked += 1;
       if (r.mismatch !== true) continue; // only a caught false "done" (verify-shadow's money metric)
       lies += 1;
@@ -423,7 +494,7 @@ function main() {
   const n = reaskCount(payload.transcript_path);
   if (n >= 2) {
     process.stdout.write(
-      `${BOLD}skalpel${RESET} · ${CYAN}${n} re-asks/interrupts this stretch${RESET} · ${DIM}run: skalpel autopsy${RESET}`,
+      `${WORDMARK}${EMDASH}${CYAN}${n}${RESET} ${DIM}re-asks/interrupts this stretch${RESET}${MIDDOT}${DIM}run: skalpel autopsy${RESET}`,
     );
     return;
   }
@@ -431,44 +502,49 @@ function main() {
   // Otherwise, if a steer is live, name what it's doing — a description, no number.
   const label = steerLabel();
   if (label) {
-    process.stdout.write(`${BOLD}skalpel${RESET} · ${CYAN}${label}${RESET}`);
+    process.stdout.write(`${WORDMARK}${EMDASH}${CYAN}${label}${RESET}`);
     return;
   }
 
-  // ALWAYS-ON baseline presence line — skalpel's terminal presence (owner product decision: never gated,
-  // never hidden). `N steers` is ALWAYS shown (fresh install reads "0 steers" — honest, present, never
-  // blank; the user's own applied-steer count). Then the ONE optional time clause selected by
-  // BASELINE_TIME_MODE, each an AGGREGATE number only (never per-catch claim text / proof — those live in
-  // the opt-in reveal + the TUI), shown only when its real value exists:
-  //   • MEASURED "· Xm caught" — the CUMULATIVE LIFETIME sum of every real measured red→green delta
-  //     (measuredCaughtTotalMs). Always-on once real catches exist; a MEASURED wall-clock, never an
-  //     estimate. Cumulative framing (not present-tense "just caught"), so it stays honest for old catches.
-  //   • Raahil's `~`-prefixed saved ESTIMATE ("· ~7m saved") — shown only when saved_min > 0 (its data is
-  //     the user's own steers.ndjson credit, not the shadow log, so it keeps his always-on #609 behavior).
+  // THE AMBIENT INSTRUMENT LINE — skalpel's always-on terminal presence (owner product decision: never
+  // gated, never hidden). The wordmark leads; the body composes ONLY the clauses with real value, each
+  // an AGGREGATE number (never per-catch claim text / proof — those live in the opt-in reveal + the TUI):
+  //   • THE HEARTBEAT (founder: "I only see 0 steers — the product is invisible while it works"):
+  //       clean so far → "3 claims verified"   (the earned-silence receipt — real verdicts only)
+  //       lies caught  → "31 checked · 2 false" (the honest split; `M false` carries the one red accent)
+  //   • MEASURED "Xm caught" — the CUMULATIVE LIFETIME sum of every real measured red→green delta
+  //     (shadowTally). IMMUTABLE product surface: rendered whenever it has a value; a MEASURED
+  //     wall-clock, never an estimate. Cumulative framing keeps it honest for old catches.
+  //   • "N steers" — the user's own applied-steer count, whenever > 0 (always-on WHEN IT HAS VALUE;
+  //     the redesign only removed the dead "0 steers" zero — presence is now the wordmark itself).
+  //   • Raahil's `~`-prefixed saved ESTIMATE ("~7m saved") — mode-gated, shown only when saved_min > 0
+  //     (its data is the user's own steers.ndjson credit, not the shadow log — #609 behavior preserved).
+  // Nothing yet (no verdicts, no steers, no measured) → the quiet watching line, never a dead zero.
   const { steers, savedMin } = readState();
-  const tally = SHOW_MEASURED ? shadowTally() : { totalMs: 0, checked: 0, lies: 0 };
-  let line = `${BOLD}skalpel${RESET} · ${CYAN}${steers} steers${RESET}`;
+  const tally = shadowTally();
+  const clauses = [];
+  if (tally.checked > 0) {
+    if (tally.lies > 0) {
+      clauses.push(`${CYAN}${tally.checked}${RESET} ${DIM}checked${RESET}`);
+      clauses.push(`${RED}${tally.lies} false${RESET}`); // the ONE red accent, used once
+    } else {
+      clauses.push(
+        `${CYAN}${tally.checked}${RESET} ${DIM}claim${tally.checked === 1 ? "" : "s"} verified${RESET}`,
+      );
+    }
+  }
   if (SHOW_MEASURED) {
     const caught = compactMeasured(tally.totalMs); // null when < 1s of real measured catches
-    if (caught) line += ` · ${CYAN}${caught} caught${RESET}`;
-    // THE HEARTBEAT (founder: "I only see 0 steers — the product is invisible while it works").
-    // Once the armed shadow has genuinely CHECKED at least one claim, the line SHOWS the work:
-    //   clean so far → "· 3 claims verified"    (the earned-silence receipt — real verdicts only)
-    //   lies caught  → "· 31 checked · 2 false" (the honest split; the measured clause carries the time)
-    // Real counts from the same single log pass. A fresh install (checked = 0) emits EXACTLY the
-    // baseline line — byte-identical, nothing invented.
-    if (tally.checked > 0) {
-      line +=
-        tally.lies > 0
-          ? ` · ${CYAN}${tally.checked} checked · ${tally.lies} false${RESET}`
-          : ` · ${CYAN}${tally.checked} claim${tally.checked === 1 ? "" : "s"} verified${RESET}`;
-    }
+    if (caught) clauses.push(`${CYAN}${caught}${RESET} ${DIM}caught${RESET}`);
   }
+  if (steers > 0)
+    clauses.push(`${CYAN}${steers}${RESET} ${DIM}steer${steers === 1 ? "" : "s"}${RESET}`);
   if (SHOW_SAVED) {
     const phrase = savedPhrase(savedMin);
-    if (phrase) line += ` · ${CYAN}${phrase}${RESET}`;
+    if (phrase) clauses.push(`${CYAN}${phrase}${RESET}`);
   }
-  process.stdout.write(line);
+  const body = clauses.length ? clauses.join(MIDDOT) : `${DIM}watching your agent's claims${RESET}`;
+  process.stdout.write(`${WORDMARK}${EMDASH}${body}`);
 }
 
 // Fail-open: wrap the whole render so a thrown error can never spill a stack trace into the live status

package/verify-shadow.mjs

@@ -1013,6 +1013,21 @@ const SHIP_CLAIM_PATTERNS = [
 const SHIP_FUTURE_OR_QUESTION =
   /\b(?:will|i'?ll|we'?ll|going\s+to|gonna|about\s+to|let\s+me|planning\s+to|need\s+to|shall\s+i|should\s+i|can\s+i|once\s+|after\s+i|before\s+i|ready\s+to)\b/i;
 
+// PRECISION (2026-07-13 false-accusation incident): markdown STRUCTURE is not a declarative sentence.
+// A real ship claim ("Deployed to prod.", "it's live at https://…") is a plain declarative line; a
+// bullet / table row / blockquote / heading / bold-lead line is the assistant NARRATING or summarizing —
+// a status-table bullet ("- **`npx skalpel@latest` (what customers install):** 4.0.52 — …") once minted
+// a false SHIP_FAIL on the founder's own machine. NARROWING only: skip such lines outright.
+const SHIP_MARKDOWN_STRUCTURE = /^(?:[-*+]\s|\||>|#|\*\*)/;
+// shipMatchInBackticks(line, offset) → does the match offset fall inside an ODD backtick segment (i.e.
+// inside inline `code`)? A ship keyword inside backticks is being QUOTED (a command, a flag, output),
+// never asserted. Split-on-backtick parity: chars after an odd number of ` are inside code.
+function shipMatchInBackticks(line, offset) {
+  let ticks = 0;
+  for (let i = 0; i < offset && i < line.length; i++) if (line[i] === "`") ticks++;
+  return ticks % 2 === 1;
+}
+
 // detectShipClaim(text) → { claim:bool, kind, text:<the claim line, <=120c> }. Scans lines; returns the
 // first ASSERTIVE ship-status line. `kind` is the canonical claim keyword reconstructShipTargetV1 consumes.
 export function detectShipClaim(text) {
@@ -1023,8 +1038,10 @@ export function detectShipClaim(text) {
     if (!l) continue;
     if (/\?\s*$/.test(l)) continue; // a question is not a claim
     if (SHIP_FUTURE_OR_QUESTION.test(l)) continue; // intention, not "it's done"
+    if (SHIP_MARKDOWN_STRUCTURE.test(l)) continue; // markdown structure, not a declarative sentence
     for (const [kind, re] of SHIP_CLAIM_PATTERNS) {
-      if (re.test(l)) {
+      const m = re.exec(l);
+      if (m && !shipMatchInBackticks(l, m.index)) {
         return { claim: true, kind, text: l.replace(/\s+/g, " ").trim().slice(0, 120) };
       }
     }
@@ -1289,9 +1306,10 @@ function maybeSurfaceReveal(row) {
   }
 }
 
-// SHIP-STATUS v1 confirm-gate: the wait between a URL FAIL_CANDIDATE (404/410/NXDOMAIN/refused) and its
-// ONE confirming re-probe. Default ~60s; overridable via env (SKALPEL_SHIP_CONFIRM_MS, 0 for tests). The
-// wait happens ONLY inside the DETACHED, unref'd `--run` worker — never on the per-turn hook deadline.
+// SHIP-STATUS v1 confirm-gate: the wait between ANY first-probe negative (a URL FAIL_CANDIDATE — 404/
+// 410/NXDOMAIN/refused — or a hard registry/tag/pr/git/checks FAIL) and its ONE confirming re-probe.
+// Default ~60s; overridable via env (SKALPEL_SHIP_CONFIRM_MS, 0 for tests). The wait happens ONLY inside
+// the DETACHED, unref'd `--run` worker — never on the per-turn hook deadline.
 const SHIP_CONFIRM_DELAY_MS = (() => {
   const v = parseInt(process.env.SKALPEL_SHIP_CONFIRM_MS ?? "", 10);
   return Number.isFinite(v) && v >= 0 ? v : 60_000;
@@ -1305,7 +1323,7 @@ function shipSleep(ms) {
 
 // resolveShipStatus({kind, contextText, payload, target?, exec?, ...}) — the TESTABLE core of the ship
 // catch: reconstruct the strict single-family target (or accept a prebuilt one), run its ONE read-only
-// probe, and (only for a URL FAIL_CANDIDATE) confirm-gate before ever calling it a red. Returns a plain
+// probe, and (for EVERY first-probe negative, any kind) confirm-gate before ever calling it a red. Returns a plain
 // result object — no I/O, no lock, no reveal. `exec` (the read-only command runner) and `sleep` are
 // injectable purely so the eval harness can drive every branch hermetically. Never throws to the caller.
 //   outcome ∈ { NO_TARGET, SHIP_OK, SHIP_FAIL, SHIP_UNKNOWN };  mismatch === (outcome === "SHIP_FAIL").
@@ -1338,10 +1356,16 @@ export async function resolveShipStatus({
   let evidence = first.evidence;
   let confirm_reprobe = false;
   let confirm_outcome = null;
-  // Defect 3 CONFIRM-GATE: a URL fail candidate (a 404/410/gone or a NXDOMAIN/refused, which can be pure
-  // CDN/propagation lag) NEVER reveals immediately — wait ~60s and re-probe ONCE; only a CONFIRMED
-  // double-negative (2/2 fail candidate) fires. A PASS on the re-probe means it was transient → SHIP_OK.
-  if (verdict === "FAIL_CANDIDATE" && tgt.kind === "url") {
+  // CONFIRM-GATE for ALL ship reds (Defect 3, widened after the 2026-07-13 false accusation): NO
+  // first-probe negative EVER reds immediately — not a URL FAIL_CANDIDATE (404/410/NXDOMAIN/refused:
+  // pure CDN/propagation lag) and not a hard registry/tag/pr/git/checks "FAIL" (replication lag, an
+  // eventually-consistent registry read, a stale gh view). Every negative waits (SHIP_CONFIRM_DELAY_MS,
+  // or the injected confirmDelayMs) and re-probes ONCE; only a CONFIRMED 2/2 negative becomes a red.
+  // A PASS on the confirm means it was transient → SHIP_OK; an UNKNOWN on the confirm → SHIP_UNKNOWN
+  // (never a red we can't stand behind). runShipProbeV1's verdict vocabulary is exactly
+  // PASS | FAIL | FAIL_CANDIDATE | UNKNOWN — both negative forms gate identically here.
+  const shipNegative = (v) => v === "FAIL" || v === "FAIL_CANDIDATE";
+  if (shipNegative(verdict)) {
     if (typeof beforeReprobe === "function") {
       try {
         beforeReprobe();
@@ -1355,11 +1379,11 @@ export async function resolveShipStatus({
     confirm_reprobe = true;
     confirm_outcome = second.verdict;
     evidence = second.evidence || evidence;
-    verdict =
-      second.verdict === "FAIL_CANDIDATE" ? "FAIL" : second.verdict === "PASS" ? "PASS" : "UNKNOWN";
-  } else if (verdict === "FAIL_CANDIDATE") {
-    // A non-URL probe should never yield a lone candidate; treat as UNKNOWN so it can never single-red.
-    verdict = "UNKNOWN";
+    verdict = shipNegative(second.verdict)
+      ? "FAIL"
+      : second.verdict === "PASS"
+        ? "PASS"
+        : "UNKNOWN";
   }
   const outcome =
     verdict === "PASS" ? "SHIP_OK" : verdict === "FAIL" ? "SHIP_FAIL" : "SHIP_UNKNOWN";
@@ -1447,7 +1471,7 @@ async function maybeShipStatusCatch({ text, session, cwd, transcriptPath }) {
       pass_fail,
       outcome,
       mismatch: outcome === "SHIP_FAIL", // claimed shipped, the read-only probe DECISIVELY says it is NOT
-      // The instrument records the confirm re-probe (URL fail-candidate) and its second-probe verdict.
+      // The instrument records the confirm re-probe (any first-probe negative) and its second verdict.
       confirm_reprobe: resolved.confirm_reprobe,
       confirm_outcome: resolved.confirm_outcome,
       evidence: String(resolved.evidence || "").slice(0, 200),