tickmarkr 2.5.8 → 2.5.9

package/dist/config/config.js

@@ -87,9 +87,50 @@ const PrefBlockSchema = z.object({
     adapters: z.array(z.string()).optional(),
     models: z.array(z.string()).optional(),
 });
-const DenyBlockSchema = PrefBlockSchema.extend({
+// exported so a test can extend the PRODUCTION deny shape and watch the enumeration grow (OBS-1099 add.1)
+export const DenyBlockSchema = PrefBlockSchema.extend({
     workers: PrefBlockSchema.optional(),
 });
+export function denyScopesOf(schema, segments = []) {
+    const unwrap = (t) => t instanceof z.ZodOptional ? unwrap(t.unwrap()) : t;
+    return Object.entries(schema.shape).flatMap(([name, type]) => {
+        const inner = unwrap(type);
+        const below = [...segments, name];
+        if (inner instanceof z.ZodObject)
+            return denyScopesOf(inner, below);
+        if (!(inner instanceof z.ZodArray))
+            return [];
+        const path = ["routing", "deny", ...below];
+        return [{ key: `deny${below.map((s) => s[0].toUpperCase() + s.slice(1)).join("")}`, path, dotted: path.join(".") }];
+    });
+}
+export const DENY_SCOPES = denyScopesOf(DenyBlockSchema);
+export const stagedDenyKeyOf = (scope) => (scope.key[4].toLowerCase() + scope.key.slice(5));
+export const initialDenyPropOf = (scope) => `initial${scope.key[0].toUpperCase()}${scope.key.slice(1)}`;
+/** the authored list at one deny scope of a routing block, undefined when the scope is absent */
+export function denyEntriesAt(routing, scope) {
+    let cur = routing;
+    for (const segment of scope.path.slice(1)) {
+        if (cur === undefined || cur === null || typeof cur !== "object")
+            return undefined;
+        cur = cur[segment];
+    }
+    return Array.isArray(cur) ? cur : undefined;
+}
+/** a routing.deny block built from per-scope lists (absent or empty lists are left out) */
+export function denyBlockFrom(lists) {
+    const block = {};
+    for (const scope of DENY_SCOPES) {
+        const entries = lists[scope.key];
+        if (!entries?.length)
+            continue;
+        let cur = block;
+        for (const segment of scope.path.slice(2, -1))
+            cur = (cur[segment] ??= {});
+        cur[scope.path[scope.path.length - 1]] = [...entries];
+    }
+    return block;
+}
 // v1.20 REC-02: operator-maintained price table for the usage/cost report (src/report/cost.ts). Two
 // channel economics, never conflated (spec cost model): API = tokens × per-Mtok rate; sub = flat plan
 // amortized over a windows/month RANGE (+ an API-equivalent counterfactual when the model has a rate).
@@ -924,8 +965,8 @@ export function fleetEditableFromConfig(cfg, universe) {
             tiers[adapter][model] = { tier };
         }
     }
-    const denyAdapters = [...(cfg.routing.deny?.adapters ?? [])].sort();
-    const denyModels = [...(cfg.routing.deny?.models ?? [])].sort();
+    // every enumerated deny scope rides verbatim (sorted) under its own key
+    const denyLists = Object.fromEntries(DENY_SCOPES.map((scope) => [scope.key, [...(denyEntriesAt(cfg.routing, scope) ?? [])].sort()]));
     let allowOut;
     if (universe !== undefined) {
         const { allow } = cfg.routing;
@@ -947,13 +988,8 @@ export function fleetEditableFromConfig(cfg, universe) {
         allowOut = [...new Set([...adaptersOut, ...modelsOut])].sort();
     }
     return {
-        denyAdapters,
-        denyModels,
+        ...denyLists,
         ...(allowOut !== undefined ? { allowOut } : {}),
-        // OBS-994: workers-only deny is never folded into the all-seats complement above — it is
-        // returned verbatim beside the flat scopes so the fleet browser can show and toggle it.
-        denyWorkersAdapters: [...(cfg.routing.deny?.workers?.adapters ?? [])].sort(),
-        denyWorkersModels: [...(cfg.routing.deny?.workers?.models ?? [])].sort(),
         tiers,
         map: structuredClone(cfg.routing.map),
         floors: { ...cfg.routing.floors },
@@ -992,14 +1028,9 @@ export function formatFleetPrint(repoRoot, opts = {}) {
             node.comment = ` ${fleetKeyLayer(repoRoot, dotted, opts)}`;
         }
     };
-    if (effective.routing.deny?.adapters !== undefined)
-        annotate(["routing", "deny", "adapters"]);
-    if (effective.routing.deny?.models !== undefined)
-        annotate(["routing", "deny", "models"]);
-    if (effective.routing.deny?.workers?.adapters !== undefined)
-        annotate(["routing", "deny", "workers", "adapters"]);
-    if (effective.routing.deny?.workers?.models !== undefined)
-        annotate(["routing", "deny", "workers", "models"]);
+    for (const scope of DENY_SCOPES)
+        if (denyEntriesAt(effective.routing, scope) !== undefined)
+            annotate(scope.path);
     for (const shape of Object.keys(effective.routing.map))
         annotate(["routing", "map", shape]);
     annotate(["routing", "floors"]);

package/dist/config/fleet-overlay.js

@@ -1,6 +1,13 @@
 // Fleet-overlay mutation, serialization, and diff rendering for the `tickmarkr fleet` write path.
 import { isMap, isScalar, isSeq, parseDocument, stringify, visit } from "yaml";
-import { universeCovers, universeEntryMatches } from "./config.js";
+import { DENY_SCOPES, universeCovers, universeEntryMatches } from "./config.js";
+// OBS-1099 add.1: the writer ranges over the schema-derived scopes. The flat (all-seats) scopes
+// take part in the membership/allow-form write; every nested scope (routing.deny.workers.*) is a
+// literal deny list written on its own. ponytail: "flat" = directly under routing.deny. Read
+// lazily: config.ts imports this module, so the enumeration is not initialized at load time.
+const flatDenyScopes = () => DENY_SCOPES.filter((scope) => scope.path.length === 3);
+const nestedDenyScopes = () => DENY_SCOPES.filter((scope) => scope.path.length > 3);
+const listsOf = (write, scope) => [write.initial[scope.key] ?? [], write.edited[scope.key] ?? []];
 /** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
 export const FLEET_OVERLAY_KEYS = ["routing", "tiers"];
 function fleetSubset(obj) {
@@ -24,7 +31,7 @@ function allowFormFromExclusions(universe, edited) {
     // LEG2-T3 round 2 finding 1: every staged entry excludes what it NAMES — a bare model id every
     // adapter serving it, an identity its alias — never only an adapter id or an adapter:model key.
     // OBS-1046: the staged allow complement is a reason of its own, beside the authored deny lists.
-    const entries = [...edited.denyAdapters, ...edited.denyModels, ...(edited.allowOut ?? [])];
+    const entries = [...flatDenyScopes().flatMap((scope) => edited[scope.key] ?? []), ...(edited.allowOut ?? [])];
     const adapters = [];
     const models = [];
     let excluded = false;
@@ -190,9 +197,9 @@ export function renderFleetOverlayWrite(priorBytes, write) {
     // OBS-1046: each flat scope (and the allow complement) is compared on its own — a scope the
     // session never edited keeps its node byte for byte, whatever its sibling did.
     const changed = (before = [], after = []) => sortedUnique(before).join() !== sortedUnique(after).join();
-    const adaptersChanged = changed(initial.denyAdapters, edited.denyAdapters);
-    const modelsChanged = changed(initial.denyModels, edited.denyModels);
-    if (adaptersChanged || modelsChanged || changed(initial.allowOut, edited.allowOut)) {
+    const FLAT_DENY_SCOPES = flatDenyScopes();
+    const flatChanged = new Map(FLAT_DENY_SCOPES.map((scope) => [scope.key, changed(...listsOf(write, scope))]));
+    if ([...flatChanged.values()].some(Boolean) || changed(initial.allowOut, edited.allowOut)) {
         if (write.universe) {
             // Membership write: the allow form IS the fleet; deny adapters/models scopes are tombstoned
             // so a lower layer can never re-exclude behind the operator's back (workers untouched).
@@ -230,15 +237,13 @@ export function renderFleetOverlayWrite(priorBytes, write) {
             // LEG2-T3 finding 4: an authored entry the edit admits (staged nowhere any more) must go
             // even from a scope whose own set did not change, or the admitted channel stays excluded
             // behind the preserved bytes.
-            const stagedAfter = new Set([...edited.denyAdapters, ...edited.denyModels, ...(edited.allowOut ?? [])]);
-            const admitted = [...initial.denyAdapters, ...initial.denyModels, ...(initial.allowOut ?? [])]
+            const stagedAfter = new Set([...FLAT_DENY_SCOPES.flatMap((scope) => edited[scope.key] ?? []), ...(edited.allowOut ?? [])]);
+            const admitted = [...FLAT_DENY_SCOPES.flatMap((scope) => initial[scope.key] ?? []), ...(initial.allowOut ?? [])]
                 .filter((entry) => !stagedAfter.has(entry));
-            const scopes = [
-                ["adapters", initial.denyAdapters, edited.denyAdapters, adaptersChanged],
-                ["models", initial.denyModels, edited.denyModels, modelsChanged],
-            ];
-            for (const [scope, before, after, touched] of scopes) {
-                const path = ["routing", "deny", scope];
+            for (const scope of FLAT_DENY_SCOPES) {
+                const [before, after] = listsOf(write, scope);
+                const touched = flatChanged.get(scope.key);
+                const path = scope.path;
                 const authored = authoredEntries(doc, path);
                 const stale = authored.some((entry) => admitted.includes(entry));
                 if (!touched && !stale)
@@ -254,28 +259,24 @@ export function renderFleetOverlayWrite(priorBytes, write) {
             }
         }
         else {
-            if (adaptersChanged) {
-                setStringSequencePreservingComments(doc, ["routing", "deny", "adapters"], edited.denyAdapters.length ? sortedUnique(edited.denyAdapters) : null);
-            }
-            if (modelsChanged) {
-                setStringSequencePreservingComments(doc, ["routing", "deny", "models"], edited.denyModels.length ? sortedUnique(edited.denyModels) : null);
+            for (const scope of FLAT_DENY_SCOPES) {
+                if (!flatChanged.get(scope.key))
+                    continue;
+                const after = edited[scope.key] ?? [];
+                setStringSequencePreservingComments(doc, scope.path, after.length ? sortedUnique(after) : null);
             }
         }
     }
     // OBS-994/FL-1: routing.deny.workers is a literal deny list, never a universe-derived
     // membership scope — it never routes through the allow-complement dance above, in either
-    // branch. Same tombstone/comment-preserving rules as the flat scopes.
-    const initialWorkersAdapters = initial.denyWorkersAdapters ?? [];
-    const editedWorkersAdapters = edited.denyWorkersAdapters ?? [];
-    const initialWorkersModels = initial.denyWorkersModels ?? [];
-    const editedWorkersModels = edited.denyWorkersModels ?? [];
-    // Each sub-path mutates independently — an untouched sibling must not be rewritten (a `null`
-    // tombstone over an absent/untouched sibling would mask a lower layer's own workers scope).
-    if (sortedUnique(initialWorkersAdapters).join() !== sortedUnique(editedWorkersAdapters).join()) {
-        setStringSequencePreservingComments(doc, ["routing", "deny", "workers", "adapters"], editedWorkersAdapters.length ? sortedUnique(editedWorkersAdapters) : null);
-    }
-    if (sortedUnique(initialWorkersModels).join() !== sortedUnique(editedWorkersModels).join()) {
-        setStringSequencePreservingComments(doc, ["routing", "deny", "workers", "models"], editedWorkersModels.length ? sortedUnique(editedWorkersModels) : null);
+    // branch. Same tombstone/comment-preserving rules as the flat scopes. Each nested scope
+    // mutates independently — an untouched sibling must not be rewritten (a `null` tombstone over
+    // an absent/untouched sibling would mask a lower layer's own workers scope).
+    for (const scope of nestedDenyScopes()) {
+        const [before, after] = listsOf(write, scope);
+        if (!changed(before, after))
+            continue;
+        setStringSequencePreservingComments(doc, scope.path, after.length ? sortedUnique(after) : null);
     }
     for (const shape of new Set([...Object.keys(initial.map), ...Object.keys(edited.map)])) {
         const before = initial.map[shape];
@@ -420,8 +421,11 @@ export function fleetRepoOverlayFromDelta(initial, edited, existingRepo = {}, fi
     const out = structuredClone(existingRepo);
     const routing = { ...out.routing };
     let routingTouched = false;
-    const denyChanged = sortedUnique(initial.denyAdapters).join() !== sortedUnique(edited.denyAdapters).join()
-        || sortedUnique(initial.denyModels).join() !== sortedUnique(edited.denyModels).join()
+    // OBS-1099 add.1: the flat scopes (routing.deny.<leaf>) and the allow complement are one
+    // membership write; a list or its tombstone lands at every flat scope the enumeration names
+    const changedAt = (scope) => sortedUnique(initial[scope.key] ?? []).join() !== sortedUnique(edited[scope.key] ?? []).join();
+    const listOrTombstone = (entries) => entries.length ? entries : null;
+    const denyChanged = flatDenyScopes().some(changedAt)
         || sortedUnique(initial.allowOut ?? []).join() !== sortedUnique(edited.allowOut ?? []).join();
     if (denyChanged) {
         if (universe) {
@@ -434,44 +438,25 @@ export function fleetRepoOverlayFromDelta(initial, edited, existingRepo = {}, fi
             }
             else
                 delete routing.allow;
-            const residualAdapters = residualDeny(universe, edited.denyAdapters);
-            const residualModels = residualDeny(universe, edited.denyModels);
             routing.deny = {
                 ...routing.deny,
-                adapters: residualAdapters.length ? residualAdapters : null,
-                models: residualModels.length ? residualModels : null,
+                ...Object.fromEntries(flatDenyScopes().map((scope) => [scope.path[scope.path.length - 1], listOrTombstone(residualDeny(universe, edited[scope.key] ?? []))])),
             };
         }
         else {
-            routing.deny = {
-                adapters: edited.denyAdapters.length ? edited.denyAdapters : null,
-                models: edited.denyModels.length ? edited.denyModels : null,
-            };
+            routing.deny = Object.fromEntries(flatDenyScopes().map((scope) => [scope.path[scope.path.length - 1], listOrTombstone(edited[scope.key] ?? [])]));
         }
         routingTouched = true;
     }
-    // OBS-994/FL-1: workers deny is a literal list, independent of the universe/allow dance above.
-    // Each sub-path is included only when it actually changed — an untouched sibling must not be
-    // rewritten as a `null` tombstone over whatever the existing repo overlay already held.
-    const initialWorkersAdapters = initial.denyWorkersAdapters ?? [];
-    const editedWorkersAdapters = edited.denyWorkersAdapters ?? [];
-    const initialWorkersModels = initial.denyWorkersModels ?? [];
-    const editedWorkersModels = edited.denyWorkersModels ?? [];
-    const workersAdaptersChanged = sortedUnique(initialWorkersAdapters).join() !== sortedUnique(editedWorkersAdapters).join();
-    const workersModelsChanged = sortedUnique(initialWorkersModels).join() !== sortedUnique(editedWorkersModels).join();
-    if (workersAdaptersChanged || workersModelsChanged) {
-        routing.deny = {
-            ...routing.deny,
-            workers: {
-                ...(routing.deny?.workers),
-                ...(workersAdaptersChanged
-                    ? { adapters: editedWorkersAdapters.length ? editedWorkersAdapters : null }
-                    : {}),
-                ...(workersModelsChanged
-                    ? { models: editedWorkersModels.length ? editedWorkersModels : null }
-                    : {}),
-            },
-        };
+    // OBS-994/FL-1: a nested scope (routing.deny.workers.*) is a literal list, independent of the
+    // universe/allow dance above. Each sub-path is included only when it actually changed — an
+    // untouched sibling must not be rewritten as a `null` tombstone over whatever the existing repo
+    // overlay already held.
+    for (const scope of nestedDenyScopes().filter(changedAt)) {
+        let cur = (routing.deny = { ...routing.deny });
+        for (const segment of scope.path.slice(2, -1))
+            cur = (cur[segment] = { ...cur[segment] });
+        cur[scope.path[scope.path.length - 1]] = listOrTombstone(edited[scope.key] ?? []);
         routingTouched = true;
     }
     // pool widened to accept the null tombstone; MapEntry itself never carries null in memory.

package/dist/gates/baseline.d.ts

@@ -1,3 +1,4 @@
+import { type EvidenceArtifact, type GateEvidenceReceipt, type ShellReceipt } from "../run/protocol.js";
 import type { TickmarkrConfig } from "../config/config.js";
 import type { AcceptanceItem } from "../graph/schema.js";
 import { type RunCapacity, type ShellOptions, type ShResult } from "../run/git.js";
@@ -13,8 +14,69 @@ import type { GateResult } from "./types.js";
 declare module "./types.js" {
     interface GateResult {
         capacity?: RunCapacity;
+        evidenceReceipt?: GateEvidenceReceipt;
+        evidenceReceipts?: GateEvidenceReceipt[];
     }
 }
+/** Evidence is observational: the command verdict never depends on this store. */
+export interface GateEvidenceOptions {
+    artifactDir?: string;
+    runId?: string;
+    taskId?: string;
+    attempt?: number;
+    subjectCommit?: string;
+    quotaBytes?: number;
+    env?: NodeJS.ProcessEnv;
+    /** Injectable storage boundary; mandatory manifest/reporter writes do not use it. */
+    write?: (path: string, bytes: Buffer) => void;
+}
+export declare const EVIDENCE_TAIL_BYTES: number;
+export declare const EVIDENCE_RUN_QUOTA_BYTES: number;
+export declare function redactGateOutput(text: string, env: NodeJS.ProcessEnv): string;
+/** Resolve a snapshot reference against actual bytes: eviction never fabricates a live artifact. */
+export declare function resolveEvidenceArtifact(root: string, ref: EvidenceArtifact): EvidenceArtifact;
+export declare function beginGateEvidence(cwd: string, gate: string, command: string, opts?: GateEvidenceOptions, nonce?: string): {
+    root: string;
+    history: {
+        invocationId: string;
+        subject: {
+            runId: string;
+            taskId: string | null;
+            attempt: number | null;
+            gate: string;
+            subjectCommit: string | null;
+        };
+        termination: {
+            kind: "unknown" | "signal" | "not-started" | "exit" | "timeout";
+            exitCode: number | null;
+            signal: string | null;
+            timedOut: boolean | null;
+        };
+        availability: "available" | "not-started" | "capture-failed" | "killed" | "expired" | "missing";
+        redaction: {
+            material: boolean;
+        };
+        stdout: {
+            path: string;
+            availability: "available" | "not-started" | "capture-failed" | "killed" | "expired" | "missing";
+            sha256: string | null;
+            retainedBytes: number;
+            droppedBytes: number;
+            truncated: boolean;
+        };
+        stderr: {
+            path: string;
+            availability: "available" | "not-started" | "capture-failed" | "killed" | "expired" | "missing";
+            sha256: string | null;
+            retainedBytes: number;
+            droppedBytes: number;
+            truncated: boolean;
+        };
+        nonce?: string | undefined;
+    }[];
+    observe(receipt: ShellReceipt): void;
+    finish(stdout?: string, stderr?: string): GateEvidenceReceipt;
+};
 export interface BaselineCommand {
     /**
      * Absent when the capture returned no verdict — see `infra`. A pre-v1.90 baseline can also lack it
@@ -66,6 +128,8 @@ export interface BaselineFileDuration {
     durationMs: number;
 }
 export interface Baseline {
+    /** Observational capture receipts stay outside the forgiveness-bearing command entries. */
+    evidenceReceipts?: Record<string, GateEvidenceReceipt>;
     commands: Record<string, BaselineCommand>;
     warnings?: BaselineWarning[];
 }
@@ -158,6 +222,7 @@ export declare const CAPTURE_CEILING_MS = 1800000;
  * count is safe to apply as a deficit floor. A null count compares nothing and is safe as-is. */
 export declare function staleFileCountCommands(baseline: Baseline, commands: Record<string, string>, cwd: string): string[];
 export interface BaselineReceiptOptions {
+    evidence?: GateEvidenceOptions;
     onReceipt?: ShellOptions["onReceipt"];
     /** Only comparison's build command may carry task-build identity; capture never does. */
     taskBuildAttribution?: ShellOptions["receiptAttribution"];

package/dist/gates/baseline.js

@@ -1,9 +1,140 @@
-import { existsSync, readFileSync } from "node:fs";
-import { availableParallelism, loadavg } from "node:os";
+import { createHash, randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync, rmdirSync } from "node:fs";
+import { availableParallelism, loadavg, tmpdir } from "node:os";
 import { join } from "node:path";
 import { DEFAULT_SHELL_TIMEOUT_MS, describeCapacity, sameCapacity, sh } from "../run/git.js";
 import { executionSignal } from "../run/execution-budget.js";
 import { isVitestTestCommand, manifestFileCount } from "./test-manifest.js";
+export const EVIDENCE_TAIL_BYTES = 16 * 1024;
+export const EVIDENCE_RUN_QUOTA_BYTES = 8 * 1024 * 1024;
+export function redactGateOutput(text, env) {
+    // One pass over the original bytes: replacing an environment value must not break a token
+    // recognizer, and a short environment value must not rewrite the redaction marker itself.
+    // Short operational values (0, true, vi, test) occur throughout ordinary diagnostics.
+    // Only secret-named keys justify redacting short values.
+    const values = [...new Set(Object.entries(env)
+            .filter(([key, value]) => !!value && (value.length >= 8 || /KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|AUTH/i.test(key)))
+            .map(([, value]) => value))]
+        .sort((a, b) => b.length - a.length).map(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"']+`;
+    return text.replace(new RegExp([tokens, assignments, ...values].join("|"), "gi"), "[REDACTED]");
+}
+/** Resolve a snapshot reference against actual bytes: eviction never fabricates a live artifact. */
+export function resolveEvidenceArtifact(root, ref) {
+    if (ref.availability !== "available")
+        return ref;
+    if (ref.path.startsWith("/") || ref.path.includes("\\") || ref.path.split("/").includes(".."))
+        return { ...ref, availability: "missing" };
+    try {
+        const bytes = readFileSync(join(root, ref.path));
+        return bytes.length === ref.retainedBytes && createHash("sha256").update(bytes).digest("hex") === ref.sha256
+            ? ref : { ...ref, availability: "missing" };
+    }
+    catch {
+        return { ...ref, availability: "missing" };
+    }
+}
+export function beginGateEvidence(cwd, gate, command, opts = {}, nonce) {
+    let invocationId = nonce ?? randomUUID();
+    let artifactId = /^[a-zA-Z0-9-]+$/.test(invocationId) ? invocationId : createHash("sha256").update(invocationId).digest("hex");
+    let subjectCommit = opts.subjectCommit ?? null;
+    if (!subjectCommit) {
+        try {
+            subjectCommit = execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        }
+        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];
+    }
+    let observed;
+    let pendingId;
+    const history = [];
+    return {
+        root, history,
+        observe(receipt) {
+            if (pendingId) {
+                history.push(this.finish());
+                invocationId = pendingId;
+                artifactId = pendingId;
+                pendingId = undefined;
+            }
+            observed = receipt;
+            // A shell-internal pre-spawn retry receives an id before it executes too. Keep the failed
+            // attempt current until a later observation proves that the shell actually tried again.
+            if (receipt.outcome === "spawn-failed")
+                pendingId = randomUUID();
+        },
+        finish(stdout = "", stderr = "") {
+            const termination = {
+                kind: !observed ? "unknown" : !observed.confirmedStart ? "not-started" : observed.outcome === "timed-out" ? "timeout" : observed.signal ? "signal" : observed.exitCode != null ? "exit" : "unknown",
+                exitCode: observed?.exitCode ?? null, signal: observed?.signal ?? null,
+                timedOut: observed ? observed.outcome === "timed-out" : null,
+            };
+            const clean = [redactGateOutput(stdout, env), redactGateOutput(stderr, env)];
+            const refs = clean.map((text, i) => {
+                const bytes = Buffer.from(text);
+                const tail = bytes.subarray(-EVIDENCE_TAIL_BYTES);
+                return { path: `gate-evidence/${artifactId}-${i === 0 ? "stdout" : "stderr"}.log`,
+                    availability: termination.kind === "not-started" ? "not-started" : "available",
+                    sha256: termination.kind === "not-started" ? null : createHash("sha256").update(tail).digest("hex"), retainedBytes: tail.length,
+                    droppedBytes: bytes.length - tail.length, truncated: bytes.length > tail.length };
+            });
+            let availability = termination.kind === "not-started" ? "not-started" : "available";
+            if (availability === "available") {
+                let lock;
+                try {
+                    const dir = join(root, "gate-evidence");
+                    mkdirSync(dir, { recursive: true });
+                    mkdirSync(join(dir, ".write-lock"));
+                    lock = join(dir, ".write-lock");
+                    const quota = opts.quotaBytes !== undefined && Number.isFinite(opts.quotaBytes)
+                        ? Math.max(0, Math.floor(opts.quotaBytes)) : EVIDENCE_RUN_QUOTA_BYTES;
+                    const files = readdirSync(dir).filter(f => /^[a-zA-Z0-9-]+-(stdout|stderr)\.log$/.test(f)).map(f => ({ path: join(dir, f), stat: statSync(join(dir, f)) }))
+                        .sort((a, b) => a.stat.mtimeMs - b.stat.mtimeMs || a.path.localeCompare(b.path));
+                    let total = files.reduce((sum, f) => sum + f.stat.size, 0);
+                    const incoming = refs.reduce((sum, ref) => sum + ref.retainedBytes, 0);
+                    if (incoming > quota)
+                        throw new Error("evidence quota cannot retain this invocation");
+                    while (files.length && total + incoming > quota) {
+                        const oldest = files.shift();
+                        unlinkSync(oldest.path);
+                        total -= oldest.stat.size;
+                    }
+                    for (const [i, ref] of refs.entries()) {
+                        (opts.write ?? writeFileSync)(join(root, ref.path), Buffer.from(clean[i]).subarray(-EVIDENCE_TAIL_BYTES));
+                    }
+                }
+                catch {
+                    availability = "capture-failed";
+                    for (const ref of refs) {
+                        ref.availability = "capture-failed";
+                        ref.sha256 = null;
+                        try {
+                            unlinkSync(join(root, ref.path));
+                        }
+                        catch { /* best effort cleanup */ }
+                    }
+                }
+                finally {
+                    if (lock) {
+                        try {
+                            rmdirSync(lock);
+                        }
+                        catch { /* observational cleanup */ }
+                    }
+                }
+            }
+            return { invocationId, ...(nonce ? { nonce } : {}),
+                subject: { runId: opts.runId ?? "standalone", taskId: opts.taskId ?? null, attempt: opts.attempt ?? null, gate, subjectCommit },
+                termination, availability, redaction: { material: clean[0] !== stdout || clean[1] !== stderr }, stdout: refs[0], stderr: refs[1] };
+        },
+    };
+}
 // incident #2 (run-20260709-104447): a vitest ✓ PASS line with "error" in the test NAME, wrapped in ANSI
 // codes that varied between baseline and worktree runs, was reported as a "new failure". Strip ANSI first;
 // a pass-marker line is never a failure. [\d;#] covers raw ANSI and digit-normalized ANSI ("\x1b[#m") from
@@ -493,7 +624,9 @@ export async function captureBaseline(cwd, commands, opts = {}) {
         if (name === "tipTest" && commands.test !== undefined && cmd === commands.test) {
             continue;
         }
-        const r = await sh(cmd, cwd, CAPTURE_CEILING_MS, { onReceipt: opts.onReceipt });
+        const evidence = beginGateEvidence(cwd, name, cmd, opts.evidence);
+        const r = await sh(cmd, cwd, CAPTURE_CEILING_MS, { env: opts.evidence?.env, onReceipt: receipt => { evidence.observe(receipt); opts.onReceipt?.(receipt); } });
+        (base.evidenceReceipts ??= {})[name] = evidence.finish(r.stdout, r.stderr);
         // ponytail: strip the executing cwd so repo-root capture and worktree compare fingerprint identically; /private-vs-/tmp symlink variance is out of scope
         // ponytail: a capture that was itself killed records the ceiling as its "measurement", which
         // scales the next ceiling up — the right direction for a suite that never finished once.
@@ -634,15 +767,36 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         }
         const entry = baseline.commands[name];
         const ceilingMs = effectiveCeilingMs(entry);
-        const r = await sh(cmd, cwd, ceilingMs, {
-            onReceipt: opts.onReceipt,
-            ...(name === "build" ? { receiptAttribution: opts.taskBuildAttribution } : {}),
-        });
+        const evidence = beginGateEvidence(cwd, name, cmd, opts.evidence);
+        let r;
+        try {
+            r = await sh(cmd, cwd, ceilingMs, {
+                env: opts.evidence?.env,
+                onReceipt: receipt => { evidence.observe(receipt); opts.onReceipt?.(receipt); },
+                ...(name === "build" ? { receiptAttribution: opts.taskBuildAttribution } : {}),
+            });
+        }
+        catch (error) {
+            const evidenceReceipt = evidence.finish();
+            // A launch refusal is infrastructure; cancellation and other thrown control flow still unwind.
+            if (evidenceReceipt.termination.kind !== "not-started" || executionSignal()?.aborted)
+                throw error;
+            results.push({ gate: name, pass: false, details: `infra; command failed to launch: ${String(error)}`,
+                meta: { classification: "infra", infra: true }, evidenceReceipt, evidenceReceipts: [...evidence.history, evidenceReceipt] });
+            continue;
+        }
+        const evidenceReceipt = evidence.finish(r.stdout, r.stderr);
+        if (evidenceReceipt.termination.kind === "not-started") {
+            results.push({ gate: name, pass: false, details: `infra; command failed to launch: ${r.stderr}`,
+                meta: { classification: "infra", infra: true }, evidenceReceipt, evidenceReceipts: [...evidence.history, evidenceReceipt] });
+            continue;
+        }
         // T7: every verdict below carries the capacity ITS OWN command ran under, taken off the shell
         // result rather than re-derived after the fact. The skip row above ran no command and therefore
         // states no capacity — a row that never divided the machine must not claim that it did.
         let recoveryBlocked;
         const record = (g) => {
+            g = { ...g, evidenceReceipt, evidenceReceipts: [...evidence.history, evidenceReceipt] };
             if (recoveryBlocked)
                 g = { ...g, meta: { ...g.meta, recoveryBlocked } };
             const withReap = r.reapedGroup ? { ...g, meta: { ...g.meta, reapedGroup: true } } : g;
@@ -735,7 +889,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             }
             else {
                 const provenance = { durationMs: r.durationMs ?? 0, referenceMs: entry?.durationMs ?? 0, waitedMs };
-                results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, infraRerun: provenance }));
+                results.push(...(await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, infraRerun: provenance })).map(row => ({ ...row, evidenceReceipts: [...evidence.history, evidenceReceipt, ...(row.evidenceReceipts ?? [])] })));
                 continue;
             }
         }
