tickmarkr 2.5.7 → 2.5.9

package/dist/gates/review.js

@@ -6,12 +6,12 @@ import { filesGlob } from "../graph/files-glob.js";
 import { renderAcceptanceItem, TIERS } from "../graph/schema.js";
 import { getAdapter } from "../adapters/registry.js";
 import { shOk } from "../run/git.js";
-import { structuredFindings } from "../run/journal.js";
+import { carryReviewFindings, observedReviewFingerprints, reviewFingerprintMatches, structuredFindings, UNIDENTIFIED } from "../run/journal.js";
 import { redactSecrets } from "../run/redact.js";
 import { marginalCostRank } from "../route/router.js";
 import { modelProvider } from "../route/preference.js";
 import { resolveStateDir } from "./cache.js";
-import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlmDetailed, verdictNonceLine } from "./llm.js";
+import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, parseAnchoredComments, runLlmDetailed, verdictNonceLine } from "./llm.js";
 import { classifyVerdictCause } from "./verdict-cause.js";
 import { captureDiffCapFor, measureArtifactDiff, reviewableLogicDiff, } from "./artifact-manifest.js";
 export { isProtectedEvidence, PROTECTED_EVIDENCE_PREFIXES, REGENERABLE_CAPTURE_PATHS, setAsideReceiptPath, setAsideRegenerableCaptures, } from "./artifact-manifest.js";
@@ -188,15 +188,17 @@ export function matchClosureId(candidate, target) {
     // OBS-1068: the brief's copy block printed each id as `Fingerprint: <id>` and told the seat to copy
     // it EXACTLY — three faithful approvals in one run were discarded as closure-mismatch. A leading
     // `Fingerprint:` label is the brief's own wording, never the reviewer's id; strip it before comparing.
-    const normCandidate = candidate.replace(/^\s*fingerprint\s*:\s*/i, "").replace(/\s+/g, "");
     if (typeof target === "string") {
-        return normCandidate === target.replace(/\s+/g, "");
+        return reviewFingerprintMatches(candidate, target);
     }
-    for (const fp of target) {
-        if (typeof fp === "string" && normCandidate === fp.replace(/\s+/g, ""))
-            return fp;
-    }
-    return undefined;
+    const matches = [...target].filter((finding) => {
+        const ids = typeof finding === "string" ? [finding] : observedReviewFingerprints(finding);
+        return ids.some((id) => reviewFingerprintMatches(candidate, id));
+    });
+    if (matches.length !== 1)
+        return undefined;
+    const match = matches[0];
+    return typeof match === "string" ? match : match.fingerprint;
 }
 /**
  * Validates closure ids in a review verdict: membership, duplication, and coverage of every prior id
@@ -205,10 +207,10 @@ export function matchClosureId(candidate, target) {
 export function isReviewClosureInvalid(v, priorIds) {
     const priors = priorIds instanceof Set ? priorIds : new Set(priorIds);
     const closureLists = [v?.resolved, v?.reraised];
-    const allCandidateIds = [...(v?.resolved ?? []), ...(v?.reraised ?? [])];
+    const allCandidateIds = closureLists.flatMap((list) => Array.isArray(list) ? list : []);
     return !!v && (priors.size > 0 || closureLists.some((list) => list !== undefined)) && (closureLists.some((list) => !Array.isArray(list) || list.some((id) => !matchClosureId(id, priors)))
         || new Set(allCandidateIds.map((id) => matchClosureId(id, priors) ?? id)).size !== allCandidateIds.length
-        || [...priors].some((id) => !allCandidateIds.some((candidate) => matchClosureId(candidate, id))));
+        || [...priors].some((id) => !allCandidateIds.some((candidate) => matchClosureId(candidate, priors) === (typeof id === "string" ? id : id.fingerprint))));
 }
 /**
  * OBS-1013 add.3: the reviewer ECHOED closure ids and at least one matches no carried fingerprint —
@@ -368,10 +370,17 @@ function daemonRepoRoot(worktree, artifactDir) {
  * closure on a typo and that read as malformed — the block is what a closure list is copied from.
  */
 export function renderPriorMaterials(priorMaterials) {
+    const fingerprints = priorMaterials.map((finding, i) => {
+        const observed = observedReviewFingerprints(finding);
+        const heading = observed.length > 1 ? `Finding ${i + 1} (choose one observed spelling):\n` : "";
+        return heading + observed.map((id) => `Fingerprint: ${id}`).join("\n");
+    }).join("\n");
     return `## Prior materials this attempt must close
-Copy each fingerprint below EXACTLY (they appear once, in this block) into resolved or reraised:
+For each finding below, copy exactly ONE of its observed fingerprints into resolved or reraised.
+Use only these observed spellings. For every findings entry that restates a reraised prior, whether at the same path or a new path, set its "reraised" field to the copied id; unrelated defects need separate entries.
+The fingerprints appear once, in this block:
 \`\`\`text
-${priorMaterials.map((finding) => `Fingerprint: ${finding.fingerprint}`).join("\n")}
+${fingerprints}
 \`\`\`
 ${priorMaterials.map((finding, i) => `${i + 1}. ${finding.note}`).join("\n\n")}`;
 }
