tickmarkr 2.6.1 → 2.6.3

package/dist/gates/baseline.d.ts

@@ -1,5 +1,5 @@
 import { type EvidenceArtifact, type GateEvidenceReceipt, type ShellReceipt } from "../run/protocol.js";
-import type { TickmarkrConfig } from "../config/config.js";
+import { type TickmarkrConfig } from "../config/config.js";
 import type { AcceptanceItem } from "../graph/schema.js";
 import { type RunCapacity, type ShellOptions, type ShResult } from "../run/git.js";
 import type { GateResult } from "./types.js";
@@ -31,8 +31,21 @@ export interface GateEvidenceOptions {
     write?: (path: string, bytes: Buffer) => void;
 }
 export declare const EVIDENCE_TAIL_BYTES: number;
+/** The default per-run quota; `gates.evidenceQuotaBytes` in config overrides it (OBS-1140). */
 export declare const EVIDENCE_RUN_QUOTA_BYTES: number;
+export type RedactionCounts = NonNullable<GateEvidenceReceipt["redaction"]["counts"]>;
+/**
+ * OBS-1139: every category scans the ORIGINAL text on its own; overlapping spans then merge into one
+ * span counted once under its highest-priority member — token, assignment, secret environment, benign
+ * HOME/TMPDIR — so precedence never depends on which match starts first. Counts only: never a value.
+ */
+export declare function classifyGateOutput(text: string, env: NodeJS.ProcessEnv): {
+    text: string;
+    counts: RedactionCounts;
+};
 export declare function redactGateOutput(text: string, env: NodeJS.ProcessEnv): string;