@@ -754,7 +908,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
                 // Compatibility with OBS-896, not an infrastructure reclassification: a persistent
                 // timeout remains the ordinary conservative verdict after the single bounded remeasure.
                 const provenance = { durationMs: r.durationMs ?? 0, referenceMs: entry?.durationMs ?? 0, waitedMs };
-                results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, rerunOf: provenance }));
+                results.push(...(await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, rerunOf: provenance })).map(row => ({ ...row, evidenceReceipts: [...evidence.history, evidenceReceipt, ...(row.evidenceReceipts ?? [])] })));
                 continue;
             }
         }

package/dist/gates/review.d.ts

@@ -14,6 +14,8 @@ export interface ReviewFinding {
     severity: ReviewSeverity;
     defer?: boolean;
     rationale?: string;
+    /** Copy an id from the top-level reraised list to identify this restatement. */
+    reraised?: string;
 }
 export interface ReviewVerdict {
     approve?: boolean;
@@ -58,19 +60,19 @@ export { modelProvider };
  * comparing both sides with every whitespace run removed (`s.replace(/\s+/g, "")`).
  */
 export declare function matchClosureId(candidate: unknown, fingerprint: string): boolean;
-export declare function matchClosureId(candidate: unknown, fingerprints: Iterable<string>): string | undefined;
+export declare function matchClosureId(candidate: unknown, fingerprints: Iterable<string | StructuredFinding>): string | undefined;
 /**
  * Validates closure ids in a review verdict: membership, duplication, and coverage of every prior id
  * all route through matchClosureId.
  */
-export declare function isReviewClosureInvalid(v: Pick<ReviewVerdict, "resolved" | "reraised"> | null | undefined, priorIds: ReadonlySet<string> | readonly string[]): boolean;
+export declare function isReviewClosureInvalid(v: Pick<ReviewVerdict, "resolved" | "reraised"> | null | undefined, priorIds: ReadonlySet<string> | readonly (string | StructuredFinding)[]): boolean;
 /**
  * OBS-1013 add.3: the reviewer ECHOED closure ids and at least one matches no carried fingerprint —
  * it answered about the materials and missed the id (a retyped, truncated or paraphrased fingerprint).
  * That is a no-verdict about the carried work (re-route), not a parse defect. A verdict that omits a
  * list, carries a non-string or duplicates an id stays malformed: its shape, not its ids, is wrong.
  */
-export declare function isReviewClosureMismatch(v: Pick<ReviewVerdict, "resolved" | "reraised"> | null | undefined, priorIds: ReadonlySet<string> | readonly string[]): boolean;
+export declare function isReviewClosureMismatch(v: Pick<ReviewVerdict, "resolved" | "reraised"> | null | undefined, priorIds: ReadonlySet<string> | readonly (string | StructuredFinding)[]): boolean;
 export type ReviewerFloorCause = "author-tier" | "task-floor" | "config" | "prior-reviewer";
 /**
  * RF-1 (OBS-922 add.2/3): the tier a reviewer must meet is the maximum of the author's tier, the
@@ -134,4 +136,4 @@ export declare function renderGoalSection(goal: string, repoRoot?: string): stri
  * closure on a typo and that read as malformed — the block is what a closure list is copied from.
  */
 export declare function renderPriorMaterials(priorMaterials: readonly StructuredFinding[]): string;
-export declare function reviewGate(task: Task, worktree: string, baseRef: string, author: Assignment, channels: BillingChannel[], adapters: WorkerAdapter[], cfg: TickmarkrConfig, via?: GateVia, excludeReviewers?: string[], artifactDir?: string, reviewHistory?: string[], demotedReviewers?: ReadonlySet<string>, carriedFindings?: readonly StructuredFinding[], priorReviewers?: readonly PriorReviewer[], carriedAuthors?: readonly string[]): Promise<GateResult>;
+export declare function reviewGate(task: Task, worktree: string, baseRef: string, author: Assignment, channels: BillingChannel[], adapters: WorkerAdapter[], cfg: TickmarkrConfig, via?: GateVia, excludeReviewers?: string[], artifactDir?: string, reviewHistory?: string[], demotedReviewers?: ReadonlySet<string>, carriedFindings?: readonly StructuredFinding[], priorReviewers?: readonly PriorReviewer[], carriedAuthors?: readonly string[], operatorContext?: string): Promise<GateResult>;