@@ -383,7 +392,7 @@ artifactDir, reviewHistory, demotedReviewers, carriedFindings = [],
 // never the run-wide rotation history nor excludeReviewers; the seat holds the highest of their tiers.
 priorReviewers = [], 
 // OBS-1033: channel keys of the seats that authored the carried commits (the daemon's tried list).
-carriedAuthors = []) {
+carriedAuthors = [], operatorContext) {
     // R3 (OBS-186): participation is keyed on PATHS. The compiler's assignment comes from the DECLARED
     // files[]; the operator's floor may RAISE it to full and can never lower it. `complexityThreshold` is
     // retired — the branch that returned a green skip on a complexity comparison is gone, and with it the
@@ -502,6 +511,10 @@ ${suiteBudget} Never run the whole suite (including an unfiltered npm test or vi
 
 ${priorMaterials.length ? `${renderPriorMaterials(priorMaterials)}
 
+` : ""}${operatorContext?.trim() ? `## Operator context
+Context only: this never substitutes for an acceptance criterion or closes a prior material.
+${operatorContext.trim()}
+
 ` : ""}## Diff
 \`\`\`diff
 ${diff}
@@ -578,7 +591,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     const provider = modelProvider(reviewer.model, reviewer.vendor);
     const v = extractVerdictJson(raw, nonce);
     const findings = v && Array.isArray(v.findings) ? v.findings : null;
-    const priorIds = new Set(priorMaterials.map((finding) => finding.fingerprint));
+    const priorIds = priorMaterials;
     const closureInvalid = isReviewClosureInvalid(v, priorIds);
     const closureMismatch = closureInvalid && isReviewClosureMismatch(v, priorIds);
     // findings decides the verdict on its own; the legacy path still needs approve + issues to parse.
@@ -610,7 +623,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
                 provider,
                 ...(cause === "malformed-verdict" ? { unparseable: true } : { noVerdict: true, classification: "infra", infra: true }),
                 cause,
-                ...(closureMismatch ? { resolved: v?.resolved, reraised: v?.reraised, carriedFingerprints: [...priorIds] } : {}),
+                ...(closureMismatch ? { resolved: v?.resolved, reraised: v?.reraised, carriedFingerprints: priorIds.flatMap(observedReviewFingerprints) } : {}),
                 bytes, seatAuthoredBytes: bytes,
                 ...(saved ? { rawPath: saved } : {}),
                 ...(savedBrief ? { briefPath: savedBrief } : {}),
@@ -621,7 +634,8 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     const decided = findings !== null
         ? classifyReviewFindings(findings)
         : classifyReviewIssues(v.approve, v.issues);
-    const reraised = priorMaterials.filter((finding) => v.reraised?.some((id) => matchClosureId(id, finding.fingerprint)));
+    const ownLines = [...decided.lines];
+    const reraised = priorMaterials.filter((finding) => v.reraised?.some((id) => matchClosureId(id, [finding])));
     if (reraised.length) {
         if (decided.pass)
             decided.headline = "requested changes";
@@ -636,6 +650,36 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     }
     const prose = `reviewer ${reviewer.adapter}:${reviewer.model} (vendor: ${reviewer.vendor}; provider: ${provider}): ${decided.headline}${decided.lines.length ? "\n" + decided.lines.join("\n") : ""}`;
     const details = appendAnchoredReview(prose, v);
+    // Only the verdict's anchors may supply missing evidence, and only when unambiguous.
+    // Reuse the journal's path normalization without changing legacy details-only parsing.
+    const anchoredPaths = new Set(parseAnchoredComments(v).map((comment) => {
+        const anchor = structuredFindings("review", `- ${comment.path}:${comment.line} — anchor`)
+            .find((finding) => finding.class === "review:anchored");
+        return anchor?.path ?? comment.path;
+    }));
+    const anchoredPath = anchoredPaths.size === 1 ? [...anchoredPaths][0] : undefined;
+    const ownDetails = appendAnchoredReview(ownLines.join("\n"), v);
+    const currentRows = (ownDetails.trim() ? structuredFindings("review", ownDetails) : [])
+        .map((finding) => finding.path === UNIDENTIFIED && anchoredPath
+        ? { ...finding, path: anchoredPath, fingerprint: `${finding.class}|${anchoredPath}|${finding.symbol}` }
+        : finding);
+    // A top-level reraised id identifies a prior, not an arbitrary new defect. Bind a restatement
+    // only when its own entry echoes that validated id (or its note explicitly contains the id).
+    const linkedRows = currentRows.map((finding) => {
+        if (finding.class !== "review:material")
+            return finding;
+        const entry = v.findings?.find((entry) => entry && typeof entry === "object" && entry.note === finding.note);
+        const mentioned = reraised.filter((prior) => observedReviewFingerprints(prior)
+            .some((fp) => finding.note.includes(`\`${fp}\``) || finding.note.trim() === fp));
+        const id = matchClosureId(entry?.reraised, reraised)
+            ?? (mentioned.length === 1 ? mentioned[0].fingerprint : undefined);
+        return id ? { ...finding, reraisedFrom: id } : finding;
+    });
+    // Several rows claiming the same prior are ambiguous; none gets to erase the others.
+    const unambiguousRows = linkedRows.map((finding) => finding.reraisedFrom
+        && linkedRows.filter((row) => row.reraisedFrom === finding.reraisedFrom).length > 1
+        ? { ...finding, reraisedFrom: undefined } : finding);
+    const carriedRows = carryReviewFindings(reraised, unambiguousRows);
     return {
         gate: "review",
         pass: decided.pass,
@@ -649,10 +693,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
                 resolvedMatches: (v.resolved ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
                 reraisedMatches: (v.reraised ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
             } : {}),
-            ...(reraised.length ? { findings: [
-                    ...structuredFindings("review", details).filter((finding) => !reraised.some((prior) => prior.note === finding.note)),
-                    ...reraised,
-                ] } : {}),
+            ...(!decided.pass ? { findings: carriedRows } : {}),
             ...(saved ? { rawPath: saved } : {}),
             ...(savedBrief ? { briefPath: savedBrief } : {}),
         },

