tickmarkr 2.6.0 → 2.6.2

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}`;

package/dist/route/role-pick.d.ts

@@ -0,0 +1,16 @@
+import { type AuthHealth, type BillingChannel, type WorkerAdapter } from "../adapters/types.js";
+import { type TickmarkrConfig } from "../config/config.js";
+import type { PreferenceRole } from "./preference.js";
+export { preferIndex, rankPreferredChannels, reviewPreferenceTieBreak } from "./router.js";
+export type RolePick = {
+    ok: true;
+    channel: BillingChannel;
+} | {
+    ok: false;
+    reason: "missing-prefer" | "no-eligible-preferred-channel";
+};
+/** Strict role selection: no task, author, pin, or default seat is invented. */
+export declare function pickRole(role: PreferenceRole, cfg: TickmarkrConfig, adapters: WorkerAdapter[], health: Record<string, AuthHealth>, opts?: {
+    excludeVendors?: ReadonlySet<string>;
+    eligible?: (channel: BillingChannel) => boolean;
+}): RolePick;

package/dist/route/role-pick.js

@@ -0,0 +1,15 @@
+import { discoverChannels } from "../adapters/registry.js";
+import { rankPreferredChannels, reviewPreferenceTieBreak } from "./router.js";
+export { preferIndex, rankPreferredChannels, reviewPreferenceTieBreak } from "./router.js";
+/** Strict role selection: no task, author, pin, or default seat is invented. */
+export function pickRole(role, cfg, adapters, health, opts = {}) {
+    // Worker preferences belong to shapes; judge currently has only an explicit pin.
+    const prefer = role === "review" ? cfg.review.prefer : role === "consult" ? cfg.consult.prefer : undefined;
+    if (!prefer?.length)
+        return { ok: false, reason: "missing-prefer" };
+    const pool = discoverChannels(cfg, adapters, health, role).filter((c) => !opts.excludeVendors?.has(c.vendor) && (opts.eligible?.(c) ?? true));
+    const channel = rankPreferredChannels(pool, prefer, {
+        tieBreak: role === "review" ? reviewPreferenceTieBreak : undefined,
+    })[0];
+    return channel ? { ok: true, channel } : { ok: false, reason: "no-eligible-preferred-channel" };
+}

package/dist/route/router.d.ts

@@ -31,6 +31,19 @@ export declare class RoutingError extends Error {
     constructor(msg: string);
 }
 export declare function marginalCostRank(c: BillingChannel): number;
+type ChannelSeat = {
+    adapter: string;
+    model: string;
+};
+/** Shared adapter | adapter:model grammar; unmatched channels follow every declared entry. */
+export declare function preferIndex(c: ChannelSeat, prefer?: readonly string[]): number;
+/** Rank an already eligible pool. Review alone retains its legacy unpreferred tail. */
+export declare function rankPreferredChannels<C extends ChannelSeat>(channels: readonly C[], prefer?: readonly string[], opts?: {
+    includeUnpreferred?: boolean;
+    tieBreak?: (a: C, b: C) => number;
+}): C[];
+/** Review preserves its established tier-then-cost order inside a preference band. */
+export declare const reviewPreferenceTieBreak: (a: BillingChannel, b: BillingChannel) => number;
 export declare function route(task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], profile?: RoutingProfile, preferCtx?: RoutingPreferContext, exclude?: ReadonlySet<string>, exploreCtx?: ExploreContext): Route;
 export declare function nextChannel(current: Assignment, task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile, exclude?: ReadonlySet<string>): Assignment | null;
 export type ClimbPick = Assignment & {
@@ -46,3 +59,4 @@ export type ClimbResult = ClimbPick;
  * returns nextChannel's same-or-higher pick flagged climbed: false naming the reason.
  */
 export declare function climbChannel(current: Assignment, task: Task, cfg: TickmarkrConfig, channels: BillingChannel[], tried: string[], profile?: RoutingProfile, exclude?: ReadonlySet<string>): ClimbPick | null;
+export {};

package/dist/route/router.js

@@ -44,6 +44,7 @@ export function marginalCostRank(c) {
 }
 const toAssignment = (c) => ({
     adapter: c.adapter, model: c.model, channel: c.channel, tier: c.tier,
+    ...(c.effort ? { effort: c.effort } : {}),
 });
 function resolvePin(pin, channels) {
     const c = channels.find((c) => c.adapter === pin.via && c.model === pin.model);
@@ -52,10 +53,18 @@ function resolvePin(pin, channels) {
     }
     return c;
 }
-function preferIndex(c, prefer = []) {
+/** Shared adapter | adapter:model grammar; unmatched channels follow every declared entry. */
+export function preferIndex(c, prefer = []) {
     const i = prefer.findIndex((p) => p === c.adapter || p === channelKey(c));
     return i === -1 ? prefer.length : i;
 }
+/** Rank an already eligible pool. Review alone retains its legacy unpreferred tail. */
+export function rankPreferredChannels(channels, prefer = [], opts = {}) {
+    return channels.filter((c) => opts.includeUnpreferred || preferIndex(c, prefer) < prefer.length)
+        .sort((a, b) => preferIndex(a, prefer) - preferIndex(b, prefer) || opts.tieBreak?.(a, b) || 0);
+}
+/** Review preserves its established tier-then-cost order inside a preference band. */
+export const reviewPreferenceTieBreak = (a, b) => TIER_RANK[b.tier] - TIER_RANK[a.tier] || Number(a.channel === "api") - Number(b.channel === "api");
 function ladderFor(task, entry) {
     const escalate = task.routingHints?.escalate ?? entry?.escalate ?? true;
     return escalate ? ["retry", "escalate", "consult", "human"] : ["retry", "consult", "human"];
@@ -142,6 +151,13 @@ const maybeSlaLint = (lints, task, profile, slaMinutes, c) => {
     lints.push(`${task.id} (${task.shape}): median ${medianMin}m exceeds sla ${slaMinutes}m — learned perf term references sla ${slaMinutes}m ref`);
 };
 export function route(task, cfg, channels, profile, preferCtx, exclude, exploreCtx) {
+    // OBS-1143: deny checks below read the probed identity the offered channels carry — the identity
+    // discovery admitted them under. A seat no channel vouches for stays unknown (conservative).
+    const observed = new Map(channels.flatMap((c) => (c.identity ? [[channelKey(c), c.identity]] : [])));
+    const seat = (adapter, model) => {
+        const identity = observed.get(channelKey({ adapter, model }));
+        return identity ? { adapter, model, identity } : { adapter, model };
+    };
     channels = withoutExcluded(channels, exclude);
     const lints = [];
     const advisoryFloor = cfg.routing.floors[task.shape];
@@ -153,7 +169,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     const prefer = effectivePrefer(entry);
     const prefActive = !!(cfg.routing.allow || cfg.routing.deny);
     const disallowedPin = (via, model, kind) => {
-        const d = disallowedBy({ adapter: via, model }, cfg.routing);
+        const d = disallowedBy(seat(via, model), cfg.routing);
         if (d) {
             throw new RoutingError(`${task.id}: ${kind} ${via}:${model} is disallowed by routing.${d.by} (${d.entry}) — remove the ${d.by} entry or re-pin to an allowed channel`);
         }
@@ -166,8 +182,8 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         }
         if (cfg.tiers[p]) {
             const expanded = channelsFromConfig(p, cfg);
-            if (expanded.length && expanded.every((c) => disallowedBy(c, cfg.routing) !== null)) {
-                const d = disallowedBy(expanded[0], cfg.routing);
+            if (expanded.length && expanded.every((c) => disallowedBy(seat(c.adapter, c.model), cfg.routing) !== null)) {
+                const d = disallowedBy(seat(expanded[0].adapter, expanded[0].model), cfg.routing);
                 throw new RoutingError(`${task.id}: prefer entry ${p} is disallowed by routing.${d.by} (${d.entry}) — remove the ${d.by} entry or re-pin to an allowed channel`);
             }
             return;
@@ -220,21 +236,28 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     // single-channel pool) and the open floor/auto path. Exhaustion stays fail-loud (pin precedent).
     if (entry?.pool) {
         const pool = entry.pool;
-        if (prefActive) {
-            for (const p of pool.channels) {
-                const i = p.indexOf(":");
-                const d = disallowedBy({ adapter: p.slice(0, i), model: p.slice(i + 1) }, cfg.routing);
-                if (d) {
-                    throw new RoutingError(`${task.id}: pool entry ${p} is disallowed by routing.${d.by} (${d.entry}) — remove the ${d.by} entry or drop it from the pool`);
-                }
-            }
+        // OBS-1144: a disallowed entry is skipped, named in provenance, never fatal for the pool; only an
+        // empty admitted remainder refuses. Filtering keeps declaration order, so ordered stays ordered.
+        const skipped = [];
+        const admitted = pool.channels.filter((p) => {
+            if (!prefActive)
+                return true;
+            const i = p.indexOf(":");
+            const d = disallowedBy(seat(p.slice(0, i), p.slice(i + 1)), cfg.routing);
+            if (d)
+                skipped.push(`${p} (disallowed by routing.${d.by} (${d.entry}))`);
+            return d === null;
+        });
+        const skippedNote = skipped.length ? `; skipped ${skipped.join(", ")}` : "";
+        if (!admitted.length) {
+            throw new RoutingError(`${task.id}: routing.map.${task.shape}.pool is exhausted — no admitted entry remains: ${skipped.join(", ")} — remove the deny/allow entry or add an admitted channel to the pool`);
         }
         // live preserves pool declaration order — ordered mode and any-mode stable-sort ties depend on it
-        const live = pool.channels
+        const live = admitted
             .map((id) => channels.find((c) => channelKey(c) === id))
             .filter((c) => c !== undefined && (!taskFloor || TIER_RANK[c.tier] >= TIER_RANK[taskFloor]));
         if (!live.length) {
-            throw new RoutingError(`${task.id}: routing.map.${task.shape}.pool has no live channel${taskFloor ? ` at task floor ${taskFloor}` : ""} — declared: ${pool.channels.join(", ")}; doctor found: ${channels.map(channelKey).join(", ") || "(nothing)"}`);
+            throw new RoutingError(`${task.id}: routing.map.${task.shape}.pool has no live channel${taskFloor ? ` at task floor ${taskFloor}` : ""} — declared: ${pool.channels.join(", ")}${skippedNote}; doctor found: ${channels.map(channelKey).join(", ") || "(nothing)"}`);
         }
         // No learned/explore inside pools: any spreads deterministically; ordered keeps declaration order.
         const chosen = pool.mode === "ordered"
@@ -242,7 +265,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
             : rankAnyPool(live, task)[0];
         lintMapPinFloor(chosen.tier, "pool");
         maybeSlaLint(lints, task, profile, slaMinutes, chosen);
-        return { assignment: toAssignment(chosen), ladder: ladderFor(task, entry), lints, provenance: `${degraded}pool ${pool.mode} ${channelKey(chosen)} (config routing.map)` };
+        return { assignment: toAssignment(chosen), ladder: ladderFor(task, entry), lints, provenance: `${degraded}pool ${pool.mode} ${channelKey(chosen)} (config routing.map${skippedNote})` };
     }
     const baseTier = floor ?? "cheap";
     // A task floor is hard on pool and floor/auto paths; the map-pin branch above stays supreme.
@@ -260,7 +283,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         let msg = `${task.id}: no channel at tier>=${minTier}; available: ${channels.map(channelKey).join(", ") || "(none)"}`;
         if (prefActive) {
             const excluded = Object.keys(cfg.tiers).flatMap((id) => channelsFromConfig(id, cfg))
-                .filter((c) => disallowedBy(c, cfg.routing) !== null && TIER_RANK[c.tier] >= TIER_RANK[minTier])
+                .filter((c) => disallowedBy(seat(c.adapter, c.model), cfg.routing) !== null && TIER_RANK[c.tier] >= TIER_RANK[minTier])
                 .map(channelKey);
             if (excluded.length)
                 msg += `; ${excluded.length} channel(s) excluded by routing.allow/deny: ${excluded.join(", ")}`;

package/dist/run/consult.d.ts

@@ -1,5 +1,6 @@
-import type { WorkerAdapter } from "../adapters/types.js";
+import { type WorkerAdapter } from "../adapters/types.js";
 import type { TickmarkrConfig } from "../config/config.js";
+import type { Effort } from "../graph/schema.js";
 import type { ExecutorDriver, Slot } from "../drivers/types.js";
 import type { GateResult } from "../gates/types.js";
 import { type VerdictUnparseableCause } from "../gates/verdict-cause.js";
@@ -13,6 +14,16 @@ export interface ConsultVerdict {
     adapter?: string;
     model?: string;
     vendor?: string;
+    effort?: Effort;
+    invocations?: ConsultInvocation[];
+}
+export interface ConsultInvocation {
+    adapter: string;
+    model: string;
+    vendor: string;
+    effort?: Effort;
+    outcome: "completed" | "failed";
+    reason: string;
 }
 export declare function renderRetryGuidance(v: ConsultVerdict): string;
 export declare function augmentRetryBrief(feedback: string, opts: {
@@ -37,6 +48,7 @@ export declare function buildDossierPrompt(d: Dossier, nonce: string): string;
 export declare function consult(d: Dossier, cfg: TickmarkrConfig, adapters: WorkerAdapter[], driver: ExecutorDriver, cwd: string, runDir: string, opts?: {
     keep?: boolean;
     onSlot?: (slot: Slot) => void;
+    onInvocation?: (inv: ConsultInvocation) => void;
     runId?: string;
     channels?: Array<{
         adapter: string;

package/dist/run/consult.js

@@ -1,9 +1,11 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { getAdapter } from "../adapters/registry.js";
+import { configuredEffort } from "../adapters/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { dewrapPaneVerdict, extractVerdictJson, gateExitTrailer, gatePaneName, generateVerdictNonce, verdictNonceLine } from "../gates/llm.js";
 import { classifyVerdictCause } from "../gates/verdict-cause.js";
+import { rankPreferredChannels } from "../route/role-pick.js";
 import { disallowedBy, routingModelProvider } from "../route/preference.js";
 import { sh } from "./git.js";
 import { redactSecrets } from "./redact.js";
@@ -144,6 +146,8 @@ export async function consult(d, cfg, adapters, driver, cwd, runDir,
 // via SlotOpts.owned; without it the legacy gatePaneName shape survives (non-daemon callers/tests).
 // v1.54 T1: channels — the daemon's doctor-filtered live channel list; prefer-seat liveness is
 // judged against it only (never rebuilt from config, which would select installed-but-unauthed seats).
+// OBS-1182: onInvocation hears every launched seat — its identity, effort and outcome — failed seats
+// included, so a seat that never produced the verdict still reaches the journal.
 opts = {}) {
     const n = ++consultSeq;
     const nonce = generateVerdictNonce();
@@ -156,11 +160,11 @@ opts = {}) {
     // One seat = the WHOLE invoke-and-parse unit, both visibility branches (OBS-69 class: a headless-only
     // failover would leave the production pane path hard-failing on seat one). A null verdict retains
     // the classifier's cause when extraction failed; parsed content rejections deliberately have none.
-    const invokeSeat = async (seatAdapter, seatModel, seatIdx) => {
+    const invokeSeat = async (seatAdapter, seatModel, seatIdx, effort) => {
         const adapter = getAdapter(seatAdapter, adapters);
         let out;
         if (cfg.visibility.llm === "headless") {
-            const r = await sh(adapter.headlessCommand(promptFile, seatModel), cwd, cfg.consult.stallMinutes * 60_000);
+            const r = await sh(adapter.headlessCommand(promptFile, seatModel, effort), cwd, cfg.consult.stallMinutes * 60_000);
             out = r.stdout + r.stderr;
         }
         else {
@@ -168,7 +172,7 @@ opts = {}) {
             // but never exits, so the exit trailer after it never runs, the wait runs to the stall cap and
             // the 300-line read is a TUI frame. The headless command exits, the trailer prints, and the
             // pane is harvested through dewrap exactly like a judge or review seat.
-            const command = adapter.headlessCommand(promptFile, seatModel);
+            const command = adapter.headlessCommand(promptFile, seatModel, effort);
             // T8: role-first pane name for fleet visibility (consult · T2); consultSeq stays on the dossier artifact only
             const slot = await driver.slot(cwd, gatePaneName("consult", d.taskId), {
                 label: `CONSULT ${d.taskId}`,
@@ -212,15 +216,10 @@ opts = {}) {
         }
         return parsed;
     };
-    // v1.54 T1: ranked seat failover. Walk consult.prefer (adapter:model entries) to the first entry
-    // whose adapter is in the live channel set; a failed seat or unparseable verdict falls to the next;
-    // the pinned consult.adapter/model is always the final seat. No channels provided (non-daemon
-    // callers) ⇒ empty live set ⇒ pin only, byte-identical to pre-v1.54 behavior. Failover changes
-    // only WHICH seat answers — per-seat parsing and the fail-safe human action below are untouched.
-    const live = new Set((opts.channels ?? []).map((c) => c.adapter));
-    const seats = (cfg.consult.prefer ?? [])
-        .map((entry) => ({ adapter: entry.slice(0, entry.indexOf(":")), model: entry.slice(entry.indexOf(":") + 1) }))
-        .filter((s) => live.has(s.adapter));
+    // Rank only exact live models from the daemon's role-scoped discovery pool.
+    // The explicit pin remains a caller-owned fallback, outside strict preference selection.
+    const live = (opts.channels ?? []).filter((c) => typeof c.model === "string");
+    const seats = rankPreferredChannels(live.filter((c) => disallowedBy(c, cfg.routing, "consult") === null), cfg.consult.prefer);
     seats.push({ adapter: cfg.consult.adapter, model: cfg.consult.model });
     // v1.87 T2: a consult seat reads the code, so it passes through the operator's policy exactly like
     // a worker does. The filter runs AFTER the pin is pushed, so the final pinned seat is checked by
@@ -246,8 +245,12 @@ opts = {}) {
         };
     }
     for (const [i, seat] of allowedSeats.entries()) {
+        // OBS-1182: each seat launches at its own configured effort, never the worker's.
+        const effort = configuredEffort(cfg, seat);
+        const record = (outcome, reason) => opts.onInvocation?.({ ...seatIdentity(seat), ...(effort ? { effort } : {}), outcome, reason });
         try {
-            const parsed = await invokeSeat(seat.adapter, seat.model, i);
+            const parsed = await invokeSeat(seat.adapter, seat.model, i, effort);
+            record(parsed.verdict ? "completed" : "failed", parsed.verdict ? "verdict" : `verdict unparseable${parsed.cause ? ` (${parsed.cause})` : ""}`);
             if (parsed.verdict) {
                 const excludeProvider = parsed.verdict.excludeAdapter
                     ? excludedProviderFromDossier(d, parsed.verdict.excludeAdapter)
@@ -259,11 +262,13 @@ opts = {}) {
                         notes: `${parsed.verdict.notes} — excluded provider ${excludeProvider}`,
                     } : {}),
                     ...seatIdentity(seat),
+                    ...(effort ? { effort } : {}),
                 };
             }
         }
-        catch {
+        catch (e) {
             // failed seat (unknown adapter, dead driver/pane, shell error) — fall to the next entry
+            record("failed", `seat error: ${e instanceof Error ? e.message : String(e)}`.slice(0, 200));
         }
     }
     return {

package/dist/run/daemon.d.ts

@@ -2,11 +2,14 @@ import { type WorkerAdapter } from "../adapters/types.js";
 import { type ModeResolution, type RoutingMode, type TickmarkrConfig } from "../config/config.js";
 import { type DriverChoice } from "../drivers/index.js";
 import { type ExecutorDriver, type Slot } from "../drivers/types.js";
-import { type Baseline } from "../gates/baseline.js";
+import { type Baseline, type BaselineProvenance } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.js";
 import { type RunGraph } from "../graph/schema.js";
+import { type PreserveProducer } from "./git.js";
 import { Journal, type JournalEvent } from "./journal.js";
 export declare function closeLiveSlot(liveSlots: Set<Slot>, driver: Pick<ExecutorDriver, "close">, slot: Slot): Promise<void>;
+export declare function setContactUnreadableDeadlineMsForTests(ms: number): void;
+export declare function resetContactUnreadableDeadlineMsForTests(): void;
 /** Optional authoritative transport receipt. Screen text can prove execution, never nonacceptance. */
 export interface DispatchObservation {
     slotId: string;
@@ -66,7 +69,35 @@ export interface RunSummary {
     approvalDisposition?: "complete" | "outstanding";
     /** the accepted approvals that never reached a dispatch — named, never left to the park buckets */
     outstandingApprovals?: string[];
+    /** OBS-1123: every baseline-recorded red a standing green carried, with the capture that recorded it */
+    forgiven?: ForgivenFingerprints[];
 }
+/** OBS-1123: one forgiveness — the fingerprints a green carried and the capture that recorded them. */
+export interface ForgivenFingerprints {
+    /** the task whose gate forgave them; absent for the integration tip */
+    taskId?: string;
+    gate: string;
+    /** absent: a legacy row that named no fingerprints */
+    fingerprints?: string[];
+    /** absent: a legacy capture or row that recorded no provenance — rendered unknown, never dated */
+    baseline?: BaselineProvenance;
+}
+/** Journal rows are untrusted input: a malformed field reads as not recorded, never as a value. */
+export declare const fingerprintsOf: (v: unknown) => string[] | undefined;
+export declare const baselineProvenanceOf: (v: unknown) => BaselineProvenance | undefined;
+/** A forgiven battery green: the structured field, or the battery's own "(forgiven)" wording on a legacy row. */
+export declare const forgivenGateRow: (data: Record<string, unknown>) => boolean;
+/**
+ * OBS-1123: the forgiveness standing at this point in the journal — each task gate's LATEST verdict
+ * where it is a forgiven green, then the latest verification cycle's forgiven tip rows. A legacy row
+ * keeps what it never recorded absent, so the reader says "unknown" instead of borrowing a date.
+ */
+export declare function forgivenFingerprints(events: readonly JournalEvent[]): ForgivenFingerprints[];
+/** The capture a forgiveness rests on, or an explicit unknown — never a time read off another clock. */
+export declare function formatBaselineProvenance(p: BaselineProvenance | undefined): string;
+export declare function formatFingerprints(fingerprints: string[] | undefined): string;
+export declare function formatForgiven(f: ForgivenFingerprints): string;
+export declare function pendingDaemonApprovalActions(events: JournalEvent[]): Map<string, import("./journal.js").PendingApprovalAction>;
 /**
  * T14, amended by v2.2 T3: approvals the run accepted and never acted on. `approved` above is still
  * built ONCE at startup — replay determinism depends on it — but a live approval is no longer inert:
@@ -126,6 +157,12 @@ export declare const APPROVAL_POLL_MS = 250;
 export declare const APPROVAL_WINDOW_MS = 120000;
 export declare const setApprovalWindowForTests: (ms: number) => void;
 export declare const resetApprovalWindowForTests: () => void;
+/** Test seam — shrink the capacity backoff without minute-long sleeps. */
+export declare function setCapacityBackoffMsForTests(ms: number): void;
+export declare function resetCapacityBackoffMsForTests(): void;
+/** Test seam — shrink the bootstrap backoff. */
+export declare function setBootstrapBackoffMsForTests(ms: number): void;
+export declare function resetBootstrapBackoffMsForTests(): void;
 export declare const EARLY_LAUNCH_LIVENESS_MS = 60000;
 /** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
 export declare function setEarlyLaunchLivenessMsForTests(ms: number): void;
@@ -149,8 +186,11 @@ export interface StartupFailureEvidence {
 /** One seat, one startup prefix. Once execution or its input box is seen, later panes are ineligible. */
 export declare class StartupFailureDetector {
     private readonly adapter;
+    private readonly pattern;
+    private readonly wholePrefix;
     private closed;
-    constructor(adapter: Pick<WorkerAdapter, "inputBox" | "harnessBannerRows">);
+    constructor(adapter: Pick<WorkerAdapter, "inputBox" | "harnessBannerRows">, pattern?: RegExp, // OBS-1169: or known bootstrap text
+    wholePrefix?: boolean);
     sample(output: string, launchedAt: number | undefined): StartupFailureEvidence | undefined;
 }
 /** Test seam — shrink the quota-banner silence gate without minute-long sleeps. */
@@ -218,5 +258,9 @@ export declare function liveSuiteCount(repoRoot: string): Promise<number>;
 /** Test seam — exercise the production observer's total read bound with a small real tree. */
 export declare function setObserveBudgetBytesForTests(bytes: number): void;
 export declare function resetObserveBudgetBytesForTests(): void;
+/** The attempt whose worker last launched into the task's current checkout; "unknown" once a
+ * recreation replaced that tree without a new launch (recheck, gate-only restore) or when no
+ * dispatch assignment is on record. Never the newest dispatch by itself. */
+export declare function knownProducer(events: readonly JournalEvent[], taskId: string): PreserveProducer;
 export declare function recordFatalRunEnd(journal: Journal, runId: string, branch: string, err: unknown, graph?: RunGraph, phase?: string): TipProof | undefined;
 export declare function runDaemon(repoRoot: string, opts?: RunOptions): Promise<RunSummary>;