tickmarkr 2.5.8 → 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,6 +62,8 @@ 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[]>;

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;
@@ -658,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;
@@ -676,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;
                 }
             }
@@ -903,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.
@@ -936,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"
@@ -1104,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;
@@ -1115,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
@@ -78,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;
@@ -91,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;
@@ -101,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;
@@ -115,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,
@@ -125,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
@@ -137,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
@@ -330,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;
@@ -355,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;
@@ -362,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
@@ -391,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("[")));
@@ -404,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
@@ -430,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
@@ -448,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,
@@ -457,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;
@@ -470,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,
@@ -482,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 } : {}) } };
     }