tickmarkr 2.5.8 → 2.6.0

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 { dependencyLinkRefusal, 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
@@ -489,11 +620,21 @@ export function staleFileCountCommands(baseline, commands, cwd) {
 }
 export async function captureBaseline(cwd, commands, opts = {}) {
     const base = { commands: {} };
+    const refusal = dependencyLinkRefusal(cwd);
+    if (refusal) {
+        base.refusal = refusal;
+        for (const name of Object.keys(commands)) {
+            base.commands[name] = { infra: true, invalidCause: "infra", fingerprints: [], invalidatingLines: [refusal] };
+        }
+        return base;
+    }
     for (const [name, cmd] of Object.entries(commands)) {
         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 +775,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 +897,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 +916,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/cache.d.ts

@@ -59,7 +59,15 @@ export declare function computeVerificationIdentity(params: {
 }): Promise<VerificationIdentity | undefined>;
 export declare function verificationIdentityKey(id: VerificationIdentity): string;
 export declare function formatReusedDetails(originalDetails: string, id: VerificationIdentity): string;
+declare module "./types.js" {
+    interface GateResult {
+        originRunRoot?: string;
+    }
+}
 export interface CachedVerdict {
+    evidenceReceipt?: GateResult["evidenceReceipt"];
+    evidenceReceipts?: GateResult["evidenceReceipts"];
+    originRunRoot?: string;
     gate: string;
     pass: boolean;
     details: string;

package/dist/gates/cache.js

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
 import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
 import { tmpdir } from "node:os";
-import { describeCapacity, resolvedCapacity, shGit, verificationProtocol } from "../run/git.js";
+import { describeCapacity, inventoryDependencyLinks, resolvedCapacity, shGit, verificationProtocol } from "../run/git.js";
 import { shq } from "../adapters/types.js";
 export const DEFAULT_VERDICT_CACHE_BOUND = 128;
 let testCacheBound;
@@ -84,6 +84,13 @@ export function environmentFingerprint(env) {
     const capacity = { forkCap: cap.forkCap, cores: cap.cores };
     const selectedSet = env.selectedSet ? [...env.selectedSet].sort() : undefined;
     const verification = env.verification ?? verificationProtocol(process.env, env.worktree ?? process.cwd());
+    // Admitted links still affect resolution. Normalize against the classified root so relocating
+    // an otherwise identical checkout (including its dependency store) preserves the identity.
+    const resolution = env.worktree ? inventoryDependencyLinks(env.worktree).map(({ link, target, classification }) => ({
+        link,
+        classification,
+        target: classification === "outside" ? target : relative(realpathSync(classification === "worktree" ? env.worktree : join(env.worktree, "node_modules")), target),
+    })).sort((a, b) => a.link < b.link ? -1 : a.link > b.link ? 1 : 0) : [];
     // R41: the protocol and the EFFECTIVE lifecycle are IN the hashed payload, so every entry written
     // before this stamp — green or red — keys differently and is never answered; no store surgery is
     // needed. `source` is provenance (kept in parts, printed on the row) and never enters the key: an
@@ -92,6 +99,7 @@ export function environmentFingerprint(env) {
         nodeRuntime,
         lockfile,
         capacity,
+        resolution,
         selectedSet: selectedSet ?? null,
         scope: env.scope ?? "battery",
         verification: { protocol: verification.protocol, lifecycle: verification.lifecycle },
@@ -155,6 +163,9 @@ export function formatReusedRow(cached, id) {
         pass: cached.pass,
         details: cached.pass ? reusedDetails : cached.details,
         capacity: cached.capacity,
+        ...(cached.evidenceReceipt ? { evidenceReceipt: cached.evidenceReceipt } : {}),
+        ...(cached.evidenceReceipts ? { evidenceReceipts: cached.evidenceReceipts } : {}),
+        ...(cached.originRunRoot ? { originRunRoot: cached.originRunRoot } : {}),
         meta: {
             ...cached.meta,
             reused: true,
@@ -306,6 +317,10 @@ export class VerdictStore {
                 ...("exitCode" in verdict ? { exitCode: verdict.exitCode } : {}),
                 ...(verdict.capacity ? { capacity: verdict.capacity } : {}),
                 ...(verdict.meta ? { meta: verdict.meta } : {}),
+                ...(verdict.evidenceReceipt ? { evidenceReceipt: verdict.evidenceReceipt } : {}),
+                ...(verdict.evidenceReceipts ? { evidenceReceipts: verdict.evidenceReceipts } : {}),
+                ...(verdict.originRunRoot ? { originRunRoot: verdict.originRunRoot }
+                    : typeof verdict.meta?.runDir === "string" ? { originRunRoot: resolve(verdict.meta.runDir) } : {}),
             },
             timestamp: Date.now(),
             sequence: ++globalStoreSequence,
@@ -314,17 +329,15 @@ export class VerdictStore {
         const tmpPath = join(this.dir, `verdict-${key}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
         writeFileSync(tmpPath, JSON.stringify(record, null, 2) + "\n");
         try {
-            unlinkSync(finalPath);
+            renameSync(tmpPath, finalPath);
         }
-        catch {
-            // ignore
-        }
-        writeFileSync(finalPath, readFileSync(tmpPath));
-        try {
-            unlinkSync(tmpPath);
-        }
-        catch {
-            // ignore
+        finally {
+            try {
+                unlinkSync(tmpPath);
+            }
+            catch {
+                // Already renamed, or best-effort cleanup after a failed replacement.
+            }
         }
         this.evictOldest(bound);
         return true;

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
@@ -108,7 +110,7 @@ export declare function pickReviewer(author: Assignment, channels: BillingChanne
 prefer?: string[], // v1.53 T2: review.prefer — reorders eligible channels, never changes eligibility
 floor?: Tier, // task/config/prior floor from the caller; the author's own tier is ALWAYS applied here (RF-1)
 history?: string[], // run-scoped picks, oldest to newest; empty preserves the established ranking
-onSeat?: (seat: number, count: number) => void, demoted?: ReadonlySet<string>, excludeVendors?: ReadonlySet<string>): BillingChannel | null;
+onSeat?: (seat: number, count: number) => void, demoted?: ReadonlySet<string>, excludeVendors?: ReadonlySet<string>, authors?: readonly string[]): BillingChannel | null;
 export type ReviewUnparseableCause = VerdictUnparseableCause | "launch-never-started" | "truncated" | "silent" | "closure-mismatch";
 /**
  * This shows the reviewer what the task DECLARED, never what the diff may actually reach. The diff
@@ -118,8 +120,7 @@ export type ReviewUnparseableCause = VerdictUnparseableCause | "launch-never-sta
 export declare function renderDeclaredWriteScope(files: ReadonlyArray<string>): string;
 /**
  * OBS-1033: the vendors of the seats that authored commits inside the accumulated diff. A seat is
- * never handed its own earlier work to approve. A prior author not resolvable in the pool excludes
- * its adapter's vendors instead (fail closed: the seat is known, its vendor is whatever it bills as).
+ * never handed its own earlier work to approve. Unresolved channels are refused by reviewGate.
  */
 export declare function carriedAuthorVendors(channels: BillingChannel[], carriedAuthors?: readonly string[]): Set<string>;
 /**
@@ -134,4 +135,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>;

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 —
@@ -281,15 +283,11 @@ floor, // task/config/prior floor from the caller; the author's own tier is ALWA
 history = [], // run-scoped picks, oldest to newest; empty preserves the established ranking
 onSeat, demoted = new Set(), 
 // OBS-1033: vendors that authored a carried commit inside the accumulated diff — excluded for the round.
-excludeVendors = new Set()) {
-    // FLEET-05 success criterion 2: an author not resolvable in the channel list yields NO reviewer.
-    // The old `?? author.adapter` fallback compared an adapter id to vendor names, matched nothing, and
-    // admitted every reviewer — including the author's own channel (fail-OPEN). null lands on reviewGate's
-    // fail-closed branch under review.required.
-    const authorChannel = channels.find((c) => c.adapter === author.adapter && c.model === author.model);
-    if (!authorChannel)
+excludeVendors = new Set(), authors = [channelKey(author)]) {
+    // Resolve every actual author, never guess a vendor from an adapter id.
+    const authorChannels = authors.map((key) => channels.find((c) => channelKey(c) === key));
+    if (authorChannels.some((c) => !c))
         return null;
-    const authorProvider = modelProvider(author.model, authorChannel.vendor);
     // RF-1: every caller inherits the author-tier floor — a reviewer is never seated below its author.
     const effectiveFloor = resolveReviewerFloor(author.tier, floor).floor;
     const ranked = channels
@@ -297,9 +295,9 @@ excludeVendors = new Set()) {
         // as well as failover, so an aggregator channel stamped "mixed" never seats the author's own provider),
         // and different base-model identity (ADDED TO the vendor rule, never replacing it). The diversity
         // filter runs BEFORE preference ranking, so prefer cannot resurrect an excluded channel.
-        .filter((c) => c.vendor !== authorChannel.vendor
-        && modelProvider(c.model, c.vendor) !== authorProvider
-        && modelId(c.model) !== modelId(author.model)
+        .filter((c) => authorChannels.every((a) => a && c.vendor !== a.vendor
+        && modelProvider(c.model, c.vendor) !== modelProvider(a.model, a.vendor)
+        && modelId(c.model) !== modelId(a.model))
         && !exclude.includes(channelKey(c))
         && !excludeVendors.has(c.vendor)
         && TIER_RANK[c.tier] >= TIER_RANK[effectiveFloor])
@@ -326,15 +324,12 @@ ${files.map((path) => `- ${path}`).join("\n")}`;
 }
 /**
  * OBS-1033: the vendors of the seats that authored commits inside the accumulated diff. A seat is
- * never handed its own earlier work to approve. A prior author not resolvable in the pool excludes
- * its adapter's vendors instead (fail closed: the seat is known, its vendor is whatever it bills as).
+ * never handed its own earlier work to approve. Unresolved channels are refused by reviewGate.
  */
 export function carriedAuthorVendors(channels, carriedAuthors = []) {
     const vendors = new Set();
     for (const key of carriedAuthors) {
-        const adapter = key.split(":")[0];
-        const exact = channels.filter((c) => channelKey(c) === key);
-        for (const c of exact.length ? exact : channels.filter((c) => c.adapter === adapter))
+        for (const c of channels.filter((c) => channelKey(c) === key))
             vendors.add(c.vendor);
     }
     return vendors;
@@ -368,10 +363,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")}`;
 }
@@ -382,8 +384,8 @@ artifactDir, reviewHistory, demotedReviewers, carriedFindings = [],
 // RF-1: channel keys of THIS task's prior reviewers (earlier rounds, a flaked seat) — task-scoped,
 // 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 = []) {
+// Closed list of actual subject authors; empty preserves legacy callers' single-author contract.
+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
@@ -457,15 +459,15 @@ carriedAuthors = []) {
     // review.floor is read from config — cfg.routing.floors governs workers and never moves review seats.
     const { floor: reviewerFloor, cause: reviewerFloorCause } = gateReviewerFloor(task, cfg, author, channels, priorReviewers);
     const floorMeta = { reviewerFloor, reviewerFloorCause };
+    const authors = carriedAuthors.length ? carriedAuthors : [channelKey(author)];
+    const authorVendors = carriedAuthorVendors(channels, authors);
+    const unresolvedAuthors = authors.filter((key) => !channels.some((c) => channelKey(c) === key));
     let rotationSeat;
-    const reviewer = pickReviewer(author, channels, excludeReviewers ?? [], cfg.review.prefer ?? [], reviewerFloor, reviewHistory, reviewHistory ? (seat) => { rotationSeat = seat; } : undefined, demotedReviewers, carriedAuthorVendors(channels, carriedAuthors));
+    const reviewer = pickReviewer(author, channels, excludeReviewers ?? [], cfg.review.prefer ?? [], reviewerFloor, reviewHistory, reviewHistory ? (seat) => { rotationSeat = seat; } : undefined, demotedReviewers, authorVendors, authors);
     if (!reviewer) {
-        // meta.noEligibleReviewer lets run-gates' review-retry keep the ORIGINAL unparseable result when
-        // the retry finds no second seat — a truthful cause beats a synthetic no-reviewer failure.
-        const reason = `no cross-vendor reviewer available at or above ${reviewerFloor} floor (${reviewerFloorCause}; diversity rule)`;
-        return cfg.review.required || priorMaterials.length > 0
-            ? { gate: "review", pass: false, details: `unreadable — ${reason}; ${priorMaterials.length ? "carried materials require a review verdict" : "set review.required:false to waive"}`, meta: { noEligibleReviewer: true, unreadable: true, ...floorMeta } }
-            : { gate: "review", pass: true, details: `WARNING: ${reason} — review waived by config`, meta: { noEligibleReviewer: true, ...floorMeta } };
+        const reason = `no cross-vendor reviewer available at or above ${reviewerFloor} floor (${reviewerFloorCause}; diversity rule); author vendors: ${[...authorVendors].sort().join(", ") || "unknown"}${unresolvedAuthors.length ? `; unresolved author channels: ${unresolvedAuthors.join(", ")}` : ""}`;
+        return { gate: "review", pass: false, details: `unreadable — ${reason}; operator approve --waive required to proceed`,
+            meta: { noEligibleReviewer: true, unreadable: true, findings: [], authorVendors: [...authorVendors].sort(), unresolvedAuthors, ...floorMeta } };
     }
     reviewHistory?.push(channelKey(reviewer));
     const rotationMeta = rotationSeat === undefined ? {} : { rotationSeat };
@@ -502,6 +504,14 @@ ${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()}
+
+` : ""}${task.outOfScope?.length ? `## Out of scope
+The task declares these items out of scope. A finding inside these declared bounds is not material and must not block approval.
+${task.outOfScope.map((item) => `- ${item}`).join("\n")}
+
 ` : ""}## Diff
 \`\`\`diff
 ${diff}
@@ -578,7 +588,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 +620,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 +631,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 +647,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 +690,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 } : {}),
         },