tickmarkr 2.7.8 → 2.8.0

package/dist/gates/baseline.js

@@ -14,21 +14,44 @@ export const EVIDENCE_RUN_QUOTA_BYTES = DEFAULT_EVIDENCE_QUOTA_BYTES;
 /** Benign environment locations substituted by name; every other redaction is material. */
 const BENIGN_ENV_KEYS = ["HOME", "TMPDIR"];
 const REDACTION_CATEGORIES = ["token", "assignment", "secretEnv", "benignEnv"];
+/** Keep inherited, evidence, and inline values as separate pairs, including overridden values. */
+function gateEvidencePairs(env, command, inheritedEnv) {
+    const pairs = [...Object.entries(inheritedEnv), ...Object.entries(env)]
+        .filter((entry) => entry[1] !== undefined);
+    for (const match of command.matchAll(/(?:^|\s)([A-Za-z_][A-Za-z_0-9]*)=(?:'([^']*)'|"([^"$]*)"|([^\s;&|]+))/g)) {
+        pairs.push([match[1], match[2] ?? match[3] ?? match[4]]);
+    }
+    return pairs;
+}
 /**
  * OBS-1139: every category scans the ORIGINAL text on its own; overlapping spans then merge into one
  * span counted once under its highest-priority member — token, assignment, secret environment, benign
  * HOME/TMPDIR — so precedence never depends on which match starts first. Counts only: never a value.
  */