package/dist/gates/run-gates.d.ts

@@ -2,7 +2,7 @@ import type { CommandReceiptAttribution } from "../run/protocol.js";
 import { type Assignment, type BillingChannel, type WorkerAdapter, type WorkerResult } from "../adapters/types.js";
 import { type TickmarkrConfig } from "../config/config.js";
 import { type GateName, type Task } from "../graph/schema.js";
-import { type Baseline } from "./baseline.js";
+import { type Baseline, type GateEvidenceOptions } from "./baseline.js";
 import { type GateVia } from "./llm.js";
 import { type PriorReviewer } from "./review.js";
 import type { GateResult } from "./types.js";
@@ -46,6 +46,7 @@ export type GateEvent = {
     result?: GateResult;
 };
 export interface GateContext {
+    evidence?: GateEvidenceOptions;
     buildReceiptIdentity?: Omit<CommandReceiptAttribution, "invocation">;
     authorizeInfraRetry?: (subject: string, cause?: VerificationRetryCause) => boolean;
     verificationScope?: VerificationScope;
@@ -61,10 +62,14 @@ export interface GateContext {
     cfg: TickmarkrConfig;
     via?: GateVia;
     carriedFindings?: readonly StructuredFinding[];
+    /** Approval reason bound to this attempt; guidance, never criterion or closure authority. */
+    operatorContext?: string;
     excludeReviewers?: string[];
     demotedReviewers?: Set<string>;
     reviewNoVerdicts?: Map<string, string[]>;
     recheck?: boolean;
+    /** Explicit worker funding requires fresh red measurements, never a gate waiver. */
+    cachedRedBypass?: "operator-rerun";
     carriedAuthors?: readonly string[];
     reviewHistory?: string[];
     priorReviewers?: PriorReviewer[];

package/dist/gates/run-gates.js

@@ -222,22 +222,25 @@ async function runVitestManifestGate(worktree, cmd, baseline, selected, artifact
         longestFile: entry?.longestFile,
         overallCeilingMs: effectiveCeilingMs(entry),
         artifactDir,
+        evidence: retry.evidence,
     });
     const reportPath = outcome.reportPath;
+    const evidence = { evidenceReceipt: outcome.evidenceReceipt, evidenceReceipts: outcome.evidenceReceipts };
     if (!retried && retry.authorizeRetry && failureDisposition(outcome) === "infrastructure"
         && outcome.meta?.retryable !== false) {
         const waitedMs = await waitForCalmWindow(executionSignal());
         if (!calmWindowReady())
-            return { gate: "test", pass: false, details: outcome.details,
+            return { ...evidence, gate: "test", pass: false, details: outcome.details,
                 meta: { ...outcome.meta, reportPath, recoveryBlocked: "calm window unavailable within the existing wait ceiling" } };
         if (!retry.authorizeRetry("infra")) {
-            return { gate: "test", pass: false, details: outcome.details,
+            return { ...evidence, gate: "test", pass: false, details: outcome.details,
                 meta: { ...outcome.meta, reportPath, recoveryBlocked: "infrastructure retry allowance exhausted or subject unavailable" } };
         }
         const result = await runVitestManifestGate(worktree, cmd, baseline, selected, artifactDir, retry, true);
-        return { ...result, meta: { ...result.meta, runnerInfraRerun: { count: 1, waitedMs, firstReportPath: reportPath } } };
+        return { ...result, evidenceReceipts: [...(outcome.evidenceReceipts ?? []), ...(result.evidenceReceipts ?? [])], meta: { ...result.meta, runnerInfraRerun: { count: 1, waitedMs, firstReportPath: reportPath } } };
     }
     return {
+        ...evidence,
         gate: "test",
         pass: outcome.pass,
         details: outcome.details,
@@ -259,6 +262,12 @@ function classifySignalOnlyTest(g) {
 }
 export async function runGates(task, ctx) {
     const results = [];
+    const evidence = {
+        artifactDir: ctx.artifactDir,
+        runId: ctx.buildReceiptIdentity?.runId ?? ctx.artifactDir ?? "standalone",
+        taskId: task.id, attempt: ctx.buildReceiptIdentity?.attempt ?? 0,
+        ...ctx.evidence,
+    };
     // Receipt identity belongs to this round, never to a cached verdict. Each call from the shell
     // allocates a new invocation, including retries whose local spawn counter starts at one again.
     let currentBuild;
@@ -310,9 +319,11 @@ export async function runGates(task, ctx) {
     // OBS-1055: on a recheck a cached red is the answer the operator just said was wrongly given; it is
     // journaled as discarded and the gate runs. Returns true when the hit must NOT be reused.
     const discardCachedRed = async (gate, hit) => {
-        if (!ctx.recheck || hit.pass)
+        const reason = ctx.recheck ? "recheck" : ctx.cachedRedBypass;
+        if (!reason || hit.pass)
             return false;
-        await ctx.onGate?.({ phase: "note", gate, name: "recheck-rerun", payload: { gate, reason: "cached-red-discarded" }, result: hit });
+        await ctx.onGate?.({ phase: "note", gate, name: reason === "recheck" ? "recheck-rerun" : "gate-rerun",
+            payload: { gate, reason: "cached-red-discarded", ...(reason === "recheck" ? {} : { bypass: reason }) }, result: hit });
         return true;
     };
     const shapeGates = ctx.cfg.gates.byShape?.[task.shape];
@@ -656,8 +667,8 @@ export async function runGates(task, ctx) {
                     // other scripted test command keeps today's exit-code contract byte-identically.
                     const useManifest = g === "test" && commands.test !== undefined && isVitestTestCommand(commands.test, ctx.worktree);
                     r = useManifest
-                        ? await measure(g, () => runVitestManifestGate(ctx.worktree, commands.test, ctx.baseline, selected, ctx.artifactDir, retryOptions(identity)))
-                        : (await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g], { ...retryOptions(identity), ...(g === "build" ? { onReceipt: buildReceipt, taskBuildAttribution: beginBuild } : {}), ...(g === "test" && selected ? { selected } : {}) })))[0];
+                        ? await measure(g, () => runVitestManifestGate(ctx.worktree, commands.test, ctx.baseline, selected, ctx.artifactDir, { ...retryOptions(identity), evidence }))
+                        : (await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g], { ...retryOptions(identity), evidence, ...(g === "build" ? { onReceipt: buildReceipt, taskBuildAttribution: beginBuild } : {}), ...(g === "test" && selected ? { selected } : {}) })))[0];
                 }
                 finally {
                     await receiptNotes;
@@ -674,7 +685,7 @@ export async function runGates(task, ctx) {
             if (!cached && r.pass && commands[g]) {
                 const dirt = await dirtyWorktree();
                 if (dirt) {
-                    await record(await dirtyRefusal(g, dirt, commands[g]));
+                    await record({ ...await dirtyRefusal(g, dirt, commands[g]), evidenceReceipt: r.evidenceReceipt, evidenceReceipts: r.evidenceReceipts });
                     return;
                 }
             }
@@ -901,7 +912,7 @@ export async function runGates(task, ctx) {
         const priorReviewers = [...(ctx.priorReviewers ?? []), ...(ctx.excludeReviewers ?? [])];
         const carriedAuthors = ctx.carriedAuthors ?? [];
         let exclusions = [...(ctx.excludeReviewers ?? []), ...retired];
-        let rv = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, ctx.via, exclusions, ctx.artifactDir, ctx.reviewHistory, ctx.demotedReviewers, ctx.carriedFindings, priorReviewers, carriedAuthors));
+        let rv = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, ctx.via, exclusions, ctx.artifactDir, ctx.reviewHistory, ctx.demotedReviewers, ctx.carriedFindings, priorReviewers, carriedAuthors, ctx.operatorContext));
         // OBS-193/574: an unparseable review verdict retries the REVIEW, preferring a different adapter. Only
         // a single-adapter eligible pool may fall back to another channel on the flaked adapter. The flaked
         // verdict never enters results; an exhausted pool preserves its cause.
