tickmarkr 2.6.0 → 2.6.2

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.";
@@ -70,11 +71,11 @@ export declare const PROMPT_GLYPHS: readonly ["➜", "❯", "$", "%", ">>", ">"]
 export declare function reviewSeatOutput(raw: string, nonce: string, adapterBannerRows?: readonly string[]): string;
 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

@@ -304,12 +304,12 @@ export const REVIEW_FIRST_LIVENESS_MS = 30_000;
 // 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 +319,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,7 +338,7 @@ 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);
@@ -403,7 +403,10 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
                 // That seat was killed by its configured timeout, not an early launch reroute.
                 if (now - startedAt >= timeoutMs)
                     break;
-                if (reviewing && !firstLivenessObserved && now - startedAt >= REVIEW_FIRST_LIVENESS_MS) {
+                // OBS-1177: the beat is armed for an INTERACTIVE (pane) driver only. On the subprocess driver
+                // a headless `claude -p` buffers every byte until it exits, so 0 seat bytes at 30 s is not a
+                // dead launch; that seat keeps its full ceiling, which still bounds it (fail-closed by timeout).
+                if (reviewing && via.driver.interactive && !firstLivenessObserved && now - startedAt >= REVIEW_FIRST_LIVENESS_MS) {
                     firstLivenessObserved = true;
                     // RS-2: the beat reads seat-authored bytes ALONE. CPU evidence never holds a preamble-only
                     // capture open to the ceiling; a seat that has not written one byte of its own is re-routed.
@@ -484,8 +487,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
@@ -546,15 +549,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

@@ -135,4 +135,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>;

package/dist/gates/review.js

@@ -8,10 +8,10 @@ import { getAdapter } from "../adapters/registry.js";
 import { shOk } from "../run/git.js";
 import { carryReviewFindings, observedReviewFingerprints, reviewFingerprintMatches, structuredFindings, UNIDENTIFIED } from "../run/journal.js";
 import { redactSecrets } from "../run/redact.js";
-import { marginalCostRank } from "../route/router.js";
+import { rankPreferredChannels, reviewPreferenceTieBreak } from "../route/role-pick.js";
 import { modelProvider } from "../route/preference.js";
 import { resolveStateDir } from "./cache.js";
-import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, parseAnchoredComments, runLlmDetailed, verdictNonceLine } from "./llm.js";
+import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, dewrapPaneVerdict, 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";
@@ -227,13 +227,6 @@ export function isReviewClosureMismatch(v, priorIds) {
     const priors = priorIds instanceof Set ? priorIds : new Set(priorIds);
     return ids.some((id) => matchClosureId(id, priors) === undefined);
 }
-// v1.53 T2: same entry grammar as routing.map.prefer (router.ts preferIndex — router is out of this
-// module's dependency direction for a private fn, so the 3 lines live here too): `adapter` matches
-// every channel of that adapter, `adapter:model` exactly one; unmatched channels sort after all entries.
-function reviewPreferIndex(c, prefer) {
-    const i = prefer.findIndex((p) => p === c.adapter || p === channelKey(c));
-    return i === -1 ? prefer.length : i;
-}
 /**
  * RF-1 (OBS-922 add.2/3): the tier a reviewer must meet is the maximum of the author's tier, the
  * task-declared floor, a configured `review.floor` tier and, on a second round or a retry, the prior
@@ -290,7 +283,7 @@ excludeVendors = new Set(), authors = [channelKey(author)]) {
         return null;
     // 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
+    const eligible = channels
         // Three independent axes: different vendor, different resolved provider identity (OBS-946: on initial pick
         // 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
@@ -300,8 +293,11 @@ excludeVendors = new Set(), authors = [channelKey(author)]) {
         && modelId(c.model) !== modelId(a.model))
         && !exclude.includes(channelKey(c))
         && !excludeVendors.has(c.vendor)
-        && TIER_RANK[c.tier] >= TIER_RANK[effectiveFloor])
-        .sort((a, b) => reviewPreferIndex(a, prefer) - reviewPreferIndex(b, prefer) || TIER_RANK[b.tier] - TIER_RANK[a.tier] || marginalCostRank(a) - marginalCostRank(b));
+        && TIER_RANK[c.tier] >= TIER_RANK[effectiveFloor]);
+    const ranked = rankPreferredChannels(eligible, prefer, {
+        includeUnpreferred: true,
+        tieBreak: reviewPreferenceTieBreak,
+    });
     const reviewer = [...ranked].sort((a, b) => Number(demoted.has(channelKey(a))) - Number(demoted.has(channelKey(b)))
         || history.lastIndexOf(channelKey(a)) - history.lastIndexOf(channelKey(b))
         || ranked.indexOf(a) - ranked.indexOf(b))[0] ?? null;
@@ -377,6 +373,33 @@ ${fingerprints}
 \`\`\`
 ${priorMaterials.map((finding, i) => `${i + 1}. ${finding.note}`).join("\n\n")}`;
 }
+/**
+ * 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 function reviewResponseExample(nonce) {
+    return JSON.stringify({
+        nonce, approve: false, resolved: [], reraised: [],
+        findings: [{ note: "path/to/file.ts:42 — the defect, in one line", severity: "material", defer: false, rationale: "" }],
+        comments: [],
+    });
+}
+export function reviewResponseRequirement(nonce) {
+    return `## Response requirement
+Your reply must end with exactly ONE JSON object whose "nonce" is "${nonce}" — this brief's nonce, never one from an earlier brief. A valid example (a rejection; replace every value with your own verdict):
+${reviewResponseExample(nonce)}
+This holds even if you already filed or posted a review of this task elsewhere (an earlier session or brief, a PR comment): that review is not on record here, so restate it now as this JSON with nonce "${nonce}". Prose saying a review was filed or approved is recorded as no verdict; approval is never inferred from it.`;
+}
+// The example parses by design, so an echo of the brief (a CLI printing its prompt, a pane showing it)
+// would otherwise read as the seat's own verdict — or as its participation when it wrote only prose.
+// Removed verbatim or hard-wrapped (renderer whitespace and chrome between any two characters) before
+// the verdict is extracted or its absence classified; the saved raw bytes keep it as evidence.
+function withoutExampleEcho(raw, nonce) {
+    const chars = [...reviewResponseExample(nonce).replace(/\s+/g, "")];
+    return raw.replace(new RegExp(chars.map((c) => c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[\\s│|]*"), "g"), "");
+}
 export async function reviewGate(task, worktree, baseRef, author, channels, adapters, cfg, via, excludeReviewers, 
 // OBS-196: run dir for raw-output persistence on an unparseable verdict; absent (older callers,
 // direct tests) skips persistence and changes nothing else.
@@ -486,7 +509,10 @@ carriedAuthors = [], operatorContext) {
     const suiteBudget = ownTestFiles.length
         ? `You may run at most the task's own test files explicitly named in files[]; these are the only suites you may run: ${ownTestFiles.map((file) => `\`${file}\``).join(", ")}.`
         : "No suite may be run: files[] names no explicit test file owned by this task.";
+    const responseRequirement = reviewResponseRequirement(nonce);
     const prompt = `TICKMARKR-REVIEW
+${responseRequirement}
+
 You are a skeptical cross-vendor code reviewer. Another agent (vendor: ${author.adapter}) authored this diff.
 Look for correctness bugs, security issues, and acceptance-criteria gaps. Approve only if you would merge it.
 
@@ -531,6 +557,8 @@ For every prior material, put its fingerprint in exactly one of resolved (verifi
 (still a blocking defect). Use only the listed fingerprints; never omit one or put it in both lists.
 Approve iff no material finding remains and every prior material is resolved.
 The top-level comments array is optional. Use it only for actionable line-anchored feedback.
+
+${responseRequirement}
 `;
     // Filenames are journaled (daemon.ts lifts meta.rawPath/briefPath onto the gate-result row), so they
     // must be reproducible from the same inputs — the verdict nonce is cryptographically random and would
@@ -573,7 +601,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     // output until completion — runLlm's 300s default killed reviews mid-flight, returning empty
     // stdout that read as "unparseable" and escalated to re-implementation of green code
     // (run-20260709-104447 P87-09). The configured ceiling defaults to that measured 15 minutes.
-    cfg.review.timeoutMs);
+    cfg.review.timeoutMs, reviewer.effort);
     const raw = llm.output;
     let saved;
     if (artifactDir) {
@@ -586,7 +614,11 @@ 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);
+    // A pane's own dewrap stops at the first parseable nonce-bound object; once the example's echo is gone
+    // a genuinely wrapped verdict behind it is reconstructed here, exactly as llm.ts would have.
+    const echoFree = withoutExampleEcho(raw, nonce);
+    const seat = via ? dewrapPaneVerdict(echoFree, nonce) : echoFree;
+    const v = extractVerdictJson(seat, nonce);
     const findings = v && Array.isArray(v.findings) ? v.findings : null;
     const priorIds = priorMaterials;
     const closureInvalid = isReviewClosureInvalid(v, priorIds);
@@ -600,7 +632,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
             : llm.launchNeverStarted ? "launch-never-started"
                 : llm.silentAtBeat ? "silent"
                     : llm.timedOut ? (bytes > 0 ? "truncated" : "silent")
-                        : classifyVerdictCause(raw, nonce, "approve", llm);
+                        : classifyVerdictCause(seat, nonce, "approve", llm);
         const failure = cause === "malformed-verdict"
             ? "review output unparseable"
             : cause === "closure-mismatch"

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

@@ -7,6 +7,7 @@ import { type GateVia } from "./llm.js";
 import { type PriorReviewer } from "./review.js";
 import type { GateResult } from "./types.js";
 import { type VerificationRetryCause } from "../run/recovery.js";
+import { type PreserveProducer } from "../run/git.js";
 import { type StructuredFinding } from "../run/journal.js";
 import { type VerificationScope } from "./cache.js";
 export type LoadProvider = () => number;
@@ -16,7 +17,8 @@ export declare function resetLoadProviderForTests(): void;
 /**
  * One gate's own measurement, taken WHERE THE GATE RUNS. `durationMs` sums that gate's execution
  * intervals and nothing between them, so the composite `test` gate (a selected screen, then other
- * gates, then the full suite) reports the two suites' cost rather than the span containing them —
+ * gates, then the full suite) reports the two suites' cost rather than the span containing them
+ * (split across the two rows when the screen is published before semantic gates, OBS-1176) —
  * and no consumer has to re-derive a duration by subtracting journal timestamps, which measures the
  * queue as well as the work. Load is sampled at each interval's endpoints and every second within it;
  * start preserves the scheduling input while max and mean retain sustained interior saturation.
@@ -71,6 +73,9 @@ export interface GateContext {
     /** Explicit worker funding requires fresh red measurements, never a gate waiver. */
     cachedRedBypass?: "operator-rerun";
     carriedAuthors?: readonly string[];
+    /** The attempt whose worker last wrote the gated checkout; a dirty-tree refusal stamps it on the
+     * preserve commit and its row. Absent (standalone verify, gate-only restores) preserves as "unknown". */
+    producer?: PreserveProducer;
     reviewHistory?: string[];
     priorReviewers?: PriorReviewer[];
     artifactDir?: string;

package/dist/gates/run-gates.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
 import { loadavg, tmpdir } from "node:os";
 import { join, posix } from "node:path";
-import { channelKey, shq } from "../adapters/types.js";
+import { channelKey, configuredEffort, shq } from "../adapters/types.js";
 import { TIER_RANK } from "../config/config.js";
 import { getAdapter } from "../adapters/registry.js";
 import { GATE_NAMES } from "../graph/schema.js";
@@ -17,7 +17,7 @@ import { scopeGate } from "./scope.js";
 import { evaluateManifestedTest, isVitestTestCommand } from "./test-manifest.js";
 import { executionSignal } from "../run/execution-budget.js";
 import { failureDisposition } from "../run/recovery.js";
-import { dependencyLinkRefusal, preserveWorktree, shGit, resolvedCapacity, verificationProtocol } from "../run/git.js";
+import { dependencyLinkRefusal, preserveWorktree, producerFields, shGit, resolvedCapacity, verificationProtocol } from "../run/git.js";
 import { withJudgeInvocationEvidence } from "../run/journal.js";
 import { computeVerificationIdentity, verificationIdentityKey, formatReusedRow, getVerdictStore, isInfraResult, resolveStateDir, reusedIdentity, } from "./cache.js";
 const productionLoadProvider = () => loadavg()[0] ?? 0;
@@ -43,13 +43,14 @@ function instrumentLlmAdapter(adapter, clocks) {
     return new Proxy(adapter, {
         get(target, property) {
             if (property === "headlessCommand") {
-                return (promptFile, model) => {
-                    const command = target.headlessCommand(promptFile, model);
+                return (promptFile, model, effort) => {
+                    const command = target.headlessCommand(promptFile, model, effort);
                     const dir = mkdtempSync(join(tmpdir(), "tickmarkr-gate-invocation-"));
                     const startedAtPath = join(dir, "started-at");
                     const completedAtPath = join(dir, "completed-at");
                     clocks.push({
                         channel: channelKey({ adapter: target.id, model }),
+                        ...(effort ? { effort } : {}),
                         preparedAt: Date.now(),
                         startedAtPath,
                         completedAtPath,
@@ -85,7 +86,7 @@ function finishLlmDispatches(clocks) {
         finally {
             rmSync(clock.dir, { recursive: true, force: true });
         }
-        return { channel: clock.channel, durationMs: completedAt - startedAt };
+        return { channel: clock.channel, ...(clock.effort ? { effort: clock.effort } : {}), durationMs: completedAt - startedAt };
     });
 }
 async function captureLlmDispatches(adapters, run) {
@@ -223,6 +224,7 @@ async function runVitestManifestGate(worktree, cmd, baseline, selected, artifact
         overallCeilingMs: effectiveCeilingMs(entry),
         artifactDir,
         evidence: retry.evidence,
+        retryBaseCommand: retry.retryBaseCommand, // OBS-1166: the un-narrowed command for a selected screen's stranded retry
     });
     const reportPath = outcome.reportPath;
     const evidence = { evidenceReceipt: outcome.evidenceReceipt, evidenceReceipts: outcome.evidenceReceipts };
@@ -340,10 +342,14 @@ export async function runGates(task, ctx) {
     const enabled = (g) => task.gates.includes(g) && (g !== "acceptance" && g !== "review" || shapeGates?.[g] !== false);
     const failed = () => results.some((r) => !r.pass);
     // T4 (OBS-265): a GREEN selected-test run is a screen, not the round's verdict — the merge-candidate
-    // round re-runs the full suite on the same commit and THAT is what the round reports. Held here so
-    // exactly one `test` gate-result ever leaves a round, always carrying which suite spoke for it.
+    // round re-runs the full suite on the same commit and THAT is what the round reports. With no
+    // semantic gate to act on it, the screen is held so its full suite speaks for it in one row.
     // (A RED screen IS the verdict: the round ends there, so it is recorded immediately.)
     let heldTest;
+    // OBS-1176: when acceptance/review WILL act on a green screen, the screen is published before they
+    // start, as its own selected row. The full suite afterwards is a second invocation on its own row —
+    // it carries only its own receipts and interval, so it neither erases nor re-counts the screen.
+    const publishScreen = enabled("acceptance") || enabled("review");
     // v2.0 T2 (OBS-554): this round's per-gate measurement. Every interval a gate actually spends
     // executing is added HERE, at the call site that runs it, so a gate that runs twice (the test
     // gate's screen and its full suite) sums to its own cost and never to the span between them.
@@ -482,7 +488,7 @@ export async function runGates(task, ctx) {
         let preservedRef;
         let preservationError;
         try {
-            preservedRef = await preserveWorktree(ctx.worktree);
+            preservedRef = await preserveWorktree(ctx.worktree, ctx.producer);
         }
         catch (error) {
             // Never masks the refusal, but never pretends a snapshot exists either — surfaced below.
@@ -537,6 +543,7 @@ export async function runGates(task, ctx) {
             dirtyWorktree: true,
             ref: preservedRef,
             preservedRef,
+            ...producerFields(ctx.producer),
             paths: dirtyPaths,
             files: dirtyPaths,
             path: primaryFile,
@@ -583,7 +590,7 @@ export async function runGates(task, ctx) {
         let preservedRef;
         let preservationError;
         try {
-            preservedRef = await preserveWorktree(ctx.worktree);
+            preservedRef = await preserveWorktree(ctx.worktree, ctx.producer);
         }
         catch (error) {
             preservationError = error instanceof Error ? error.message : String(error);
@@ -614,6 +621,7 @@ export async function runGates(task, ctx) {
                 dirtyAtRoundEnd: true,
                 ref: preservedRef,
                 preservedRef,
+                ...producerFields(ctx.producer),
                 paths: dirtyPaths,
                 files: dirtyPaths,
                 path: primaryFile,
@@ -677,7 +685,7 @@ 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), evidence }))
+                        ? await measure(g, () => runVitestManifestGate(ctx.worktree, commands.test, ctx.baseline, selected, ctx.artifactDir, { ...retryOptions(identity), evidence, ...(selected ? { retryBaseCommand: ctx.commands.test } : {}) }))
                         : (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 {
@@ -708,6 +716,13 @@ export async function runGates(task, ctx) {
                 const screened = { ...r, meta: { ...r.meta, selectedTests: selected } };
                 if (!screened.pass)
                     await record(screened);
+                else if (publishScreen) {
+                    await record(screened);
+                    // The screen's interval now lives on its own row; the full suite measures from zero.
+                    spans.delete("test");
+                    loadSamples.delete("test");
+                    selectedDurationMs = undefined;
+                }
                 else {
                     heldTest = withTelemetry(screened);
                     results.push(heldTest);
@@ -812,8 +827,8 @@ export async function runGates(task, ctx) {
         // Separate from `invocations` above deliberately: that array is transcript evidence and records
         // one entry per CAPTURED OUTPUT, so a dispatch that produced none contributes nothing to it.
         const invocationSpans = [];
-        const invokeJudge = async (adapter, model, via) => {
-            const captured = await captureLlmDispatches([adapter], ([instrumented]) => acceptanceGate(task, ctx.worktree, ctx.baseRef, { adapter: instrumented, model }, via, { testCmd: ctx.commands.test, diffCap: ctx.cfg.gates.diffCap }));
+        const invokeJudge = async (adapter, model, via, effort) => {
+            const captured = await captureLlmDispatches([adapter], ([instrumented]) => acceptanceGate(task, ctx.worktree, ctx.baseRef, { adapter: instrumented, model, effort }, via, { testCmd: ctx.commands.test, diffCap: ctx.cfg.gates.diffCap }));
             // The instrumented adapter is reached only by runLlm. Deterministic oracles and diff-cap exits
             // never call headlessCommand, so they produce no clock and cannot manufacture an invocation.
             invocationSpans.push(...captured.invocations);
@@ -835,7 +850,8 @@ export async function runGates(task, ctx) {
             }
             return captured.value;
         };
-        let a = await invokeJudge(judgeAdapter, ctx.cfg.judge.model, jvia);
+        // OBS-1182: every judge seat launches at its OWN configured effort, never the worker's.
+        let a = await invokeJudge(judgeAdapter, ctx.cfg.judge.model, jvia, configuredEffort(ctx.cfg, ctx.cfg.judge));
         // GATE-09: an unparseable judge verdict retries the JUDGE exactly once on a failover channel — never
         // the worker (run-20260711-185020 P43-03 L70-72 billed a judge flake as a worker attempt). The flaked
         // first verdict NEVER enters results (no false gate-result journal event, no operator notify, no stale
@@ -871,7 +887,7 @@ export async function runGates(task, ctx) {
                 ? { driver: ctx.via.driver, keep: ctx.via.keep, onSlot: ctx.via.onSlot, name: ctx.via.nameFor("judge", retryAdapter.id) + "-r1", label: ctx.via.labelFor("judge") }
                 : undefined;
             // the retry IS a second acceptanceGate call: one code path, one parser, zero new parse leniency.
-            a = await invokeJudge(retryAdapter, retry.model, retryJvia);
+            a = await invokeJudge(retryAdapter, retry.model, retryJvia, configuredEffort(ctx.cfg, retry));
             a = { ...a, meta: { ...a.meta, judgeRetry: { flaked: flakedKey, retried: channelKey({ adapter: retry.adapter, model: retry.model }) } } };
         }
         // No dispatch, no key: a deterministic-oracle round writes no `invocations` field rather than an
@@ -1087,9 +1103,10 @@ export async function runGates(task, ctx) {
     }
     // The merge-candidate round: every other gate is green, so THIS round is the one that can merge —
     // the full suite runs on the exact gated commit before the pipeline reports green. Nothing merges
-    // on a subset (spec: "nothing merges without a complete green suite"). Its verdict SUPERSEDES the
-    // held screen rather than joining it: one `test` entry in the record, one `test` end event in the
-    // stream, and `fullSuite` says which suite spoke while `selectedTests` keeps what the screen ran.
+    // on a subset (spec: "nothing merges without a complete green suite"). Its verdict replaces the
+    // screen's entry in the returned record (one `test` entry), and `fullSuite` says which suite spoke
+    // while `selectedTests` keeps what the screen ran. In the stream, a held screen is superseded (one
+    // `test` end event); a published screen keeps its own earlier event and this is the second.
     if (selected) {
         await emitStart("test");
         // This is the last shell command a round can run — the judge's named-test oracle (acceptance.ts)

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

@@ -1,5 +1,7 @@
 import { type GateEvidenceOptions, type BaselineFileDuration } from "./baseline.js";
 import type { GateEvidenceReceipt } from "../run/protocol.js";
+export declare const VITEST_CACHE_ENV = "TICKMARKR_VITEST_CACHE_DIR";
+export declare function worktreeVitestCache(cwd: string, inherited?: string): string;
 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
@@ -144,6 +146,15 @@ export declare function discoverTestManifest(cmd: string, cwd: string, opts: {
  * runner cannot list (a null compares nothing — it never manufactures a deficit). The suite is not
  * run here; the capture already ran it once. */
 export declare function manifestFileCount(cmd: string, cwd: string): Promise<number | null>;
+/** The stranded single-fork retry: positional filters are substring matches that OR with any filter
+ * the command already carries, and under a `projects` config the CLI `--exclude` never subtracts such a
+ * selection (OBS-1166: a selected screen's retry rediscovered the whole selection and refused). So the
+ * retry is built from the UN-narrowed base command, its own `--` rule, the stranded files as the only
+ * positional filters, and an `--exclude` of every completed file; the caller then requires discovery
+ * to prove the exact retry set before launch. OBS-1180: Vitest matches an absolute filter against the
+ * module path it resolved through every symlink, so the filters are rooted at the canonical realpath of
+ * `cwd` — a symlinked worktree root otherwise filters to an empty discovery. */
+export declare function singleForkRetryCommand(base: string, cwd: string, stranded: readonly string[], completed: readonly string[]): string;
 /** One configured runner execution, and its own collection under the same arguments and environment.
  * The installed runner is trusted (R28 add.1 option B); the nonce catches stale artifacts, not forgery. */
 export declare function evaluateManifestedTest(cmd: string, cwd: string, opts: {
@@ -152,4 +163,7 @@ export declare function evaluateManifestedTest(cmd: string, cwd: string, opts: {
     overallCeilingMs?: number;
     artifactDir?: string;
     evidence?: GateEvidenceOptions;
+    /** OBS-1166: the configured command BEFORE a selected screen narrowed it, so a stranded retry's
+     * only positional filters are the stranded files. Absent (a full suite), `cmd` is that command. */
+    retryBaseCommand?: string;
 }): Promise<ManifestGateOutcome>;

package/dist/gates/test-manifest.js

@@ -1,11 +1,20 @@
 import { createHash, randomBytes } from "node:crypto";
-import { existsSync, mkdtempSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { isAbsolute, join, relative, sep } from "node:path";
+import { isAbsolute, join, relative, resolve, 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";
+// Outside the shared dependency symlink and ignored by the shipped repository.
+export const VITEST_CACHE_ENV = "TICKMARKR_VITEST_CACHE_DIR";
+export function worktreeVitestCache(cwd, inherited) {
+    const local = resolve(cwd, ".vitest-cache");
+    const candidate = inherited ? resolve(cwd, inherited) : local;
+    const within = relative(local, candidate);
+    return within === "" || (!isAbsolute(within) && within !== ".." && !within.startsWith(`..${sep}`))
+        ? candidate : local;
+}
 /**
  * VL-1 (OBS-985 lineage): a test gate's completion must be the runner's OWN report, never a stdout
  * count. `fileCountDeficit` (baseline.ts) reads a summary LINE — a selected screen's smaller count
@@ -387,6 +396,7 @@ export function runManifestedTest(cmd, cwd, opts) {
  * verdict measured with `pretest` hooks is never compared to one without. */
 function manifestEnvironment(cwd) {
     const env = { ...process.env, PATH: `${join(cwd, "node_modules/.bin")}:${process.env.PATH ?? ""}`,
+        [VITEST_CACHE_ENV]: worktreeVitestCache(cwd),
         [FORK_CAP_ENV]: String(resolvedCapacity().forkCap), [SUITE_PARENT_ENV]: String(process.pid) };
     const verification = verificationProtocol(env, cwd);
     for (const key of ROUTING_ENV_SEAMS)
@@ -436,6 +446,9 @@ export async function manifestFileCount(cmd, cwd) {
     catch {
         return null;
     }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    } // OBS-1155: the listing directory is the capture's alone, listed or not
 }
 /** Vitest's forks pool awaits the parallel phase, then throws before the single-fork phase
  * on any rejected worker. Recover only that exact, fully accounted-for boundary. */
@@ -474,6 +487,23 @@ function strandedSingleForkFiles(files, nonce, run) {
         return;
     return single;
 }
+/** The stranded single-fork retry: positional filters are substring matches that OR with any filter
+ * the command already carries, and under a `projects` config the CLI `--exclude` never subtracts such a
+ * selection (OBS-1166: a selected screen's retry rediscovered the whole selection and refused). So the
+ * retry is built from the UN-narrowed base command, its own `--` rule, the stranded files as the only
+ * positional filters, and an `--exclude` of every completed file; the caller then requires discovery
+ * to prove the exact retry set before launch. OBS-1180: Vitest matches an absolute filter against the
+ * module path it resolved through every symlink, so the filters are rooted at the canonical realpath of
+ * `cwd` — a symlinked worktree root otherwise filters to an empty discovery. */
+export function singleForkRetryCommand(base, cwd, stranded, completed) {
+    let root = cwd;
+    try {
+        root = realpathSync(cwd);
+    }
+    catch { /* unreadable cwd — the exact rediscovery below fails closed */ }
+    const excluded = completed.map(f => `--exclude=${shq(f.replace(/[\\*?[\]{}()!+@]/g, "\\$&"))}`).join(" ");
+    return `${base}${runnerInvocation(base, cwd).separator} ${stranded.map(f => shq(join(root, f))).join(" ")} ${excluded}`;
+}
 /** One configured runner execution, and its own collection under the same arguments and environment.
  * The installed runner is trusted (R28 add.1 option B); the nonce catches stale artifacts, not forgery. */
 export async function evaluateManifestedTest(cmd, cwd, opts) {
@@ -518,10 +548,7 @@ export async function evaluateManifestedTest(cmd, cwd, opts) {
             recovery = { firstNonce: nonce, firstReportPath: reportPath, retryNonce, files: stranded };
             nonce = retryNonce;
             reportPath = join(dir, `test-manifest-report-${nonce}.json`);
-            // Positional filters are substring matches (and OR with existing filters). Exclude every
-            // completed file as well, then require discovery to prove the exact retry set before launch.
-            const excluded = files.filter(f => !stranded.includes(f)).map(f => `--exclude=${shq(f.replace(/[\\*?[\]{}()!+@]/g, "\\$&"))}`).join(" ");
-            const retryCommand = `${cmd}${invocation.separator} ${stranded.map(f => shq(join(cwd, f))).join(" ")} ${excluded}`;
+            const retryCommand = singleForkRetryCommand(opts.retryBaseCommand ?? cmd, cwd, stranded, files.filter(f => !stranded.includes(f)));
             const listed = await discoverTestManifest(retryCommand, cwd, { dir, nonce, env,
                 overallCeilingMs: opts.overallCeilingMs, evidence: { ...opts.evidence, artifactDir: opts.evidence?.artifactDir ?? dir } });
             evidenceReceipts.push(...listed.evidenceReceipts);

package/dist/graph/graph.d.ts

@@ -36,8 +36,12 @@ export declare function addEvidence(g: RunGraph, id: string, patch: {
     gateResults?: unknown[];
 }): RunGraph;
 export declare function chainDepth(g: RunGraph): Map<string, number>;
-export declare function readyTasks(g: RunGraph): Task[];
-export declare function dispatchWaves(g: RunGraph, concurrency: number): Map<string, number>;
+export declare function readyTasks(g: RunGraph, prioritized?: ReadonlySet<string>): Task[];
+export declare function batteryPriority(actions: Iterable<{
+    taskId: string;
+    authority: string;
+}>): Set<string>;
+export declare function dispatchWaves(g: RunGraph, concurrency: number, prioritized?: ReadonlySet<string>): Map<string, number>;
 export declare function isComplete(g: RunGraph): boolean;
 export declare function isStalled(g: RunGraph): boolean;
 export declare function closureReaches(g: RunGraph, taskId: string, pred: (t: Task) => boolean): boolean;

package/dist/graph/graph.js

@@ -191,21 +191,32 @@ export function chainDepth(g) {
 // OBS-1018: admission is critical-path order — deepest chain root first, ties in declaration order.
 // The daemon's dispatch loop slices this list unchanged. Stated limit: resume-restore of previously
 // in-flight attempts keeps its own precedence (src/run/daemon.ts); only fresh admission is ordered here.
-export function readyTasks(g) {
+// OBS-1158: `prioritized` names tasks holding a pending battery (recheck) approval. Among READY tasks
+// of equal depth an approved recheck precedes fresh work; deeper fresh work keeps its rank, and a
+// recheck that is not ready (dependency-blocked) is not admitted at all, so it gains nothing here.
+export function readyTasks(g, prioritized = NO_PRIORITY) {
     const done = new Set(g.tasks.filter((t) => t.status === "done").map((t) => t.id));
     const depth = chainDepth(g);
+    const rank = (t) => (prioritized.has(t.id) ? 1 : 0);
     return g.tasks
         .filter((t) => t.status === "pending" && t.deps.every((d) => done.has(d)))
-        .sort((a, b) => depth.get(b.id) - depth.get(a.id)); // Array#sort is stable: equal depths keep declaration order
+        .sort((a, b) => depth.get(b.id) - depth.get(a.id) || rank(b) - rank(a)); // Array#sort is stable: remaining ties keep declaration order
+}
+const NO_PRIORITY = new Set();
+// OBS-1158: the one seam plan and the daemon share for battery priority — journal approval actions
+// in (src/run/journal.ts pendingApprovalActions), the ids whose pending authority is `battery` out.
+// Waivers, worker-funding approvals and inert releases never qualify; a consumed approval is absent.
+export function batteryPriority(actions) {
+    return new Set([...actions].filter((a) => a.authority === "battery").map((a) => a.taskId));
 }
 // OBS-1018: the dispatch wave each pending task would enter at `concurrency` slots if every wave
 // took one tick — computed by draining readyTasks, so plan and daemon can never disagree on order.
 // Tasks already past pending carry no wave.
-export function dispatchWaves(g, concurrency) {
+export function dispatchWaves(g, concurrency, prioritized = NO_PRIORITY) {
     const waves = new Map();
     let sim = g;
     for (let wave = 1;; wave++) {
-        const batch = readyTasks(sim).slice(0, Math.max(1, concurrency));
+        const batch = readyTasks(sim, prioritized).slice(0, Math.max(1, concurrency));
         if (!batch.length)
             return waves;
         for (const t of batch) {