tickmarkr 2.6.1 → 2.6.2

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);
@@ -487,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
@@ -549,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

@@ -11,7 +11,7 @@ import { redactSecrets } from "../run/redact.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";
@@ -373,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.
@@ -482,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.
 
@@ -527,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
@@ -569,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) {
@@ -582,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);
@@ -596,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

@@ -17,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.

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";
@@ -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) {
@@ -341,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.
@@ -711,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);
@@ -815,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);
@@ -838,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
@@ -874,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
@@ -1090,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

@@ -151,7 +151,9 @@ export declare function manifestFileCount(cmd: string, cwd: string): Promise<num
  * 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. */
+ * 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. */

package/dist/gates/test-manifest.js

@@ -492,10 +492,17 @@ function strandedSingleForkFiles(files, nonce, run) {
  * 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. */
+ * 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(cwd, f))).join(" ")} ${excluded}`;
+    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. */

package/dist/graph/schema.d.ts

@@ -4,12 +4,14 @@ export declare const GRAPH_ROUTING_MODES: readonly ["partner-led", "risk-based",
 export declare const STATUSES: readonly ["pending", "running", "gated", "failed", "done", "human"];
 export declare const GATE_NAMES: readonly ["build", "test", "lint", "evidence", "scope", "acceptance", "review"];
 export declare const TIERS: readonly ["cheap", "mid", "frontier"];
+export declare const EFFORTS: readonly ["low", "medium", "high"];
 export declare const SPEC_SOURCES: readonly ["speckit", "gsd", "prd", "native"];
 export declare const ORACLES: readonly ["command", "test", "judge"];
 export type Shape = (typeof SHAPES)[number];
 export type TaskStatus = (typeof STATUSES)[number];
 export type GateName = (typeof GATE_NAMES)[number];
 export type Oracle = (typeof ORACLES)[number];
+export type Effort = (typeof EFFORTS)[number];
 export type SpecSource = (typeof SPEC_SOURCES)[number];
 export declare const AcceptanceItemSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     oracle: z.ZodLiteral<"command">;

package/dist/graph/schema.js

@@ -7,6 +7,8 @@ export const STATUSES = ["pending", "running", "gated", "failed", "done", "human
 export const GATE_NAMES = ["build", "test", "lint", "evidence", "scope", "acceptance", "review"];
 const MANDATORY_GATES = ["build", "test", "lint", "evidence", "scope"];
 export const TIERS = ["cheap", "mid", "frontier"];
+// OBS-1182: launch effort — channel metadata beside tier, never part of model identity or channelKey.
+export const EFFORTS = ["low", "medium", "high"];
 export const SPEC_SOURCES = ["speckit", "gsd", "prd", "native"];
 // v1.19 acceptance oracles: command (exit code), test (named test), judge (LLM, free-text rubric).
 // A plain string is the read-old/write-new compat form — semantically a judge oracle (spec §2).

package/dist/plan/scope.js

@@ -169,7 +169,7 @@ function bindCandidate(candidate, channels) {
             `(doctor found: ${channels.map((ch) => `${ch.adapter}:${ch.model}`).join(", ") || "(nothing)"}) — ` +
             "re-run scope --preview and confirm again");
     }
-    return { adapter: c.adapter, model: c.model, channel: c.channel, tier: c.tier };
+    return { adapter: c.adapter, model: c.model, channel: c.channel, tier: c.tier, ...(c.effort ? { effort: c.effort } : {}) };
 }
 // Adapter-level probes establish the current installation/auth state, but shipped adapters do not
 // return per-model verdicts from probe(). Preserve cached verdicts only where that fresh snapshot is
@@ -202,7 +202,7 @@ export async function scopeIntent(intentFile, repoRoot, options) {
             driver, name: `scope-${name}-${attempts}-${adapter.id}`, label: "SCOPE",
             keep: options.cfg.visibility.keepPanes === "forever",
         } : undefined;
-        const draft = extractDraft(await runLlm(adapter, assignment.model, prompt, repoRoot, via));
+        const draft = extractDraft(await runLlm(adapter, assignment.model, prompt, repoRoot, via, undefined, assignment.effort));
         let tasks;
         try {
             tasks = validateDraft(draft);

package/dist/route/preference.d.ts

@@ -11,6 +11,16 @@ export declare const routingModelProvider: typeof modelProvider;
 export declare const modelRouteIdentity: (model: string, fallback?: string) => string;
 export declare const channelRouteIdentity: (key: string, fallback?: string) => string;
 export declare function routingEntrySeatLines(cfg: TickmarkrConfig): string[];
+export declare const observedIdentity: (health: Record<string, AuthHealth> | null | undefined, adapter: string, model: string) => string | undefined;
+export declare const observedSeat: (health: Record<string, AuthHealth> | null | undefined, adapter: string, model: string) => {
+    adapter: string;
+    model: string;
+    identity: string;
+} | {
+    adapter: string;
+    model: string;
+    identity?: undefined;
+};
 export declare function excludedChannels(cfg: TickmarkrConfig, adapters: {
     id: string;
 }[] | string[], health: Record<string, AuthHealth>): {
@@ -59,6 +69,14 @@ export interface DenyPreferCollision {
     detail: string;
     disallowed: Disallowed;
 }
-export declare function preferEntryDenied(p: string, cfg: TickmarkrConfig): Disallowed | null;
-export declare function denyPreferCollisions(cfg: TickmarkrConfig, shapes?: Iterable<string>): DenyPreferCollision[];
+export declare function preferEntryDenied(p: string, cfg: TickmarkrConfig, health?: Record<string, AuthHealth> | null): Disallowed | null;
+export declare function denyPreferCollisions(cfg: TickmarkrConfig, shapes?: Iterable<string>, health?: Record<string, AuthHealth> | null): DenyPreferCollision[];
+export interface DeadPoolEntry {
+    shape: string;
+    entry: string;
+    disallowed: Disallowed;
+    admitted: string[];
+}
+export declare function deadPoolEntries(cfg: TickmarkrConfig, shapes?: Iterable<string>, health?: Record<string, AuthHealth> | null): DeadPoolEntry[];
+export declare function deadPoolEntryLine({ shape, entry, disallowed, admitted }: DeadPoolEntry): string;
 export declare function denyPreferCollisionLine({ kind, shape, detail, disallowed }: DenyPreferCollision): string;

package/dist/route/preference.js

@@ -47,6 +47,13 @@ export function routingEntrySeatLines(cfg) {
     add("routing.deny.workers.models", cfg.routing.deny?.workers?.models, ["worker"]);
     return lines;
 }
+// OBS-1143: the probed identity doctor cached for adapter:model — the one discoverChannels routes
+// with. Absent ⇒ unknown, and the deny matcher stays conservative (alias-family match).
+export const observedIdentity = (health, adapter, model) => health?.[adapter]?.modelAuth?.[model]?.identity ?? health?.[adapter]?.modelIdentities?.[model];
+export const observedSeat = (health, adapter, model) => {
+    const identity = observedIdentity(health, adapter, model);
+    return identity ? { adapter, model, identity } : { adapter, model };
+};
 const adapterIds = (adapters) => typeof adapters[0] === "string" ? adapters : adapters.map((a) => a.id);
 export function excludedChannels(cfg, adapters, health) {
     const { allow, deny } = cfg.routing;
@@ -57,9 +64,7 @@ export function excludedChannels(cfg, adapters, health) {
         if (!health[id]?.installed || !health[id]?.authed)
             continue;
         for (const c of channelsFromConfig(id, cfg)) {
-            const identity = health[id]?.modelAuth?.[c.model]?.identity ?? health[id]?.modelIdentities?.[c.model];
-            const chan = identity ? { ...c, identity } : c;
-            const d = disallowedBy(chan, cfg.routing);
+            const d = disallowedBy(observedSeat(health, c.adapter, c.model), cfg.routing);
             if (d)
                 out.push({ key: channelKey(c), d });
         }
@@ -175,13 +180,20 @@ const disallowedFromPreferError = (msg) => {
     const m = msg.match(/prefer entry .+ is disallowed by routing\.(deny|allow) \(([^)]+)\)/);
     return m ? { by: m[1], entry: m[2] } : null;
 };
-export function preferEntryDenied(p, cfg) {
+// OBS-1143: `health` is doctor's CACHED verdict (never a probe); its identities ride the channels
+// route() reads them from, so the preflight answers exactly as the router would.
+export function preferEntryDenied(p, cfg, health) {
     if (!cfg.routing.allow && !cfg.routing.deny)
         return null;
     const probe = structuredClone(cfg);
     probe.routing.map = { ...probe.routing.map, [PREFLIGHT_SHAPE]: { prefer: [p] } };
+    const observed = Object.keys(cfg.tiers).flatMap((id) => channelsFromConfig(id, cfg))
+        .flatMap((c) => {
+        const identity = observedIdentity(health, c.adapter, c.model);
+        return identity ? [{ ...c, identity }] : [];
+    });
     try {
-        route(preflightTask, probe, []);
+        route(preflightTask, probe, observed);
         return null;
     }
     catch (e) {
@@ -194,7 +206,9 @@ export function preferEntryDenied(p, cfg) {
 // route — resume hands it the loaded graph's shape set, so a collision on a shape no resumed task
 // uses can no longer refuse the only crash-recovery path. Omitted ⇒ the whole routing map: doctor
 // audits the config itself, which has no graph to be scoped by.
-export function denyPreferCollisions(cfg, shapes) {
+// OBS-1143: `health` (doctor's cached verdict) supplies each alias's observed identity; omitted or
+// unrecorded ⇒ unknown, which stays conservative.
+export function denyPreferCollisions(cfg, shapes, health) {
     if (!cfg.routing.allow && !cfg.routing.deny)
         return [];
     const inGraph = shapes === undefined ? undefined : new Set(shapes);
@@ -203,7 +217,7 @@ export function denyPreferCollisions(cfg, shapes) {
         if (inGraph && !inGraph.has(shape))
             continue;
         if (entry.pin) {
-            const d = disallowedBy({ adapter: entry.pin.via, model: entry.pin.model }, cfg.routing);
+            const d = disallowedBy(observedSeat(health, entry.pin.via, entry.pin.model), cfg.routing);
             if (d) {
                 out.push({
                     kind: "pin",
@@ -214,20 +228,17 @@ export function denyPreferCollisions(cfg, shapes) {
             }
         }
         const prefer = entry.prefer ?? [];
-        if (prefer.length && prefer.every((p) => preferEntryDenied(p, cfg) !== null)) {
+        if (prefer.length && prefer.every((p) => preferEntryDenied(p, cfg, health) !== null)) {
             out.push({
                 kind: "prefer",
                 shape,
                 detail: prefer.join(" > "),
-                disallowed: preferEntryDenied(prefer[0], cfg),
+                disallowed: preferEntryDenied(prefer[0], cfg, health),
             });
         }
         const pool = entry.pool;
         if (pool) {
-            const denied = pool.channels.map((p) => {
-                const i = p.indexOf(":");
-                return disallowedBy({ adapter: p.slice(0, i), model: p.slice(i + 1) }, cfg.routing);
-            });
+            const denied = pool.channels.map((p) => poolEntryDisallowed(p, cfg, health));
             // only a FULLY dead pool collides — a partial deny still leaves live members to route
             if (denied.every((d) => d !== null)) {
                 out.push({ kind: "pool", shape, detail: pool.channels.join(" > "), disallowed: denied[0] });
@@ -236,6 +247,30 @@ export function denyPreferCollisions(cfg, shapes) {
     }
     return out;
 }
+const poolEntryDisallowed = (p, cfg, health) => {
+    const i = p.indexOf(":");
+    return disallowedBy(observedSeat(health, p.slice(0, i), p.slice(i + 1)), cfg.routing);
+};
+// OBS-1144: every disallowed entry a pool carries, beside the admitted remainder the router routes
+// instead — the router skips the entry; an empty remainder is the exhausted pool it refuses.
+export function deadPoolEntries(cfg, shapes, health) {
+    if (!cfg.routing.allow && !cfg.routing.deny)
+        return [];
+    const inGraph = shapes === undefined ? undefined : new Set(shapes);
+    return Object.entries(cfg.routing.map).flatMap(([shape, entry]) => {
+        if (!entry.pool || (inGraph && !inGraph.has(shape)))
+            return [];
+        const judged = entry.pool.channels.map((p) => ({ p, d: poolEntryDisallowed(p, cfg, health) }));
+        const admitted = judged.filter(({ d }) => d === null).map(({ p }) => p);
+        return judged.flatMap(({ p, d }) => (d ? [{ shape, entry: p, disallowed: d, admitted }] : []));
+    });
+}
+export function deadPoolEntryLine({ shape, entry, disallowed, admitted }) {
+    const verdict = admitted.length
+        ? `skipped — routes the admitted remainder ${admitted.join(" > ")}`
+        : "the pool is exhausted — no admitted entry remains, so the shape is unroutable";
+    return `routing.map.${shape}.pool entry ${entry} is disallowed by routing.${disallowed.by} (${disallowed.entry}) — ${verdict}`;
+}
 export function denyPreferCollisionLine({ kind, shape, detail, disallowed }) {
     const verb = kind === "pin" ? "is disallowed" : "fully disallowed";
     return `deny∩prefer: routing.map.${shape}.${kind} ${detail} ${verb} by routing.${disallowed.by} (${disallowed.entry}) — remove the ${disallowed.by} entry or adjust ${kind}`;