@@ -934,7 +945,7 @@ export async function runGates(task, ctx) {
             const crossAdapter = pickReviewer(ctx.author, ctx.channels, [...exclusions, ...adapterExclusions], ctx.cfg.review.prefer ?? [], retryFloor, undefined, undefined, undefined, carriedAuthorVendors(ctx.channels, carriedAuthors));
             const exclusion = crossAdapter ? "adapter" : "channel";
             exclusions = [...exclusions, ...(crossAdapter ? adapterExclusions : [flaked])];
-            const second = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, retryVia, exclusions, ctx.artifactDir, ctx.reviewHistory, ctx.demotedReviewers, ctx.carriedFindings, retryPrior, carriedAuthors));
+            const second = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, retryVia, exclusions, ctx.artifactDir, ctx.reviewHistory, ctx.demotedReviewers, ctx.carriedFindings, retryPrior, carriedAuthors, ctx.operatorContext));
             if (second.meta?.noEligibleReviewer !== true) {
                 const retried = typeof second.meta?.reviewer === "string" ? second.meta.reviewer : "none";
                 const route = exclusion === "adapter"
@@ -1102,8 +1113,8 @@ export async function runGates(task, ctx) {
         if (!full) {
             const fullUsesManifest = ctx.commands.test !== undefined && isVitestTestCommand(ctx.commands.test, ctx.worktree);
             full = fullUsesManifest
-                ? await measure("test", () => runVitestManifestGate(ctx.worktree, ctx.commands.test, ctx.baseline, undefined, ctx.artifactDir, retryOptions(identity)))
-                : (await measure("test", () => compareToBaseline(ctx.worktree, ctx.commands, ctx.baseline, ["test"], retryOptions(identity))))[0];
+                ? await measure("test", () => runVitestManifestGate(ctx.worktree, ctx.commands.test, ctx.baseline, undefined, ctx.artifactDir, { ...retryOptions(identity), evidence }))
+                : (await measure("test", () => compareToBaseline(ctx.worktree, ctx.commands, ctx.baseline, ["test"], { ...retryOptions(identity), evidence })))[0];
         }
         fullDurationMs = spans.get("test") ? spans.get("test").durationMs - (selectedDurationMs ?? 0) : 0;
         const dirt = (!cached && full.pass) ? await dirtyWorktree() : undefined;
@@ -1113,8 +1124,9 @@ export async function runGates(task, ctx) {
             verdictStore.set(identity, { ...full, meta: { ...full.meta, source: "gate", runDir: ctx.artifactDir } });
         }
         const merged = withTelemetry(dirt
-            ? await dirtyRefusal("test", dirt, ctx.commands.test)
+            ? { ...await dirtyRefusal("test", dirt, ctx.commands.test), evidenceReceipt: full.evidenceReceipt, evidenceReceipts: full.evidenceReceipts }
             : { ...full, meta: { ...full.meta, fullSuite: true, selectedTests: selected } });
+        merged.evidenceReceipts = [...(heldTest?.evidenceReceipts ?? []), ...(full?.evidenceReceipts ?? [])];
         results[results.findIndex((r) => r.gate === "test")] = merged;
         heldTest = undefined;
         await ctx.onGate?.({ phase: "end", gate: "test", result: merged });

package/dist/gates/test-manifest.d.ts

@@ -1,4 +1,5 @@
-import type { BaselineFileDuration } from "./baseline.js";
+import { type GateEvidenceOptions, type BaselineFileDuration } from "./baseline.js";
+import type { GateEvidenceReceipt } from "../run/protocol.js";
 export declare function isVitestTestCommand(cmd: string, cwd: string): boolean;
 /** One identity for every path this module compares: repo-relative, forward-slash. `vitest list
  * --json` and `TestModule.moduleId` both hand back an absolute filesystem path already resolved
@@ -20,6 +21,15 @@ export interface TestReportCompletion {
         failed: number;
         skipped: number;
     };
+    /** Bounded (4096 bytes) runner evidence per failed test — diff, actual/expected or stack head.
+     * Never part of the failure's identity: `failures` alone feeds details and fingerprints. */
+    evidence?: FailureEvidence[];
+}
+export interface FailureEvidence {
+    test: string;
+    text: string;
+    truncated?: true;
+    unavailable?: true;
 }
 /** The runner's own machine report — requested/started/completed are the runner's claims about ITSELF. */
 export interface TestReport {
@@ -69,6 +79,8 @@ export declare const FILE_HANG_SLACK = 3;
 export declare const DEFAULT_FILE_HANG_BUDGET_MS = 60000;
 export declare function fileHangBudgetMs(file: string, baselineDurations?: readonly BaselineFileDuration[] | null, ceilingMs?: number, longestFile?: BaselineFileDuration | null): number;
 export interface ManifestRunResult {
+    evidenceReceipt: GateEvidenceReceipt;
+    evidenceReceipts: GateEvidenceReceipt[];
     exitCode: number | undefined;
     stdout: string;
     stderr: string;
@@ -82,6 +94,7 @@ export interface ManifestRunResult {
 /** Supervise the configured command and poll the runner's atomic lifecycle snapshots. Every
  * timeout kills the detached process group, including descendants holding the output pipes. */
 export declare function runManifestedTest(cmd: string, cwd: string, opts: {
+    evidence?: GateEvidenceOptions;
     manifest: readonly string[];
     nonce: string;
     reportPath: string;
@@ -92,6 +105,8 @@ export declare function runManifestedTest(cmd: string, cwd: string, opts: {
     overallCeilingMs?: number;
 }): Promise<ManifestRunResult>;
 export interface ManifestGateOutcome {
+    evidenceReceipt?: GateEvidenceReceipt;
+    evidenceReceipts?: GateEvidenceReceipt[];
     pass: boolean;
     kind: ManifestVerdictKind;
     details: string;
@@ -106,6 +121,8 @@ export interface DiscoveredManifest {
     separator: string;
     listingExit: number | undefined;
     listingStdout: string;
+    evidenceReceipt: GateEvidenceReceipt;
+    evidenceReceipts: GateEvidenceReceipt[];
 }
 /** OBS-1044: THE discovery seam — the files the runner would collect under this exact invocation,
  * from its own listing and never from a stdout summary. The gate and the baseline capture share it,
@@ -116,6 +133,7 @@ export declare function discoverTestManifest(cmd: string, cwd: string, opts: {
     nonce: string;
     env: NodeJS.ProcessEnv;
     overallCeilingMs?: number;
+    evidence?: GateEvidenceOptions;
 }): Promise<DiscoveredManifest>;
 /** The baseline capture's reading of the same seam: the manifest's file count, or null when the
  * runner cannot list (a null compares nothing — it never manufactures a deficit). The suite is not
@@ -128,4 +146,5 @@ export declare function evaluateManifestedTest(cmd: string, cwd: string, opts: {
     longestFile?: BaselineFileDuration | null;
     overallCeilingMs?: number;
     artifactDir?: string;
+    evidence?: GateEvidenceOptions;
 }): Promise<ManifestGateOutcome>;

package/dist/gates/test-manifest.js

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { isAbsolute, join, relative, sep } from "node:path";
 import { TEST_REPORTER_SOURCE } from "./test-reporter.js";
 import { shq } from "../adapters/types.js";
+import { beginGateEvidence, redactGateOutput } from "./baseline.js";
 import { FORK_CAP_ENV, ROUTING_ENV_SEAMS, SUITE_PARENT_ENV, shell, resolvedCapacity, verificationProtocol } from "../run/git.js";
 /**
  * VL-1 (OBS-985 lineage): a test gate's completion must be the runner's OWN report, never a stdout
@@ -103,6 +104,12 @@ export function toManifestPath(file, cwd) {
     catch { /* cwd unreadable — best effort with the given path */ }
     return relative(resolvedCwd, file).split(sep).join("/");
 }
+function isFailureEvidence(v) {
+    if (typeof v !== "object" || v === null)
+        return false;
+    const e = v;
+    return typeof e.test === "string" && typeof e.text === "string";
+}
 function isTestReportShape(v) {
     if (typeof v !== "object" || v === null)
         return false;
@@ -228,10 +235,12 @@ export function verifyManifestReport(opts) {
     const failedCompletions = Object.entries(report.completed).filter(([, c]) => c.status === "failed");
     const failingFiles = failedCompletions.map(([file]) => file).sort();
     const failures = failedCompletions.flatMap(([, c]) => c.failures?.length ? c.failures : ["<unnamed failure>"]);
+    // Parsed defensively: a malformed entry is dropped, never a verdict change — evidence is diagnostics only.
+    const failureEvidence = failedCompletions.flatMap(([, c]) => Array.isArray(c.evidence) ? c.evidence.filter(isFailureEvidence) : []);
     if (failures.length)
         return { kind: "work", pass: false,
             details: `test report names failing fingerprint(s):\n${failures.join("\n")}`,
-            meta: { classification: "regression", failingTests: failures, failingFiles, processExit: exitCode } };
+            meta: { classification: "regression", failingTests: failures, failingFiles, processExit: exitCode, failureEvidence } };
     if (exitCode === undefined) {
         return {
             kind: "fail-closed",
@@ -322,6 +331,7 @@ export function runManifestedTest(cmd, cwd, opts) {
     const pollMs = opts.pollMs ?? 20;
     const overallCeilingMs = usable(opts.overallCeilingMs) ? opts.overallCeilingMs : DEFAULT_FILE_HANG_BUDGET_MS;
     const env = { ...(opts.env ?? process.env), TICKMARKR_TEST_REPORT: opts.reportPath, TICKMARKR_TEST_NONCE: opts.nonce };
+    const evidence = beginGateEvidence(cwd, "test", cmd, { ...opts.evidence, env }, opts.nonce);
     const controller = new AbortController();
     let pid;
     let killedFile;
@@ -347,6 +357,7 @@ export function runManifestedTest(cmd, cwd, opts) {
         }
     };
     return shell(cmd, cwd, overallCeilingMs, false, {
+        onReceipt: receipt => evidence.observe(killedFile && receipt.outcome === "cancelled" ? { ...receipt, outcome: "timed-out" } : receipt),
         env, signal: controller.signal, onTimeout: () => checkHang(true),
         onSpawn: (childPid) => {
             pid = childPid;
@@ -354,11 +365,21 @@ export function runManifestedTest(cmd, cwd, opts) {
             clearInterval(poll);
             poll = setInterval(checkHang, pollMs);
         },
-    }).then((result) => ({
-        exitCode: result.signalExit ? undefined : result.code,
-        stdout: result.stdout, stderr: result.stderr,
-        report: readTestReport(opts.reportPath), killedFile, hangBudgetMs, pid,
-    })).finally(() => { clearInterval(poll); });
+    }).then((result) => {
+        const evidenceReceipt = evidence.finish(result.stdout, result.stderr);
+        return {
+            evidenceReceipt, evidenceReceipts: [...evidence.history, evidenceReceipt],
+            exitCode: result.signalExit ? undefined : result.code,
+            stdout: result.stdout, stderr: result.stderr,
+            report: readTestReport(opts.reportPath), killedFile, hangBudgetMs, pid,
+        };
+    }).catch((error) => {
+        if (error instanceof Error) {
+            const evidenceReceipt = evidence.finish();
+            Object.assign(error, { evidenceReceipt, evidenceReceipts: [...evidence.history, evidenceReceipt] });
+        }
+        throw error;
+    }).finally(() => { clearInterval(poll); });
 }
 /** The child environment every manifest invocation (listing and run) receives, and the lifecycle
  * protocol it records. R41: the policy is whatever THIS process was launched with (npm reads
@@ -383,11 +404,12 @@ function manifestEnvironment(cwd) {
 export async function discoverTestManifest(cmd, cwd, opts) {
     const invocation = runnerInvocation(cmd, cwd);
     const listed = await runManifestedTest(invocation.listing, cwd, {
-        manifest: [], nonce: opts.nonce, reportPath: join(opts.dir, `listing-${opts.nonce}.json`), env: opts.env,
+        evidence: opts.evidence, manifest: [], nonce: `${opts.nonce}-listing`, reportPath: join(opts.dir, `listing-${opts.nonce}.json`), env: opts.env,
         overallCeilingMs: opts.overallCeilingMs ?? DEFAULT_FILE_HANG_BUDGET_MS,
     });
+    const discoveryError = (message) => Object.assign(new Error(message), { evidenceReceipt: listed.evidenceReceipt, evidenceReceipts: listed.evidenceReceipts });
     if (listed.exitCode !== 0)
-        throw new Error(`vitest cannot list files (exit ${listed.exitCode ?? "signal"}): ${listed.stderr || listed.stdout}`);
+        throw discoveryError(`vitest cannot list files (exit ${listed.exitCode ?? "signal"}): ${listed.stderr || listed.stdout}`);
     let files;
     try {
         const rows = JSON.parse(listed.stdout.slice(listed.stdout.indexOf("[")));
@@ -396,11 +418,11 @@ export async function discoverTestManifest(cmd, cwd, opts) {
         files = [...new Set(rows.map((r) => toManifestPath(r.file, cwd)))].sort();
     }
     catch {
-        throw new Error(`vitest cannot list files: invalid JSON listing: ${listed.stdout}`);
+        throw discoveryError(`vitest cannot list files: invalid JSON listing: ${listed.stdout}`);
     }
     if (!files.length)
-        throw new Error("vitest cannot list files: empty manifest");
-    return { files, listing: invocation.listing, separator: invocation.separator, listingExit: listed.exitCode, listingStdout: listed.stdout };
+        throw discoveryError("vitest cannot list files: empty manifest");
+    return { files, listing: invocation.listing, separator: invocation.separator, listingExit: listed.exitCode, listingStdout: listed.stdout, evidenceReceipt: listed.evidenceReceipt, evidenceReceipts: listed.evidenceReceipts };
 }
 /** The baseline capture's reading of the same seam: the manifest's file count, or null when the
  * runner cannot list (a null compares nothing — it never manufactures a deficit). The suite is not
@@ -422,11 +444,13 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
     const nonce = randomBytes(16).toString("hex");
     const reportPath = join(dir, `test-manifest-report-${nonce}.json`);
     const reporterPath = join(dir, `test-reporter-${nonce}.mjs`);
+    const evidenceReceipts = [];
     let spawnedCommand = cmd;
     let manifestPath;
     const { env, verification } = manifestEnvironment(cwd);
     try {
-        const invocation = await discoverTestManifest(cmd, cwd, { dir, nonce, env, overallCeilingMs: opts.overallCeilingMs });
+        const invocation = await discoverTestManifest(cmd, cwd, { dir, nonce, env, overallCeilingMs: opts.overallCeilingMs, evidence: { ...opts.evidence, artifactDir: opts.evidence?.artifactDir ?? dir } });
+        evidenceReceipts.push(...invocation.evidenceReceipts);
         const files = invocation.files;
         // R41: the EXPECTED manifest is evidence in its own right — persisted beside the report with the
         // exact discovery invocation, so a later reader can tell what this invocation was asked to prove
@@ -440,7 +464,7 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
         writeFileSync(reporterPath, TEST_REPORTER_SOURCE);
         spawnedCommand = `${cmd}${invocation.separator} --reporter=${shq(reporterPath)} --outputFile=${shq(reportPath)}`;
         const invoked = await runManifestedTest(spawnedCommand, cwd, {
-            manifest: files, nonce, reportPath, env,
+            evidence: { ...opts.evidence, artifactDir: opts.evidence?.artifactDir ?? dir }, manifest: files, nonce, reportPath, env,
             baselineDurations: opts.baselineDurations?.map((d) => ({ ...d, file: toManifestPath(d.file, cwd) })),
             longestFile: opts.longestFile,
             overallCeilingMs: opts.overallCeilingMs ?? DEFAULT_FILE_HANG_BUDGET_MS,
@@ -449,12 +473,13 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
         const verdict = verifyManifestReport({ manifest: files, nonce, exitCode: invoked.exitCode,
             report: invoked.report, killedFile: invoked.killedFile, hangBudgetMs: invoked.hangBudgetMs });
         // Preserve the validator's verdict and classification; runner evidence only explains it.
-        const stdoutPath = join(dir, `test-runner-stdout-${nonce}.log`);
-        const stderrPath = join(dir, `test-runner-stderr-${nonce}.log`);
-        const stdoutTail = Buffer.from(invoked.stdout).subarray(-16 * 1024);
-        const stderrTail = Buffer.from(invoked.stderr).subarray(-16 * 1024);
-        writeFileSync(stdoutPath, stdoutTail);
-        writeFileSync(stderrPath, stderrTail);
+        const evidenceReceipt = invoked.evidenceReceipt;
+        evidenceReceipts.push(...invoked.evidenceReceipts);
+        const evidenceRoot = opts.evidence?.artifactDir ?? dir;
+        const stdoutPath = join(evidenceRoot, evidenceReceipt.stdout.path);
+        const stderrPath = join(evidenceRoot, evidenceReceipt.stderr.path);
+        const stdoutTail = Buffer.from(redactGateOutput(invoked.stdout, env)).subarray(-16 * 1024);
+        const stderrTail = Buffer.from(redactGateOutput(invoked.stderr, env)).subarray(-16 * 1024);
         const report = invoked.report?.nonce === nonce ? invoked.report : undefined;
         const neverStarted = report ? files.filter(file => !(file in report.started)).length : "unknown";
         const errors = report?.certificate?.errors;
@@ -462,11 +487,11 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
         const reportedDiagnostics = report?.certificate?.diagnostics;
         const runnerErrors = Array.isArray(reportedDiagnostics) ? reportedDiagnostics.filter(error => typeof error === "string") : [];
         const diagnostics = !verdict.pass
-            ? `\nclassification: ${verdict.meta.classification ?? "unknown"}; runner-level diagnostic: never-started ${neverStarted}; reporter errors ${reporterErrors}`
+            ? `\nclassification: ${verdict.meta.classification ?? "unknown"}; runner-level diagnostic: never-started ${neverStarted}; reporter errors ${reporterErrors}; runner vitest`
                 + [...runnerErrors,
                     stdoutTail.toString(), stderrTail.toString()].filter(Boolean).map(text => `\n${text}`).join("")
             : "";
-        return { pass: verdict.pass, kind: verdict.kind,
+        return { evidenceReceipt, evidenceReceipts, pass: verdict.pass, kind: verdict.kind,
             details: verdict.details + diagnostics,
             classification: verdict.meta.classification,
             meta: { ...verdict.meta, nonce, manifest: files, manifestPath, listingCommand: invocation.listing, verification,
@@ -474,7 +499,10 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
             exitCode: invoked.exitCode ?? -1, reportPath };
     }
     catch (error) {
-        return { pass: false, kind: "infra", classification: "infra", exitCode: -1, reportPath,
+        const evidenceReceipt = error?.evidenceReceipt;
+        if (evidenceReceipt)
+            evidenceReceipts.push(...(error.evidenceReceipts ?? [evidenceReceipt]));
+        return { evidenceReceipt, evidenceReceipts, pass: false, kind: "infra", classification: "infra", exitCode: -1, reportPath,
             details: error instanceof Error ? error.message : String(error),
             meta: { classification: "infra", infra: true, manifestDiscoveryFailed: true, spawnedCommand, verification, ...(manifestPath ? { manifestPath } : {}) } };
     }

package/dist/gates/test-reporter.js

@@ -11,6 +11,24 @@ export default class TickmarkrReporter {
     this.cwd = realpathSync(process.cwd());
   }
   file(module) { return relative(this.cwd, module.moduleId).split(sep).join('/'); }
+  // Bounded assertion evidence, kept BESIDE the failure fingerprint and never inside it: the
+  // fingerprint is the failure's identity (the repeated-failure cap compares it), the evidence is
+  // what the runner knew and the message elided. ONE 4096-byte budget per failed test, shared by
+  // all of its errors (expect.soft yields several); never invented.
+  evidence(test, errors) {
+    const parts = [];
+    for (const e of errors) {
+      if (e && typeof e.diff === 'string' && e.diff) parts.push(e.diff);
+      else for (const k of ['actual', 'expected']) if (e && e[k] !== undefined && e[k] !== null) parts.push(k + ': ' + (typeof e[k] === 'string' ? e[k] : JSON.stringify(e[k])));
+      if (e && typeof e.stack === 'string' && e.stack) parts.push(e.stack.split('\n').slice(0, 8).join('\n'));
+    }
+    if (!parts.length) return { test, text: '', unavailable: true };
+    const full = parts.join('\n').replace(/\x1b\[[0-9;]*m/g, '');
+    if (Buffer.byteLength(full) <= 4096) return { test, text: full };
+    let text = full.slice(0, 4096);
+    while (Buffer.byteLength(text) > 4096) text = text.slice(0, -1);
+    return { test, text, truncated: true };
+  }
   save() {
     writeFileSync(this.path + '.tmp', JSON.stringify(this.report));
     renameSync(this.path + '.tmp', this.path);
@@ -27,6 +45,7 @@ export default class TickmarkrReporter {
     const file = this.file(module);
     const failed = module.state() === 'failed';
     const failures = [];
+    const evidence = [];
     // R41: count test bodies by their own state so a module whose every test was skipped (a
     // describe.skipIf gate) is recorded as SKIPPED — present in the lifecycle, but never as
     // executed test-body success. 'passed'/'failed' executed; anything else did not run.
@@ -37,6 +56,8 @@ export default class TickmarkrReporter {
         tests.failed++;
         if (failed) {
           const errors = test.result().errors || [];
+          const name = file + ' > ' + test.fullName;
+          evidence.push(this.evidence(name, errors));
           failures.push(...(errors.length ? errors.map(e => 'FAIL ' + file + ' > ' + test.fullName + ': ' + e.message) : ['FAIL ' + file + ' > ' + test.fullName]));
         }
       } else if (state === 'passed') tests.passed++;
@@ -45,7 +66,7 @@ export default class TickmarkrReporter {
     if (failed && !failures.length) failures.push('FAIL ' + file);
     const status = failed ? 'failed' : tests.passed + tests.failed === 0 ? 'skipped' : 'passed';
     if (file in this.report.completed) this.report.duplicateCompletions.push(file);
-    this.report.completed[file] = { at: Date.now(), status, failures, tests };
+    this.report.completed[file] = { at: Date.now(), status, failures, tests, ...(evidence.length ? { evidence } : {}) };
     this.save();
   }
   onTestRunEnd(modules, errors, reason) {