-export function classifyGateOutput(text, env) {
-    // HOME/TMPDIR substitute by name at any length; "/" alone would rewrite every path separator.
-    const benign = BENIGN_ENV_KEYS.flatMap(key => { const value = env[key]; return value && value.length > 1 ? [{ value, label: `$${key}` }] : []; });
-    // Short operational values (0, true, vi, test) occur throughout ordinary diagnostics.
-    // Only secret-named keys justify redacting short values. A secret-named value that happens to equal
-    // HOME/TMPDIR stays a secret candidate: precedence decides the span, never candidate pruning.
-    const secrets = [...new Set(Object.entries(env)
-            .filter(([key, value]) => !!value && !BENIGN_ENV_KEYS.includes(key)
-            && (value.length >= 8 || /KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|AUTH/i.test(key)))
-            .map(([, value]) => value))];
+export function classifyGateOutput(text, env, command = "", inheritedEnv = process.env) {
+    const benign = [];
+    const secrets = new Set();
+    // Closed pair rule, first match wins: HOME/TMPDIR is benign when longer than one; empty is nothing;
+    // length >= 8 is secret; a secret name with a flag literal (0, 1, true, false, yes, no, on, off)
+    // or all ASCII digits is nothing; another short secret-named value is secret; other short values
+    // are nothing. Cost: short all-digit secrets and flag literals are no longer withheld. Span
+    // precedence still makes a secret equal to HOME/TMPDIR win over the benign location label.
+    for (const [name, value] of gateEvidencePairs(env, command, inheritedEnv)) {
+        if (BENIGN_ENV_KEYS.includes(name)) {
+            if (value.length > 1)
+                benign.push({ value, label: `$${name}` });
+        }
+        else if (!value) {
+            continue;
+        }
+        else if (value.length >= 8) {
+            secrets.add(value);
+        }
+        else if (/KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|AUTH/i.test(name)
+            && !/^(?:0|1|true|false|yes|no|on|off)$/i.test(value) && !/^[0-9]+$/.test(value)) {
+            secrets.add(value);
+        }
+    }
     const literal = (v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const tokens = String.raw `\b(?:sk-[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9_]{16,}|github_pat_[A-Za-z0-9_]{16,}|AKIA[A-Z0-9]{16}|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)\b`;
     const assignments = String.raw `(?:authorization\s*:\s*bearer|(?:api[_-]?key|token|password|secret)\s*[:=])\s*[^\s"']+`;
@@ -37,7 +60,7 @@ export function classifyGateOutput(text, env) {
     const scan = (source, rank, label) => [...text.matchAll(new RegExp(source, "gi"))].map(m => ({ start: m.index, end: m.index + m[0].length, rank, label }));
     const spans = [
         ...scan(tokens, 0), ...scan(assignments, 1),
-        ...secrets.flatMap(v => scan(literal(v), 2)),
+        ...[...secrets].flatMap(v => scan(literal(v), 2)),
         ...benign.flatMap(b => scan(literal(b.value), 3, b.label)),
     ].sort((a, b) => a.start - b.start || b.end - a.end);
     const merged = [];
@@ -64,8 +87,8 @@ export function classifyGateOutput(text, env) {
     }
     return { text: out + text.slice(at), counts };
 }
-export function redactGateOutput(text, env) {
-    return classifyGateOutput(text, env).text;
+export function redactGateOutput(text, env, command = "") {
+    return classifyGateOutput(text, env, command).text;
 }
 /** Material means bytes were withheld; a benign location substitution withholds nothing. */
 export const redactionMaterial = (c) => c.token + c.assignment + c.secretEnv > 0;
@@ -103,10 +126,8 @@ export function beginGateEvidence(cwd, gate, command, opts = {}, nonce) {
         catch { /* unknown subject */ }
     }
     const root = opts.artifactDir ?? join(tmpdir(), "tickmarkr-gate-evidence", createHash("sha256").update(cwd).digest("hex"));
-    const env = { ...process.env, ...opts.env };
-    for (const match of command.matchAll(/(?:^|\s)[A-Za-z_][A-Za-z_0-9]*=(?:'([^']*)'|"([^"$]*)"|([^\s;&|]+))/g)) {
-        env[`assignment_${match.index}`] = match[1] ?? match[2] ?? match[3];
-    }
+    const inheritedEnv = { ...process.env };
+    const evidenceEnv = { ...opts.env };
     let observed;
     let pendingId;
     const history = [];
@@ -131,7 +152,7 @@ export function beginGateEvidence(cwd, gate, command, opts = {}, nonce) {
                 exitCode: observed?.exitCode ?? null, signal: observed?.signal ?? null,
                 timedOut: observed ? observed.outcome === "timed-out" : null,
             };
-            const classified = [classifyGateOutput(stdout, env), classifyGateOutput(stderr, env)];
+            const classified = [classifyGateOutput(stdout, evidenceEnv, command, inheritedEnv), classifyGateOutput(stderr, evidenceEnv, command, inheritedEnv)];
             const clean = classified.map(c => c.text);
             const counts = { token: 0, assignment: 0, secretEnv: 0, benignEnv: 0 };
             for (const c of classified)
@@ -366,6 +387,17 @@ const namesRegression = (l) => (isFailureShaped(l) || ERROR_CLASS_RE.test(l)) &&
 // This does not make the vocabulary open-ended: INFRA_RE is still the one closed list, and
 // classifyFailureOutput's ERROR_CLASS_RE/namesFailure vetoes still decide mixed lines.
 const isFingerprintShaped = (l) => isFailureShaped(l) || INFRA_RE.test(l);
+/** D1's signal vocabulary, one copy for the gate battery and the tip (the daemon keeps its own). */
+export const SIGNAL_EXIT_RE = /\b(?:SIGTERM|SIGKILL|signal\s+(?:9|15)|exit(?:s|ed|\s+code)?\s+(?:137|143))\b/i;
+/**
+ * S19m4: the first kill line of in-memory runner output — outside Vitest echo blocks, ANSI-stripped,
+ * read in its turbo-stripped form: it names a signal exit, is not failure-shaped, is neither a pass nor an
+ * operator line, and is not a script echo (`> ` — npm and pnpm print one before every script they run,
+ * nested ones included, and the echo is the command text, never kill text).
+ */
+const firstKillLine = (output) => withoutVitestEchoBlocks(output)
+    .map((l) => { const clean = l.replace(ANSI_RE, ""); return stripTurboPrefix(clean) ?? clean; })
+    .find((l) => SIGNAL_EXIT_RE.test(l) && !isFingerprintShaped(l) && !PASS_LINE_RE.test(l) && !OPERATOR_LINE_RE.test(l) && !l.startsWith("> "));
 /**
  * What a nonzero runner exit is evidence OF. `undefined` when the output names neither — the
  * unreadable-runner case the existing fail-closed path already owns.
@@ -494,6 +526,102 @@ export function fingerprint(output) {
         return lines.some((l) => l.trim()) ? [UNRECOGNIZED_FAILURE] : [];
     return [...new Set(shaped.map(normalizeLine))];
 }
+// S22 table T (ANL-021): the ONLY whole-token shapes whose digits a v2 fingerprint canonicalizes, first
+// match wins. Every other token keeps its digits verbatim — TestParse1, TS2304, 1ms.js, my/no-1ms-timeout.
+const T4_PATH_POSITION_RE = /^(.*[^\d:])((?::\d+){1,2})$/;
+const T5_TSC_POSITION_RE = /^(.*)\((\d+),(\d+)\)$/;
+const TABLE_T = [
+    [/^(?:\d+h)?(?:\d+m(?!s))?(?:\d*\.)?\d+(?:ns|ps|us|µs|μs|ms|s|m|h)$/, () => "<dur>"], // T1 duration
+    [/^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?%?$/, () => "#"], // T2 number
+    [/^\d+(?:[:.]\d+)+$/, (m) => m[0].replace(/\d+/g, "#")], // T3 position, clock, version
+    [T4_PATH_POSITION_RE, (m) => m[1] + m[2].replace(/\d+/g, "#")], // T4 path with position
+    [T5_TSC_POSITION_RE, (m) => `${m[1]}(#,#)`], // T5 tsc position
+    [/^\d+\/\d+$/, () => "#/#"], // T6 ratio
+    [/^\d{4}-\d{2}-\d{2}(?:[T ]?\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?(?:Z|[+-]\d{2}:?\d{2})?$/, () => "<time>"], // T7 ISO date-time
+    [/^([A-Za-z_][\w.-]*)=([+-]?\d+(?:\.\d+)?)$/, (m) => `${m[1]}=#`], // T8 key=number
+    [/^0x[0-9a-fA-F]+$/, () => "0x#"], // T9 hex address
+];
+const canonical = (core, rows) => {
+    for (const [re, to] of rows) {
+        const m = re.exec(core);
+        if (m)
+            return to(m);
+    }
+    return undefined;
+};
+const canonicalToken = (token) => {
+    const trail = /[,;:.!?]+$/.exec(token)?.[0] ?? "";
+    const rest = token.slice(0, token.length - trail.length);
+    const positioned = canonical(rest, [TABLE_T[4], TABLE_T[3]]);
+    if (positioned !== undefined)
+        return positioned + trail;
+    const lead = /^[([{"']/.exec(rest)?.[0] ?? "";
+    const close = /[)\]}"']+$/.exec(rest.slice(lead.length))?.[0] ?? "";
+    const core = rest.slice(lead.length, rest.length - close.length);
+    const out = canonical(core, TABLE_T);
+    return out === undefined ? token : lead + out + close + trail;
+};
+/** A v2 line: every whitespace token canonicalized by table T, joined with one space. */
+const normalizeV2 = (l) => l.split(/\s+/).filter(Boolean).map(canonicalToken).join(" ");
+// S22 layout L: when a stylish header is PROVEN for an error row. A stream is keyed by its turbo-style
+// label (CONTENT keeps the runner's own indentation, unlike TURBO_PREFIX_RE); unlabelled output is one stream.
+const L_LABEL_RE = /^([\w@./-]+(?::[A-Za-z_][\w.-]*)+):(?: |$)/;
+const L_ROW_RE = /^\s+\d+:\d+\s+(?:error|warning)\s+\S/;
+const splitLabel = (l) => {
+    const m = L_LABEL_RE.exec(l);
+    return m ? { label: m[1], content: l.slice(m[0].length) } : { label: "", content: l };
+};
+/** Line index → proven header of every ROW inside a BLOCK (a header plus the maximal run of rows after it). */
+function stylishHeaders(lines) {
+    const streams = new Map();
+    lines.forEach((line, index) => {
+        const { label, content } = splitLabel(line);
+        const stream = streams.get(label) ?? [];
+        stream.push({ index, content });
+        streams.set(label, stream);
+    });
+    const headers = new Map();
+    for (const stream of streams.values()) {
+        stream.forEach(({ content }, i) => {
+            const proven = /^\S/.test(content) && !L_ROW_RE.test(content) && !isFingerprintShaped(content)
+                && (i === 0 || stream[i - 1].content.trim() === "") && L_ROW_RE.test(stream[i + 1]?.content ?? "");
+            for (let j = i + 1; proven && j < stream.length && L_ROW_RE.test(stream[j].content); j++)
+                headers.set(stream[j].index, content);
+        });
+    }
+    return headers;
+}
+/**
+ * S22: one identity per failure OCCURRENCE (never deduplicated), each kept beside the original line it came
+ * from. Same filters as `fingerprint`; a stylish error ROW is emitted once, as its layout-L tuple.
+ */
+function fingerprintOccurrences(output) {
+    const all = withoutVitestEchoBlocks(output).map((l) => l.replace(ANSI_RE, ""));
+    const headers = stylishHeaders(all);
+    const occurrences = [];
+    let printed = false;
+    all.forEach((l, index) => {
+        if (PASS_LINE_RE.test(l) || OPERATOR_LINE_RE.test(l))
+            return;
+        printed ||= l.trim() !== "";
+        const stripped = stripTurboPrefix(l);
+        if (stripped !== undefined && OPERATOR_LINE_RE.test(stripped))
+            return; // OBS-888: operator prose under a turbo prefix
+        const { label, content } = splitLabel(l);
+        if (L_ROW_RE.test(content) && LINTER_ERROR_RE.test(content)) {
+            const header = headers.get(index) ?? null;
+            occurrences.push({ id: JSON.stringify(["stylish", label, header, normalizeV2(content)]), line: l, ...(header === null ? { unattributed: true } : {}) });
+            return;
+        }
+        if (isFingerprintShaped(l))
+            occurrences.push({ id: normalizeV2(l), line: l });
+        if (stripped !== undefined && !PASS_LINE_RE.test(stripped) && isFingerprintShaped(stripped))
+            occurrences.push({ id: normalizeV2(stripped), line: stripped });
+    });
+    if (!occurrences.length && printed)
+        return [{ id: UNRECOGNIZED_FAILURE, line: UNRECOGNIZED_FAILURE }];
+    return occurrences;
+}
 // The diagnostic channel for a runner we cannot read: raw output lines, never fingerprints, never a
 // verdict. They exist so the operator sees SOMETHING when a green command turns red unrecognizably.
 const unrecognizedEvidence = (raw) => raw
@@ -505,23 +633,81 @@ const unrecognizedEvidence = (raw) => raw
 // stored baselines may predate ANSI/pass-marker hardening — renormalize at compare time so existing
 // on-disk baseline.json files stay comparable without recapture (compat invariant, CLAUDE.md)
 const renormalize = (fp) => normalizeLine(fp.replace(ANSI_RE, ""));
+const entryState = (entry) => {
+    if (entry === undefined)
+        return { state: "missing" };
+    if (entry === null || typeof entry !== "object")
+        return { state: "unreadable", why: "entry is not an object" };
+    const version = entry.fingerprintVersion;
+    if (version !== undefined && version !== 2)
+        return { state: "unreadable", why: `fingerprintVersion ${JSON.stringify(version)} is not 2` };
+    const fps = entry.fingerprints;
+    // ponytail: an absent list keeps 2.7.8's `?? []` for legacy entries; a present one must be all strings
+    if ((fps !== undefined || version === 2) && !(Array.isArray(fps) && fps.every((f) => typeof f === "string"))) {
+        return { state: "unreadable", why: "fingerprints is not an array of strings" };
+    }
+    if (entry.infra === true)
+        return { state: "no-verdict" };
+    return { state: version === 2 ? "v2" : "legacy" };
+};
+/** The red reason a missing or unreadable entry owes in BOTH readers; undefined for every other state. */
+export function baselineEntryRefusal(gate, verdict) {
+    if (verdict.state === "missing")
+        return `no baseline entry for ${gate}`;
+    if (verdict.state === "unreadable")
+        return `baseline entry for ${gate} is unreadable (${verdict.why})`;
+    return undefined;
+}
+// OBS-42: diagnostic headings enrich fingerprints but cannot reject on their own.
+const rejects = (f) => !FAIL_ANCHOR_RE.test(f) || f.startsWith("FAIL ");
 /**
- * Q121s: the battery's forgiveness math, exported so tip-verify applies the IDENTICAL rule.
- * Returns the failure fingerprints of `raw` that are NOT in the baseline entry (fresh), and
- * whether the output carried no recognizable failure shape at all.
+ * Q121s / S22: the battery's forgiveness math, exported so tip verify applies the IDENTICAL rule, and
+ * the one place an entry's state is decided — each reader renders its reason, neither re-derives it.
+ *
+ * A LEGACY entry (no fingerprintVersion) compares exactly as 2.7.8 did: set membership over lines whose
+ * every digit run is masked. A v2 entry is a MULTISET under two closed grammars (ANL-021 S22):
+ * - table T: only whole tokens of a closed volatile shape (durations, numbers, positions, ratios, ISO
+ *   times, key=number, hex addresses) lose their digits; every other token keeps them. Declared cost: a
+ *   volatile token outside T stays verbatim, so its change reads fresh (a closed false red, not a defect).
+ * - layout L: a stylish error row is keyed by its stream label and the header layout L proves (blank or
+ *   nothing before it, rows right after it). Declared costs: a row outside every proven block is never
+ *   forgiven, and a header printed under a realpath variant of the cwd compares as a different header.
+ * f is fresh when the candidate repeats it more often than the capture recorded it.
  */
-export function freshFailures(entry, raw) {
+export function freshFailures(entry, raw, readKillText = false) {
+    // S19m4: kill text is read here, before table T, from the in-memory output — never the redacted tail.
+    const killLine = readKillText ? firstKillLine(raw) : undefined;
+    const kill = killLine !== undefined ? { killLine } : {};
+    const { state, why } = entryState(entry);
+    const baselineRed = (state === "legacy" || state === "v2") && (entry.exitCode ?? 1) !== 0;
+    if (state === "v2") {
+        const recorded = new Map();
+        for (const f of entry.fingerprints)
+            recorded.set(f, (recorded.get(f) ?? 0) + 1);
+        const occurrences = fingerprintOccurrences(raw);
+        const seen = new Map();
+        for (const o of occurrences)
+            seen.set(o.id, (seen.get(o.id) ?? 0) + 1);
+        const isFresh = (o) => o.id !== UNRECOGNIZED_FAILURE && rejects(o.id)
+            && (o.unattributed === true || seen.get(o.id) > (recorded.get(o.id) ?? 0));
+        const fresh = occurrences.filter(isFresh);
+        return {
+            failing: [...new Set(fresh.map((o) => o.id))],
+            unreadable: seen.has(UNRECOGNIZED_FAILURE),
+            forgiven: [...new Set(occurrences.filter((o) => o.unattributed !== true && seen.get(o.id) <= (recorded.get(o.id) ?? 0)).map((o) => o.id))],
+            failingLines: fresh.map((o) => o.line),
+            state, baselineRed, ...kill,
+        };
+    }
     // OBS-534 (T2): an infra-recorded entry is a KILL, not a verdict — whatever fingerprints it carries
     // came from output flushed before the kill, over a suite that never finished. Nothing there is
-    // "pre-existing", so it forgives nothing. The rule lives here rather than in either caller, so the
-    // battery and tip verify inherit it from the one helper they already share.
-    const known = new Set(entry?.infra === true ? [] : (entry?.fingerprints ?? []).map(renormalize));
-    // OBS-42: diagnostic headings enrich fingerprints but cannot invalidate legacy baselines.
+    // "pre-existing", so it forgives nothing; neither does a missing or unreadable entry.
+    const known = new Set(state === "legacy" ? (entry.fingerprints ?? []).map(renormalize) : []);
     const current = fingerprint(raw);
-    const fresh = current.filter((f) => !known.has(f) && (!FAIL_ANCHOR_RE.test(f) || f.startsWith("FAIL ")));
+    const fresh = current.filter((f) => !known.has(f) && rejects(f) && f !== UNRECOGNIZED_FAILURE);
     // OBS-1123: the baseline-recorded half, named so a reader never has to infer it from the fresh half.
-    return { failing: fresh.filter((f) => f !== UNRECOGNIZED_FAILURE), unreadable: current.includes(UNRECOGNIZED_FAILURE),
-        forgiven: current.filter((f) => known.has(f)) };
+    return { failing: fresh, unreadable: current.includes(UNRECOGNIZED_FAILURE),
+        forgiven: current.filter((f) => known.has(f)), failingLines: fresh, state, ...(why ? { why } : {}), baselineRed, ...kill };
 }
 /**
  * Operator directive 2026-08-12 (D-OBS-10): tickmarkr is package-manager agnostic.
@@ -785,8 +971,9 @@ export async function captureBaseline(cwd, commands, opts = {}) {
             exitCode: runnerVerdict === "green-teardown" ? 0 : r.code,
             ...(runnerVerdict === "green-teardown" ? { teardownFingerprint: true } : {}),
             // a command that exits 0 has no failures to fingerprint — recording any would be a lie the
-            // compare step then has to forgive
-            fingerprints: r.code === 0 || runnerVerdict === "green-teardown" ? [] : fingerprint(raw),
+            // compare step then has to forgive. S22: one v2 identity per occurrence, sorted.
+            fingerprints: r.code === 0 || runnerVerdict === "green-teardown" ? [] : fingerprintOccurrences(raw).map((o) => o.id).sort(),
+            fingerprintVersion: 2,
             missingCommand: missingConfiguredCommand(cmd, r),
             durationMs,
             ...fileTiming(raw, durationMs),
@@ -840,15 +1027,20 @@ export async function detectVacuousOracles(cwd, tasks) {
 // drop a FAIL line that fingerprint-collides with baseline noise). No headline anchors → byte-identical
 // fallback to today's text (non-vitest runners lose nothing). RED-pinned by tests/gates/baseline.test.ts
 // "HYG-08: details headlines the failing test, not the noise".
-function headlineDetails(raw, fresh) {
+function headlineDetails(raw, fresh, freshLines) {
     const headlines = raw
         .split("\n")
         .map((l) => l.replace(ANSI_RE, ""))
         .filter((l) => namesFailureEitherForm(l) || SUMMARY_FAIL_RE.test(l));
+    // S22: the ORIGINAL runner lines behind v2 comparison keys are the diagnostic; the keys are secondary.
+    // A legacy entry's lines ARE its keys, so its details stay byte-identical.
+    const lines = [...new Set(freshLines)].join("\n");
+    const keys = `new failure fingerprints vs baseline (secondary):\n${fresh.join("\n")}`;
+    const same = lines === fresh.join("\n");
     if (!headlines.length)
-        return { details: `new failures vs baseline:\n${fresh.join("\n")}` };
+        return { details: same ? `new failures vs baseline:\n${lines}` : `new failures vs baseline:\n${lines}\n\n${keys}` };
     return {
-        details: `failing tests:\n${headlines.join("\n")}\n\nnew failure fingerprints vs baseline (secondary):\n${fresh.join("\n")}`,
+        details: `failing tests:\n${headlines.join("\n")}\n\n${same ? "" : `new failure lines vs baseline:\n${lines}\n\n`}${keys}`,
         meta: { failingTests: headlines.filter(namesFailureEitherForm) },
     };
 }
@@ -871,6 +1063,8 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             continue;
         }
         const entry = baseline.commands[name];
+        const entryRead = entryState(entry);
+        const refusal = baselineEntryRefusal(name, entryRead);
         const ceilingMs = effectiveCeilingMs(entry);
         const evidence = beginGateEvidence(cwd, name, cmd, opts.evidence);
         let r;
@@ -902,6 +1096,12 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         let recoveryBlocked;
         const record = (g) => {
             g = { ...g, evidenceReceipt, evidenceReceipts: [...evidence.history, evidenceReceipt] };
+            // S22: every red that read this command's output names a missing or unreadable entry, once, beside
+            // its own cause (infra, deficit, fresh). A ceiling kill is read before the output and forgives
+            // nothing either way; the tip's kill clause is queue row 19's, so neither reader appends it there.
+            if (!g.pass && refusal && g.meta?.kind !== "ceiling-kill") {
+                g = { ...g, details: g.details.includes(refusal) ? g.details : `${g.details}\n\n${refusal}`, meta: { ...g.meta, baselineEntry: entryRead.state } };
+            }
             if (recoveryBlocked)
                 g = { ...g, meta: { ...g.meta, recoveryBlocked } };
             const withReap = r.reapedGroup ? { ...g, meta: { ...g.meta, reapedGroup: true } } : g;
@@ -977,7 +1177,8 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         // below rather than reading as a verified green. Raise the ceiling by teaching isFailureShaped
         // that runner's position rule (leading verdict + identifier, or identifier + separator + trailing
         // verdict); loosening back to vocabulary re-opens OBS-278.
-        const { failing, unreadable, forgiven } = freshFailures(entry, raw);
+        const verdict = freshFailures(entry, raw, name === "test");
+        const { failing, unreadable, forgiven, failingLines, baselineRed, killLine } = verdict;
         // OBS-1123: which baseline-recorded fingerprints this verdict carried, and the capture that
         // recorded them. Observational only — nothing below reads it to decide a verdict.
         const provenance = baseline.provenance ? { baselineProvenance: baseline.provenance } : {};
@@ -1004,7 +1205,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         // OBS-896: every fresh failure must be timeout-class, and the suite must take at least twice its
         // own baseline measurement. The first read buys one calm rerun here, never a worker repair.
         if (name === "test" && classification !== "infra" && failing.length && !rerunOf && !opts.infraRerun
-            && hostStarved(failing.join("\n"), r.durationMs ?? 0, entry?.durationMs)) {
+            && hostStarved(failingLines.join("\n"), r.durationMs ?? 0, entry?.durationMs)) {
             const waitedMs = await waitForCalmWindow(executionSignal());
             if (opts.authorizeRetry && !calmWindowReady()) {
                 recoveryBlocked = "calm window unavailable within the existing wait ceiling";
@@ -1021,8 +1222,8 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             }
         }
         if (classification === "infra") {
-            const evidence = failing.length
-                ? failing.slice(0, 10).join("\n")
+            const evidence = failingLines.length
+                ? failingLines.slice(0, 10).join("\n")
                 : unrecognizedEvidence(raw) || raw.trim().split("\n").slice(0, 10).join("\n");
             record({
                 gate: name,
@@ -1035,17 +1236,19 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         // OBS-534 (T2): only a recorded VERDICT can be forgiven. A green baseline has no red to forgive,
         // and neither has a capture that was killed at its ceiling — it recorded a cause instead, so it
         // fails closed on the same branch rather than reading as "only pre-existing failures". Legacy
-        // entries with no exitCode keep the `?? 1` red default both readers share (merge.ts:131).
-        const baselineRed = entry?.infra !== true && (entry?.exitCode ?? 1) !== 0;
+        // entries with no exitCode keep the `?? 1` red default both readers share (freshFailures'
+        // baselineRed); S22: a missing or unreadable entry forgives nothing and says so.
         if (!failing.length && !baselineRed) {
             const recordedCause = entry?.invalidCause === "infra"
                 ? "was invalidated by its recorded runner-infrastructure cause"
                 : entry?.invalidCause === "resource-exhaustion" || entry?.invalidatingLines?.length
                     ? `was invalidated by its recorded process/resource-exhaustion cause${entry.invalidatingLines?.[0] ? ` (${entry.invalidatingLines[0]})` : ""}`
                     : "was killed at its ceiling";
-            const closed = entry?.infra === true
-                ? `the baseline capture for this command ${recordedCause} and recorded no verdict, so nothing here is forgivable — it now exits ${r.code} with no recognizable failure lines — failing closed`
-                : `command was green at baseline but now exits ${r.code} with no recognizable failure lines — failing closed`;
+            const closed = refusal
+                ? `exit ${r.code}; ${refusal} — nothing is forgiven, failing closed`
+                : entry?.infra === true
+                    ? `the baseline capture for this command ${recordedCause} and recorded no verdict, so nothing here is forgivable — it now exits ${r.code} with no recognizable failure lines — failing closed`
+                    : `command was green at baseline but now exits ${r.code} with no recognizable failure lines — failing closed`;
             const evidence = unrecognizedEvidence(raw);
             record({
                 gate: name,
@@ -1056,7 +1259,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             continue;
         }
         if (failing.length) {
-            const headlined = headlineDetails(raw, failing);
+            const headlined = headlineDetails(raw, failing, failingLines);
             // A fresh red beside baseline-recorded ones names both halves, so no reader shows the new one as forgiven.
             const meta = { ...headlined.meta, ...(classification ? { classification } : {}),
                 ...(forgiven.length ? { freshFingerprints: failing, forgivenFingerprints: forgiven, ...provenance } : {}) };
@@ -1079,11 +1282,22 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             });
             continue;
         }
+        // S19m4: a killed test runner completed no suite, so its familiar failures are no verdict to forgive.
+        if (killLine !== undefined) {
+            record({
+                gate: name,
+                pass: false,
+                details: `infra; exit ${r.code}; every failure is recorded in the baseline, but the runner printed kill text — `
+                    + `it never completed a suite, so nothing is forgiven: ${killLine}`,
+                meta: { classification: "infra", infra: true, retryable: false, kind: "signal-exit", forgivenFingerprints: forgiven, ...provenance },
+            });
+            continue;
+        }
         record({
             gate: name,
             pass: true,
             details: `exit ${r.code} but only pre-existing failures (forgiven)${unreadable ? " — no failure shape recognized in this output, so a new failure from this runner is invisible to the baseline gate" : ""}`,
-            meta: { ...(classification ? { classification } : {}), forgivenFingerprints: forgiven, ...provenance },
+            meta: { ...(classification ? { classification } : {}), forgivenFingerprints: forgiven, ...provenance, ...(name === "test" ? { killTextRead: true } : {}) },
         });
     }
     return results;
@@ -1171,7 +1385,7 @@ export function fileCountDeficit(entry, raw, opts) {
 export function classifyFreshRunnerOutput(entry, raw, code) {
     if (classifyRunnerOutput(raw, code) === "green-teardown")
         return undefined;
-    const { failing } = freshFailures(entry, raw);
-    const verdict = classifyRunnerOutput(failing.length ? failing.join("\n") : raw, code);
+    const { failingLines } = freshFailures(entry, raw);
+    const verdict = classifyRunnerOutput(failingLines.length ? failingLines.join("\n") : raw, code);
     return verdict === "infra" || verdict === "regression" ? verdict : undefined;
 }

package/dist/gates/operation-facts.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Queue row 142 (ANL-021 P7, limited to three facts; D-1843, D-1844): a diff made only of a pure rename, an empty new
+ * file or a mode-only change carries no changed hunk, so the acceptance judge had nothing to cite. These facts come
+ * from TYPED git measurement, read beside the patch text and never from it: no diff --git, rename, mode or new file
+ * header line of the patch is ever an authority here, so a file whose content spells those headers creates nothing.
+ *
+ * Measurement: the worktree HEAD is resolved to one commit, then tickmarkr's own-git runner reads
+ * `git diff --raw -z --no-abbrev -M <baseRef>..<commit>` with stdout captured as BYTES. -M forces rename detection
+ * whatever diff.renames says in repository, global or inherited (GIT_CONFIG_*) configuration, and no copy option is
+ * passed; nothing else is configured. -z makes git print every path verbatim (never C-quoted, so core.quotePath is
+ * irrelevant), and the bytes are split on NUL before any decoding, so no name can move a record boundary.
+ *
+ * Closed record grammar, every field NUL-terminated:
+ *   ':' oldmode SP newmode SP oldhash SP newhash SP status NUL path NUL [path NUL — exactly when status is R or C]
+ * modes are six octal digits, hashes 40 or 64 lowercase hex, status one of A C D M R T U X, and R and C (only they)
+ * carry exactly three score digits. A header outside the grammar, an empty path or a truncated record ends the read
+ * with NO facts at all. Each path is decoded by a FATAL UTF-8 decoder (BOM kept): a name that is not valid UTF-8
+ * makes its record no fact, so a lossy U+FFFD rendering can never authorize a valid U+FFFD-named file beside it.
+ *
+ * The closed fact table — each fact is line 0 of its exact path:
+ *   pure rename       R100, equal blob ids and equal modes; the fact names the destination (never the source)
+ *   empty add         A whose blob id equals this repository's empty blob (git hash-object -t blob /dev/null)
+ *   mode-only change  M, equal blob ids, modes 100644 and 100755 exchanged
+ * Every other record is no fact: binary adds and modifications (git's binary decision follows worker-writable
+ * attributes, and the judge cannot read the content), deletions (an empty file's included), renames below 100 or with
+ * a mode change, copies, type changes and every other status. A non-zero or killed read gives no facts, and so does a
+ * HEAD that resolves to another commit after the judged diff was read (operationFactsAtHead).
+ */
+export type OperationFactKind = "pure rename" | "empty add" | "mode-only change";
+export interface OperationFact {
+    kind: OperationFactKind;
+    path: string;
+}
+export type OperationFactsRead = {
+    ok: true;
+    commit: string;
+    facts: OperationFact[];
+} | {
+    ok: false;
+    error: string;
+};
+/** The facts in raw `-z` output, or null when any record falls outside the closed grammar. */
+export declare function parseOperationFacts(raw: Buffer, emptyBlob: string): OperationFact[] | null;
+/** Reads the typed operation facts of `<baseRef>..HEAD`, bound to the commit HEAD resolved to. Never throws. */
+export declare function readOperationFacts(worktree: string, baseRef: string): Promise<OperationFactsRead>;
+/** The read's facts only while HEAD still resolves to the commit they measured; call it after the judged diff is read. */
+export declare function operationFactsAtHead(worktree: string, read: OperationFactsRead): Promise<OperationFact[]>;

package/dist/gates/operation-facts.js

@@ -0,0 +1,84 @@
+import { shq } from "../adapters/types.js";
+import { shGit } from "../run/git.js";
+const RECORD_HEADER = /^:([0-7]{6}) ([0-7]{6}) ([0-9a-f]{40}|[0-9a-f]{64}) ([0-9a-f]{40}|[0-9a-f]{64}) ([RC][0-9]{3}|[ADMTUX])$/;
+const EXECUTABLE_EXCHANGE = new Set(["100644", "100755"]);
+function decodeName(bytes) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+/** The facts in raw `-z` output, or null when any record falls outside the closed grammar. */
+export function parseOperationFacts(raw, emptyBlob) {
+    const fields = [];
+    for (let start = 0; start < raw.length;) {
+        const end = raw.indexOf(0, start);
+        if (end < 0)
+            return null; // a field git did not terminate: truncated output
+        fields.push(raw.subarray(start, end));
+        start = end + 1;
+    }
+    const facts = [];
+    for (let i = 0; i < fields.length;) {
+        // latin1 maps each byte to one code point, so a non-ASCII byte can never satisfy the ASCII header grammar
+        const header = RECORD_HEADER.exec(fields[i].toString("latin1"));
+        if (!header)
+            return null;
+        const [, oldMode, newMode, oldId, newId, status] = header;
+        const count = status[0] === "R" || status[0] === "C" ? 2 : 1;
+        const paths = fields.slice(i + 1, i + 1 + count);
+        if (paths.length !== count || paths.some((path) => path.length === 0))
+            return null;
+        i += 1 + count;
+        const names = paths.map(decodeName);
+        if (names.some((name) => name === null))
+            continue;
+        const path = names[count - 1];
+        if (status === "R100" && oldId === newId && oldMode === newMode)
+            facts.push({ kind: "pure rename", path });
+        else if (status === "A" && newId === emptyBlob)
+            facts.push({ kind: "empty add", path });
+        else if (status === "M" && oldId === newId && oldMode !== newMode && EXECUTABLE_EXCHANGE.has(oldMode) && EXECUTABLE_EXCHANGE.has(newMode)) {
+            facts.push({ kind: "mode-only change", path });
+        }
+    }
+    return facts;
+}
+async function resolveHead(worktree) {
+    const head = await shGit("git rev-parse --verify --end-of-options 'HEAD^{commit}'", worktree);
+    return head.code === 0 && !head.timedOut ? head.stdout.trim() : null;
+}
+/** Reads the typed operation facts of `<baseRef>..HEAD`, bound to the commit HEAD resolved to. Never throws. */
+export async function readOperationFacts(worktree, baseRef) {
+    try {
+        const commit = await resolveHead(worktree);
+        if (!commit)
+            return { ok: false, error: "HEAD did not resolve to a commit" };
+        // --no-filters: the empty blob is git's, never a clean filter's output under a worker-written attribute
+        const empty = await shGit("git hash-object -t blob --no-filters /dev/null", worktree);
+        if (empty.code !== 0 || empty.timedOut)
+            return { ok: false, error: `git hash-object exited ${empty.code}` };
+        const raw = await shGit(`git diff --raw -z --no-abbrev -M ${shq(`${baseRef}..${commit}`)} --`, worktree, undefined, {}, { bytes: true });
+        if (raw.code !== 0 || raw.signalExit || raw.timedOut || !raw.stdoutBytes) {
+            return { ok: false, error: `git diff --raw exited ${raw.code}${raw.signalExit ? " (killed)" : ""}` };
+        }
+        const facts = parseOperationFacts(raw.stdoutBytes, empty.stdout.trim());
+        return facts ? { ok: true, commit, facts } : { ok: false, error: "a raw diff record is outside the closed grammar" };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** The read's facts only while HEAD still resolves to the commit they measured; call it after the judged diff is read. */
+export async function operationFactsAtHead(worktree, read) {
+    if (!read.ok)
+        return [];
+    try {
+        return (await resolveHead(worktree)) === read.commit ? read.facts : [];
+    }
+    catch {
+        return [];
+    }
+}