tickmarkr 2.6.0 → 2.6.1

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

@@ -52,10 +52,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"];

package/dist/run/consult.js

@@ -4,6 +4,7 @@ import { getAdapter } from "../adapters/registry.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";
@@ -212,15 +213,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

package/dist/run/daemon.d.ts

@@ -5,6 +5,7 @@ import { type ExecutorDriver, type Slot } from "../drivers/types.js";
 import { type Baseline } 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>;
 /** Optional authoritative transport receipt. Screen text can prove execution, never nonacceptance. */
@@ -67,6 +68,7 @@ export interface RunSummary {
     /** the accepted approvals that never reached a dispatch — named, never left to the park buckets */
     outstandingApprovals?: 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 +128,9 @@ 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;
 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;
@@ -218,5 +223,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>;