+/** Material means bytes were withheld; a benign location substitution withholds nothing. */
+export declare const redactionMaterial: (c: RedactionCounts) => boolean;
 /** Resolve a snapshot reference against actual bytes: eviction never fabricates a live artifact. */
 export declare function resolveEvidenceArtifact(root: string, ref: EvidenceArtifact): EvidenceArtifact;
 export declare function beginGateEvidence(cwd: string, gate: string, command: string, opts?: GateEvidenceOptions, nonce?: string): {
@@ -47,7 +60,7 @@ export declare function beginGateEvidence(cwd: string, gate: string, command: st
             subjectCommit: string | null;
         };
         termination: {
-            kind: "unknown" | "signal" | "not-started" | "exit" | "timeout";
+            kind: "unknown" | "timeout" | "signal" | "not-started" | "exit";
             exitCode: number | null;
             signal: string | null;
             timedOut: boolean | null;
@@ -55,6 +68,12 @@ export declare function beginGateEvidence(cwd: string, gate: string, command: st
         availability: "available" | "not-started" | "capture-failed" | "killed" | "expired" | "missing";
         redaction: {
             material: boolean;
+            counts?: {
+                token: number;
+                assignment: number;
+                secretEnv: number;
+                benignEnv: number;
+            } | undefined;
         };
         stdout: {
             path: string;
@@ -127,9 +146,19 @@ export interface BaselineFileDuration {
     file: string;
     durationMs: number;
 }
+/**
+ * OBS-1123: WHICH capture a forgiveness rests on — the commit it measured and when it was published.
+ * Stamped by the daemon beside the measurement; absent on every baseline.json written before it, which
+ * readers must render as unknown provenance and never date from any other clock.
+ */
+export interface BaselineProvenance {
+    baseRef: string;
+    capturedAt: string;
+}
 export interface Baseline {
     /** No command ran because the dependency inventory could not establish isolation. */
     refusal?: string;
+    provenance?: BaselineProvenance;
     /** Observational capture receipts stay outside the forgiveness-bearing command entries. */
     evidenceReceipts?: Record<string, GateEvidenceReceipt>;
     commands: Record<string, BaselineCommand>;
@@ -156,6 +185,7 @@ export declare function fingerprint(output: string): string[];
 export declare function freshFailures(entry: BaselineCommand | undefined, raw: string): {
     failing: string[];
     unreadable: boolean;
+    forgiven: string[];
 };
 export type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
 /**

package/dist/gates/baseline.js

@@ -1,25 +1,81 @@
 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 { EVICTION_TOMBSTONE_LIMIT, EVICTION_TOMBSTONES_FILE, parseEvictionTombstones } from "../run/receipt-resolver.js";
+import { existsSync, readFileSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, rmdirSync } from "node:fs";
 import { availableParallelism, loadavg, tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
+import { DEFAULT_EVIDENCE_QUOTA_BYTES } from "../config/config.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.
+/** The default per-run quota; `gates.evidenceQuotaBytes` in config overrides it (OBS-1140). */
+export const EVIDENCE_RUN_QUOTA_BYTES = DEFAULT_EVIDENCE_QUOTA_BYTES;
+/** Benign environment locations substituted by name; every other redaction is material. */
+const BENIGN_ENV_KEYS = ["HOME", "TMPDIR"];
+const REDACTION_CATEGORIES = ["token", "assignment", "secretEnv", "benignEnv"];
+/**
+ * OBS-1139: every category scans the ORIGINAL text on its own; overlapping spans then merge into one
+ * span counted once under its highest-priority member — token, assignment, secret environment, benign
+ * HOME/TMPDIR — so precedence never depends on which match starts first. Counts only: never a value.
+ */
+export function classifyGateOutput(text, env) {
+    // HOME/TMPDIR substitute by name at any length; "/" alone would rewrite every path separator.
+    const benign = BENIGN_ENV_KEYS.flatMap(key => { const value = env[key]; return value && value.length > 1 ? [{ value, label: `$${key}` }] : []; });
     // Short operational values (0, true, vi, test) occur throughout ordinary diagnostics.
-    // Only secret-named keys justify redacting short values.
-    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, "\\$&"));
+    // Only secret-named keys justify redacting short values. A secret-named value that happens to equal
+    // HOME/TMPDIR stays a secret candidate: precedence decides the span, never candidate pruning.
+    const secrets = [...new Set(Object.entries(env)
+            .filter(([key, value]) => !!value && !BENIGN_ENV_KEYS.includes(key)
+            && (value.length >= 8 || /KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|AUTH/i.test(key)))
+            .map(([, value]) => value))];
+    const literal = (v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const tokens = String.raw `\b(?:sk-[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9_]{16,}|github_pat_[A-Za-z0-9_]{16,}|AKIA[A-Z0-9]{16}|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)\b`;
     const assignments = String.raw `(?:authorization\s*:\s*bearer|(?:api[_-]?key|token|password|secret)\s*[:=])\s*[^\s"']+`;
-    return text.replace(new RegExp([tokens, assignments, ...values].join("|"), "gi"), "[REDACTED]");
+    // Every value scans the original text on its own: an alternation would consume the first match and
+    // skip a longer overlapping value's tail, so precedence is resolved on the collected spans instead.
+    const scan = (source, rank, label) => [...text.matchAll(new RegExp(source, "gi"))].map(m => ({ start: m.index, end: m.index + m[0].length, rank, label }));
+    const spans = [
+        ...scan(tokens, 0), ...scan(assignments, 1),
+        ...secrets.flatMap(v => scan(literal(v), 2)),
+        ...benign.flatMap(b => scan(literal(b.value), 3, b.label)),
+    ].sort((a, b) => a.start - b.start || b.end - a.end);
+    const merged = [];
+    for (const span of spans) {
+        const last = merged.at(-1);
+        if (!last || span.start >= last.end) {
+            merged.push({ ...span });
+            continue;
+        }
+        // C-11 (D-673): a benign value nested in (or identical to) another is one location, named by the containing
+        // span, which sorts first. Only a PARTIAL overlap of two different benign values is ambiguous: withhold it.
+        if (last.rank === 3 && span.rank === 3 && last.label !== span.label && span.end > last.end)
+            last.rank = 2;
+        else
+            last.rank = Math.min(last.rank, span.rank);
+        last.end = Math.max(last.end, span.end);
+    }
+    const counts = { token: 0, assignment: 0, secretEnv: 0, benignEnv: 0 };
+    let out = "", at = 0;
+    for (const { start, end, rank, label } of merged) {
+        counts[REDACTION_CATEGORIES[rank]]++;
+        out += text.slice(at, start) + (rank === 3 ? label : "[REDACTED]");
+        at = end;
+    }
+    return { text: out + text.slice(at), counts };
+}
+export function redactGateOutput(text, env) {
+    return classifyGateOutput(text, env).text;
+}
+/** Material means bytes were withheld; a benign location substitution withholds nothing. */
+export const redactionMaterial = (c) => c.token + c.assignment + c.secretEnv > 0;
+function readEvictionTombstones(root) {
+    try {
+        return parseEvictionTombstones(readFileSync(join(root, EVICTION_TOMBSTONES_FILE)));
+    }
+    catch {
+        return [];
+    }
 }
 /** Resolve a snapshot reference against actual bytes: eviction never fabricates a live artifact. */
 export function resolveEvidenceArtifact(root, ref) {
@@ -75,7 +131,12 @@ export function beginGateEvidence(cwd, gate, command, opts = {}, nonce) {
                 exitCode: observed?.exitCode ?? null, signal: observed?.signal ?? null,
                 timedOut: observed ? observed.outcome === "timed-out" : null,
             };
-            const clean = [redactGateOutput(stdout, env), redactGateOutput(stderr, env)];
+            const classified = [classifyGateOutput(stdout, env), classifyGateOutput(stderr, env)];
+            const clean = classified.map(c => c.text);
+            const counts = { token: 0, assignment: 0, secretEnv: 0, benignEnv: 0 };
+            for (const c of classified)
+                for (const k of Object.keys(counts))
+                    counts[k] += c.counts[k];
             const refs = clean.map((text, i) => {
                 const bytes = Buffer.from(text);
                 const tail = bytes.subarray(-EVIDENCE_TAIL_BYTES);
@@ -94,19 +155,38 @@ export function beginGateEvidence(cwd, gate, command, opts = {}, nonce) {
                     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;
+                    // An empty artifact costs no quota, so it is never evicted: every eviction frees 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));
+                        .filter(f => f.stat.size > 0).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) {
+                    // OBS-1140: the quota binds what is already retained too, so a resumed run at zero quota keeps
+                    // zero bytes. An invocation larger than the whole quota is expired at birth; older artifacts
+                    // are evicted only as far as the quota itself demands, never for bytes that could not fit.
+                    const fits = incoming <= quota;
+                    const evicted = [];
+                    while (files.length && total + (fits ? incoming : 0) > quota) {
                         const oldest = files.shift();
+                        const bytes = readFileSync(oldest.path);
                         unlinkSync(oldest.path);
                         total -= oldest.stat.size;
+                        evicted.push({ path: `gate-evidence/${basename(oldest.path)}`, sha256: createHash("sha256").update(bytes).digest("hex"), retainedBytes: bytes.length });
+                    }
+                    if (evicted.length) {
+                        // Identity-bound (path + hash + length) and bounded: the newest 256 survive a restart.
+                        const tombstones = join(root, EVICTION_TOMBSTONES_FILE);
+                        writeFileSync(`${tombstones}.tmp`, JSON.stringify([...readEvictionTombstones(root), ...evicted].slice(-EVICTION_TOMBSTONE_LIMIT)));
+                        renameSync(`${tombstones}.tmp`, tombstones);
                     }
-                    for (const [i, ref] of refs.entries()) {
-                        (opts.write ?? writeFileSync)(join(root, ref.path), Buffer.from(clean[i]).subarray(-EVIDENCE_TAIL_BYTES));
+                    if (!fits) {
+                        availability = "expired";
+                        for (const ref of refs)
+                            ref.availability = "expired";
+                    }
+                    else {
+                        for (const [i, ref] of refs.entries()) {
+                            (opts.write ?? writeFileSync)(join(root, ref.path), Buffer.from(clean[i]).subarray(-EVIDENCE_TAIL_BYTES));
+                        }
                     }
                 }
                 catch {
@@ -131,7 +211,7 @@ export function beginGateEvidence(cwd, gate, command, opts = {}, nonce) {
             }
             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] };
+                termination, availability, redaction: { material: redactionMaterial(counts), counts }, stdout: refs[0], stderr: refs[1] };
         },
     };
 }
@@ -428,7 +508,9 @@ export function freshFailures(entry, raw) {
     // OBS-42: diagnostic headings enrich fingerprints but cannot invalidate legacy baselines.
     const current = fingerprint(raw);
     const fresh = current.filter((f) => !known.has(f) && (!FAIL_ANCHOR_RE.test(f) || f.startsWith("FAIL ")));
-    return { failing: fresh.filter((f) => f !== UNRECOGNIZED_FAILURE), unreadable: current.includes(UNRECOGNIZED_FAILURE) };
+    // OBS-1123: the baseline-recorded half, named so a reader never has to infer it from the fresh half.
+    return { failing: fresh.filter((f) => f !== UNRECOGNIZED_FAILURE), unreadable: current.includes(UNRECOGNIZED_FAILURE),
+        forgiven: current.filter((f) => known.has(f)) };
 }
 /**
  * Operator directive 2026-08-12 (D-OBS-10): tickmarkr is package-manager agnostic.
@@ -880,7 +962,10 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         // below rather than reading as a verified green. Raise the ceiling by teaching isFailureShaped
         // that runner's position rule (leading verdict + identifier, or identifier + separator + trailing
         // verdict); loosening back to vocabulary re-opens OBS-278.
-        const { failing, unreadable } = freshFailures(entry, raw);
+        const { failing, unreadable, forgiven } = freshFailures(entry, raw);
+        // OBS-1123: which baseline-recorded fingerprints this verdict carried, and the capture that
+        // recorded them. Observational only — nothing below reads it to decide a verdict.
+        const provenance = baseline.provenance ? { baselineProvenance: baseline.provenance } : {};
         // T9: classify the FRESH diff before charging it. The complete runner output can legitimately
         // contain a baseline-recorded assertion beside a newly introduced infrastructure death; letting
         // that known assertion outvote the fresh birpc line turns machine failure into a worker defect.
@@ -957,7 +1042,9 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         }
         if (failing.length) {
             const headlined = headlineDetails(raw, failing);
-            const meta = { ...headlined.meta, ...(classification ? { classification } : {}) };
+            // A fresh red beside baseline-recorded ones names both halves, so no reader shows the new one as forgiven.
+            const meta = { ...headlined.meta, ...(classification ? { classification } : {}),
+                ...(forgiven.length ? { freshFingerprints: failing, forgivenFingerprints: forgiven, ...provenance } : {}) };
             record({ gate: name, pass: false, details: headlined.details, ...(Object.keys(meta).length ? { meta } : {}) });
             continue;
         }
@@ -981,7 +1068,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             gate: name,
             pass: true,
             details: `exit ${r.code} but only pre-existing failures (forgiven)${unreadable ? " — no failure shape recognized in this output, so a new failure from this runner is invisible to the baseline gate" : ""}`,
-            ...(classification ? { meta: { classification } } : {}),
+            meta: { ...(classification ? { classification } : {}), forgivenFingerprints: forgiven, ...provenance },
         });
     }
     return results;

package/dist/gates/cache.d.ts

@@ -9,8 +9,15 @@ export declare function lockfileHash(worktree: string): string;
 export declare function canonicalJson(obj: unknown): string;
 export declare function baselineIdentity(baseline?: Baseline): string;
 export declare function getWorktreeTree(worktree: string): Promise<string>;
+/** OBS-635: environment inputs a runner child reads that capacity and lifecycle do not already bind.
+ * ponytail: a named list, not the whole env (pids and terminal vars would defeat every reuse); extend
+ * it when another variable is shown to change what a runner executes. */
+export declare const RUNNER_ENV_KEYS: readonly ["PATH", "NODE_OPTIONS", "NODE_PATH", "NODE_ENV", "TZ"];
+export declare function runnerInputsHash(env?: NodeJS.ProcessEnv): string;
 export interface GateEnvironmentInput {
     nodeRuntime?: string;
+    /** the runner inputs hash; defaults to this process's (runnerInputsHash) */
+    runner?: string;
     lockfile?: string;
     worktree?: string;
     capacity?: RunCapacity;
@@ -21,6 +28,7 @@ export interface GateEnvironmentInput {
 }
 export interface EnvironmentParts {
     nodeRuntime: string;
+    runner: string;
     lockfile: string;
     capacity: RunCapacity;
     selectedSet?: readonly string[];

package/dist/gates/cache.js

@@ -77,8 +77,17 @@ export async function getWorktreeTree(worktree) {
         rmSync(scratch, { recursive: true, force: true });
     }
 }
+/** OBS-635: environment inputs a runner child reads that capacity and lifecycle do not already bind.
+ * ponytail: a named list, not the whole env (pids and terminal vars would defeat every reuse); extend
+ * it when another variable is shown to change what a runner executes. */
+export const RUNNER_ENV_KEYS = ["PATH", "NODE_OPTIONS", "NODE_PATH", "NODE_ENV", "TZ"];
+export function runnerInputsHash(env = process.env) {
+    return createHash("sha256").update(canonicalJson(Object.fromEntries(RUNNER_ENV_KEYS.map((k) => [k, env[k] ?? null]))))
+        .digest("hex").slice(0, 16);
+}
 export function environmentFingerprint(env) {
     const nodeRuntime = env.nodeRuntime ?? process.version;
+    const runner = env.runner ?? runnerInputsHash();
     const lockfile = env.lockfile ?? (env.worktree ? lockfileHash(env.worktree) : "no-lockfile");
     const cap = env.capacity ?? resolvedCapacity();
     const capacity = { forkCap: cap.forkCap, cores: cap.cores };
@@ -97,6 +106,7 @@ export function environmentFingerprint(env) {
     // explicit `false` and an npmrc `false` are the same policy for the child that ran.
     const payload = canonicalJson({
         nodeRuntime,
+        runner,
         lockfile,
         capacity,
         resolution,
@@ -107,7 +117,7 @@ export function environmentFingerprint(env) {
     const fingerprint = createHash("sha256").update(payload).digest("hex").slice(0, 16);
     return {
         fingerprint,
-        parts: { nodeRuntime, lockfile, capacity, selectedSet, verification },
+        parts: { nodeRuntime, runner, lockfile, capacity, selectedSet, verification },
     };
 }
 export async function computeVerificationIdentity(params) {
@@ -151,7 +161,7 @@ export function verificationIdentityKey(id) {
 export function formatReusedDetails(originalDetails, id) {
     const unadorned = originalDetails.replace(/^reused verdict \(identity: [^)]+\):\s*/, "");
     const envDesc = id.envParts
-        ? ` [node=${id.envParts.nodeRuntime}, lockfile=${id.envParts.lockfile}, capacity=${describeCapacity(id.envParts.capacity)}${id.envParts.selectedSet ? `, selected=${id.envParts.selectedSet.join(",")}` : ""}, protocol=${id.envParts.verification.protocol}, lifecycle=${id.envParts.verification.lifecycle} (${id.envParts.verification.source})]`
+        ? ` [node=${id.envParts.nodeRuntime}, runner=${id.envParts.runner}, lockfile=${id.envParts.lockfile}, capacity=${describeCapacity(id.envParts.capacity)}${id.envParts.selectedSet ? `, selected=${id.envParts.selectedSet.join(",")}` : ""}, protocol=${id.envParts.verification.protocol}, lifecycle=${id.envParts.verification.lifecycle} (${id.envParts.verification.source})]`
         : "";
     const gate = id.gate ?? "gate";
     const prefix = `reused ${id.scope === "tip" ? "tip " : ""}verdict (identity: gate=${gate} tree=${id.tree}${id.worktree ? ` worktree=${id.worktree}` : ""} command=${id.command} baseline=${id.baseline} env=${id.environment}${envDesc})`;

package/dist/gates/llm.d.ts

@@ -1,4 +1,5 @@
 import { type WorkerAdapter } from "../adapters/types.js";
+import type { Effort } from "../graph/schema.js";
 import { type ExecutorDriver, type Slot } from "../drivers/types.js";
 export declare const GATE_PANE_SEP = " \u00B7 ";
 export declare const COMPLETION_FAKING_CHECKLIST = "## Completion-faking checklist\nHunt for these concrete completion-faking shortcuts before ruling on any criterion:\n- hardcoded-result: output or fixture hardcoded to satisfy the stated criterion instead of real logic\n- test-weakening: tests skipped, deleted, or assertions loosened until failing behavior looks green\n- vacuous-assertion: a test that cannot fail (asserts a constant, asserts its own setup, no assertion)\n- fixture-overfit: implementation narrowed to the exact test inputs rather than the described behavior\n- echo-not-implement: criterion text echoed in names, comments, or strings without the behavior itself\n- stub-left-behind: TODO, throw, or no-op stub where the real implementation should be\n- error-swallowing: catch or fallback that hides failures instead of handling them\n- self-mocking: the code under test mocked or faked so the test exercises the mock\n- check-bypass: lint, type, or CI checks disabled, relaxed, or excluded to get green\n- rename-as-work: code moved or renamed and presented as the requested change\n- scope-padding: unrelated edits padding the diff while the criterion's behavior is untouched\nWhen a criterion fails, the verdict MUST name which shortcut above it matches, or state that none does.";
@@ -68,13 +69,19 @@ export interface LlmRunResult {
 }
 export declare const PROMPT_GLYPHS: readonly ["➜", "❯", "$", "%", ">>", ">"];
 export declare function reviewSeatOutput(raw: string, nonce: string, adapterBannerRows?: readonly string[]): string;
+/** OBS-1168(b): a judge/review seat whose pane could not be created or launched. Typed so the gates can
+ * contain it as seat recovery (another seat) or an infra park — never as a worker failure. */
+export declare class SeatLaunchError extends Error {
+    readonly seat: string;
+    constructor(seat: string, cause: unknown);
+}
 export declare const REVIEW_FIRST_LIVENESS_MS = 30000;
 export declare const REVIEW_SILENT_BYTE_FLOOR = 64;
-export declare function runHeadless(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, timeoutMs?: number): Promise<string>;
-export declare function runViaDriver(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via: LlmVia, timeoutMs?: number): Promise<string>;
+export declare function runHeadless(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, timeoutMs?: number, effort?: Effort): Promise<string>;
+export declare function runViaDriver(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via: LlmVia, timeoutMs?: number, effort?: Effort): Promise<string>;
 export declare function dewrapPaneVerdict(out: string, nonce: string): string;
-export declare function runLlmDetailed(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via?: LlmVia, timeoutMs?: number): Promise<LlmRunResult>;
-export declare function runLlm(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via?: LlmVia, timeoutMs?: number): Promise<string>;
+export declare function runLlmDetailed(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via?: LlmVia, timeoutMs?: number, effort?: Effort): Promise<LlmRunResult>;
+export declare function runLlm(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via?: LlmVia, timeoutMs?: number, effort?: Effort): Promise<string>;
 export declare function extractJson<T>(raw: string): T | null;
 /** Fable F3: verdict JSON must echo the call nonce — skip unbound or mismatched objects. */
 export declare function extractVerdictJson<T>(raw: string, nonce: string): T | null;

package/dist/gates/llm.js

@@ -81,19 +81,22 @@ export function gatePaneName(role, taskId, suffix = "") {
 // T2 ownership contract: a canonical owned fallback (the daemon's nameFor now emits one) passes
 // through untouched; run-gates' "-r1" judge-retry suffix becomes attempt+1 so the retry pane's name
 // stays contract-parseable (tickmarkr:judge:<task>:1:<runId>) instead of a corrupted-runId shape.
+// C-3 (D-669): the hop suffix is -r<N> — the judge-flake retry is -r1 and the adjudicator -r2, so the two
+// never share an owned name (a retained retry pane must not shadow the adjudicator's slot).
 export function rolePaneNameFromPrompt(prompt, fallback) {
-    const retry = fallback.endsWith("-r1");
-    const base = retry ? fallback.slice(0, -3) : fallback;
+    const hop = /-r([1-9])$/.exec(fallback);
+    const suffix = hop ? hop[0] : "";
+    const base = hop ? fallback.slice(0, -suffix.length) : fallback;
     const owned = parseOwnedName(base);
     if (owned)
-        return retry ? formatOwnedName({ ...owned, attempt: owned.attempt + 1 }) : base;
+        return hop ? formatOwnedName({ ...owned, attempt: owned.attempt + Number(hop[1]) }) : base;
     const id = prompt.match(/## Task ([^\n:]+):/)?.[1];
     if (!id)
         return fallback;
     if (prompt.startsWith("TICKMARKR-JUDGE"))
-        return gatePaneName("judge", id, retry ? "-r1" : "");
+        return gatePaneName("judge", id, suffix);
     if (prompt.startsWith("TICKMARKR-REVIEW"))
-        return gatePaneName("review", id, retry ? "-r1" : "");
+        return gatePaneName("review", id, suffix);
     return fallback;
 }
 const llmOutputCapture = new AsyncLocalStorage();
@@ -299,17 +302,27 @@ export function reviewSeatOutput(raw, nonce, adapterBannerRows = []) {
     // often the seat's first byte than the harness's exit marker, and the next read completes either.
     return trailer ? seat.slice(0, trailer.index) : seat;
 }
+/** OBS-1168(b): a judge/review seat whose pane could not be created or launched. Typed so the gates can
+ * contain it as seat recovery (another seat) or an infra park — never as a worker failure. */
+export class SeatLaunchError extends Error {
+    seat;
+    constructor(seat, cause) {
+        super(`seat ${seat} failed to launch: ${cause instanceof Error ? cause.message : String(cause)}`);
+        this.seat = seat;
+        this.name = "SeatLaunchError";
+    }
+}
 export const REVIEW_FIRST_LIVENESS_MS = 30_000;
 // OBS-1039: a seat that wrote ten bytes and went quiet escaped the zero-byte beat and sat to the
 // ceiling. Below this many seat-authored bytes at the first beat the seat is `silent` — demoted and
 // re-routed then, not at the ceiling. Pane path only; a headless runner buffers and keeps its ceiling.
 export const REVIEW_SILENT_BYTE_FLOOR = 64;
-async function runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs = 300000) {
+async function runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs = 300000, effort) {
     const dir = mkdtempSync(join(tmpdir(), "tickmarkr-llm-"));
     try {
         const pf = join(dir, "prompt.md");
         writeFileSync(pf, prompt);
-        const r = await sh(adapter.headlessCommand(pf, model), cwd, timeoutMs);
+        const r = await sh(adapter.headlessCommand(pf, model, effort), cwd, timeoutMs);
         const output = r.stdout + "\n" + r.stderr;
         const nonce = extractPromptNonce(prompt) ?? "";
         return { output, exitCode: r.code, timedOut: r.timedOut === true,
@@ -319,12 +332,12 @@ async function runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs = 3000
         rmSync(dir, { recursive: true, force: true });
     }
 }
-export async function runHeadless(adapter, model, prompt, cwd, timeoutMs = 300000) {
-    return (await runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs)).output;
+export async function runHeadless(adapter, model, prompt, cwd, timeoutMs = 300000, effort) {
+    return (await runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs, effort)).output;
 }
 // v1.1 default path: the same headless CLI call, but dispatched through the driver
 // as a visible named agent (herdr pane), with the quote-split completion wrapper.
-async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
+async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs = 300000, effort) {
     const dir = mkdtempSync(join(tmpdir(), "tickmarkr-llm-"));
     let slot;
     let accountant;
@@ -338,12 +351,18 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
         writeFileSync(scriptPath, [
             "export BASH_SILENCE_DEPRECATION_WARNING=1",
             bannerShell(),
-            adapter.headlessCommand(pf, model),
+            adapter.headlessCommand(pf, model, effort),
             gateExitTrailer(nonce),
         ].join("\n"));
-        slot = await via.driver.slot(cwd, rolePaneNameFromPrompt(prompt, via.name), via.label ? { label: via.label } : undefined);
-        via.onSlot?.(slot);
-        await via.driver.run(slot, paneDispatchCommand(scriptPath));
+        try {
+            slot = await via.driver.slot(cwd, rolePaneNameFromPrompt(prompt, via.name), via.label ? { label: via.label } : undefined);
+            via.onSlot?.(slot);
+            await via.driver.run(slot, paneDispatchCommand(scriptPath));
+        }
+        catch (error) {
+            forceClose = true; // a half-launched pane is closed, never kept
+            throw new SeatLaunchError(`${adapter.id}:${model}`, error);
+        }
         if (via.driver.sendKey) {
             try {
                 if (matchesTrustDialog(await via.driver.read(slot, 400), adapter.trustDialog)) {
@@ -487,8 +506,8 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
         }
     }
 }
-export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
-    return (await runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs)).output;
+export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs = 300000, effort) {
+    return (await runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs, effort)).output;
 }
 // OBS-155: a TUI renders the verdict as a bullet and HARD-wraps it at pane width with a 2-space
 // continuation indent, splitting words mid-token — so literal newlines land inside JSON string
@@ -549,15 +568,15 @@ export function dewrapPaneVerdict(out, nonce) {
     }
     return out;
 }
-export async function runLlmDetailed(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
+export async function runLlmDetailed(adapter, model, prompt, cwd, via, timeoutMs = 300000, effort) {
     const result = await (via
-        ? runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs)
-        : runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs));
+        ? runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs, effort)
+        : runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs, effort));
     llmOutputCapture.getStore()?.push(result.output);
     return result;
 }
-export async function runLlm(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
-    return (await runLlmDetailed(adapter, model, prompt, cwd, via, timeoutMs)).output;
+export async function runLlm(adapter, model, prompt, cwd, via, timeoutMs = 300000, effort) {
+    return (await runLlmDetailed(adapter, model, prompt, cwd, via, timeoutMs, effort)).output;
 }
 export function extractJson(raw) {
     const fenced = [...raw.matchAll(/```json\s*\n([\s\S]*?)```/g)].at(-1);

package/dist/gates/review.d.ts

@@ -51,6 +51,11 @@ export declare function fetchTaskDiff(worktree: string, baseRef: string, files?:
 export declare function checkDiffCap(gate: string, measured: number, cap: number, prefix?: string): GateResult | null;
 /** Apply the strict reviewable-logic cap and the finite, larger capture cap independently. */
 export declare function checkTaskDiffCaps(gate: string, measured: Pick<TaskDiffMeasurement, "logicBytes" | "captureBytes">, logicCap: number, prefix?: string): GateResult | null;
+export declare function isGarbageReview(result: GateResult): result is GateResult & {
+    meta: {
+        reviewer: string;
+    };
+};
 export declare function isDiffCapPark(result: GateResult): boolean;
 export declare function diffCapParkReason(results: GateResult[]): string | null;
 export declare function modelId(model: string): string;
@@ -111,7 +116,7 @@ prefer?: string[], // v1.53 T2: review.prefer — reorders eligible channels, ne
 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>, authors?: readonly string[]): BillingChannel | null;
-export type ReviewUnparseableCause = VerdictUnparseableCause | "launch-never-started" | "truncated" | "silent" | "closure-mismatch";
+export type ReviewUnparseableCause = VerdictUnparseableCause | "launch-never-started" | "truncated" | "silent" | "closure-mismatch" | "seat-launch-failed";
 /**
  * This shows the reviewer what the task DECLARED, never what the diff may actually reach. The diff
  * remains a separate stated input, so whether its touched paths fit the declaration stays a reviewer
@@ -135,4 +140,12 @@ 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;
+/**
+ * OBS-1052(2): a seat that lost the top of a long brief, or believed it had already filed its review,
+ * answered in prose — and prose is no verdict. So the requirement, naming THIS call's nonce with a
+ * valid example, is both the first and the last instruction of the brief. It is best-effort wording:
+ * the parser stays the authority, and nothing here reads approval out of prose.
+ */
+export declare function reviewResponseExample(nonce: string): string;
+export declare function reviewResponseRequirement(nonce: string): 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[], operatorContext?: string): Promise<GateResult>;