tickmarkr 2.5.3 → 2.5.5

package/dist/route/router.d.ts

@@ -33,3 +33,16 @@ export declare class RoutingError extends Error {
 export declare function marginalCostRank(c: 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 & {
+    climbed: boolean;
+    reason?: string;
+};
+export type ClimbResult = ClimbPick;
+/**
+ * v2.5.4 OBS-986 (ES-1): climb one tier on request when untried channels exist in higher tiers.
+ * With routing.escalateTier on, returns the cheapest untried live channel strictly above current.tier,
+ * ordered as nextChannel orders (tier, then marginal cost, learned score strictly last), flagged climbed: true.
+ * When the knob is off, when current is frontier, or when no higher tier has an untried channel,
+ * 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;

package/dist/route/router.js

@@ -103,6 +103,32 @@ function withoutExcluded(channels, exclude) {
     // OBS-57: in-run demotion after consecutive no-trailer windows — route around poisoned channels for the rest of the run.
     return channels.filter((c) => !exclude.has(channelKey(c)));
 }
+// Pools spread providers before tier, independently within each marginal-cost run. Stable
+// cost sorting preserves declaration order when forming groups; gateways share the served
+// model's provider, so adding a second transport does not buy that provider another turn.
+function rankAnyPool(live, task) {
+    const sorted = [...live].sort((a, b) => marginalCostRank(a) - marginalCostRank(b));
+    const out = [];
+    for (let i = 0; i < sorted.length;) {
+        let j = i + 1;
+        while (j < sorted.length && marginalCostRank(sorted[j]) === marginalCostRank(sorted[i]))
+            j++;
+        const groups = new Map();
+        for (const c of sorted.slice(i, j)) {
+            const provider = routingModelProvider(c.model, c.vendor);
+            const group = groups.get(provider) ?? [];
+            group.push(c);
+            groups.set(provider, group);
+        }
+        const ordered = [...groups.values()];
+        const k = spreadOffset(task) % ordered.length;
+        for (const group of [...ordered.slice(k), ...ordered.slice(0, k)]) {
+            out.push(...group.sort((a, b) => TIER_RANK[a.tier] - TIER_RANK[b.tier]));
+        }
+        i = j;
+    }
+    return out;
+}
 const maybeSlaLint = (lints, task, profile, slaMinutes, c) => {
     if (slaMinutes === undefined || !profile)
         return;
@@ -206,21 +232,20 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         // live preserves pool declaration order — ordered mode and any-mode stable-sort ties depend on it
         const live = pool.channels
             .map((id) => channels.find((c) => channelKey(c) === id))
-            .filter((c) => c !== undefined);
+            .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 — 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(", ")}; doctor found: ${channels.map(channelKey).join(", ") || "(nothing)"}`);
         }
-        // ponytail: no learned/explore/spread inside pools in v1 — a pool pick is fully static; the
-        // upgrade path is feeding the pool-filtered set through the learned path below.
+        // No learned/explore inside pools: any spreads deterministically; ordered keeps declaration order.
         const chosen = pool.mode === "ordered"
             ? live[0]
-            : [...live].sort((a, b) => marginalCostRank(a) - marginalCostRank(b) || TIER_RANK[a.tier] - TIER_RANK[b.tier])[0];
+            : 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)` };
     }
     const baseTier = floor ?? "cheap";
-    // D-04: a task floor is hard only on floor/auto paths; the map-pin branch above stays supreme.
+    // A task floor is hard on pool and floor/auto paths; the map-pin branch above stays supreme.
     const minTier = taskFloor && TIER_RANK[taskFloor] > TIER_RANK[baseTier] ? taskFloor : baseTier;
     if (prefActive)
         for (const p of prefer ?? [])
@@ -328,15 +353,8 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     maybeSlaLint(lints, task, profile, slaMinutes, eligible[0]);
     return { assignment: toAssignment(eligible[0]), ladder: ladderFor(task, entry), lints, provenance: `${degraded}${bound}, marginal-cost auto (${chosenBy})`, ...(deviation ? { deviation } : {}) };
 }
-export function nextChannel(current, task, cfg, channels, tried, profile, exclude) {
+function candidatePool(current, channels, tried, tierPredicate, exclude) {
     channels = withoutExcluded(channels, exclude);
-    // already cheapest-sufficient: TIER_RANK asc is the PRIMARY key so escalation climbs one band at a time.
-    // Do NOT "unify" this onto route()'s key order (marginal-cost first) — that reverses climb-one-band on mixed fleets (ROUTE-02, D2).
-    // ROUTE-13: learnedScore is the STRICTLY-LAST key — within-band tiebreak only. Precomputed
-    // outside the comparator (Pitfall 1), never arithmetic-combined with the band keys, no
-    // profile-dependent filter. NO exploration bonus here (route():110 has one; a probe on the
-    // failure path would spend a real retry). Absent profile ⇒ every score is 0 ⇒ third key
-    // all-ties ⇒ the stable sort preserves the exact v1.7 candidate ORDER.
     const triedKeys = new Set(tried);
     const triedIdentities = new Set(tried.map((key) => {
         const channel = channels.find((c) => channelKey(c) === key);
@@ -348,11 +366,71 @@ export function nextChannel(current, task, cfg, channels, tried, profile, exclud
         && channels.filter((c) => c.adapter === current.adapter).every((c) => triedKeys.has(channelKey(c)));
     const currentChannel = channels.find((c) => c.adapter === current.adapter && c.model === current.model);
     const excludedProvider = currentAdapterExcluded ? routingModelProvider(current.model, currentChannel?.vendor) : undefined;
-    const pool = channels.filter((c) => !triedIdentities.has(modelRouteIdentity(c.model, c.vendor))
+    return channels.filter((c) => !triedIdentities.has(modelRouteIdentity(c.model, c.vendor))
         && (!excludedProvider || routingModelProvider(c.model, c.vendor) !== excludedProvider)
-        && TIER_RANK[c.tier] >= TIER_RANK[current.tier]);
+        && tierPredicate(c.tier));
+}
+function rankFailoverCandidates(pool, task, cfg, profile) {
     const scores = new Map(pool.map((c) => [channelKey(c), profile ? learnedScore(profile, task.shape, channelKey(c), c.channel, { availWeight: cfg.routing.learnedTuning?.availWeight }) : 0]));
     const scoreOf = (c) => scores.get(channelKey(c));
-    const candidates = pool.sort((a, b) => TIER_RANK[a.tier] - TIER_RANK[b.tier] || marginalCostRank(a) - marginalCostRank(b) || scoreOf(b) - scoreOf(a));
+    return pool.sort((a, b) => TIER_RANK[a.tier] - TIER_RANK[b.tier] || marginalCostRank(a) - marginalCostRank(b) || scoreOf(b) - scoreOf(a));
+}
+export function nextChannel(current, task, cfg, channels, tried, profile, exclude) {
+    // already cheapest-sufficient: TIER_RANK asc is the PRIMARY key so escalation climbs one band at a time.
+    // Do NOT "unify" this onto route()'s key order (marginal-cost first) — that reverses climb-one-band on mixed fleets (ROUTE-02, D2).
+    // ROUTE-13: learnedScore is the STRICTLY-LAST key — within-band tiebreak only. Precomputed
+    // outside the comparator (Pitfall 1), never arithmetic-combined with the band keys, no
+    // profile-dependent filter. NO exploration bonus here (route():110 has one; a probe on the
+    // failure path would spend a real retry). Absent profile ⇒ every score is 0 ⇒ third key
+    // all-ties ⇒ the stable sort preserves the exact v1.7 candidate ORDER.
+    const pool = candidatePool(current, channels, tried, (tier) => TIER_RANK[tier] >= TIER_RANK[current.tier], exclude);
+    const candidates = rankFailoverCandidates(pool, task, cfg, profile);
     return candidates.length ? toAssignment(candidates[0]) : null;
 }
+function makeClimbPick(assignment, climbed, reason) {
+    const pick = {
+        adapter: assignment.adapter,
+        model: assignment.model,
+        channel: assignment.channel,
+        tier: assignment.tier,
+        climbed,
+        ...(climbed ? {} : { reason }),
+    };
+    Object.defineProperty(pick, "assignment", {
+        get() {
+            return {
+                adapter: this.adapter,
+                model: this.model,
+                channel: this.channel,
+                tier: this.tier,
+            };
+        },
+        enumerable: false,
+    });
+    return pick;
+}
+/**
+ * v2.5.4 OBS-986 (ES-1): climb one tier on request when untried channels exist in higher tiers.
+ * With routing.escalateTier on, returns the cheapest untried live channel strictly above current.tier,
+ * ordered as nextChannel orders (tier, then marginal cost, learned score strictly last), flagged climbed: true.
+ * When the knob is off, when current is frontier, or when no higher tier has an untried channel,
+ * returns nextChannel's same-or-higher pick flagged climbed: false naming the reason.
+ */
+export function climbChannel(current, task, cfg, channels, tried, profile, exclude) {
+    const escalateOn = cfg.routing.escalateTier !== "off";
+    if (!escalateOn) {
+        const pick = nextChannel(current, task, cfg, channels, tried, profile, exclude);
+        return pick ? makeClimbPick(pick, false, "routing.escalateTier knob is off") : null;
+    }
+    if (current.tier === "frontier") {
+        const pick = nextChannel(current, task, cfg, channels, tried, profile, exclude);
+        return pick ? makeClimbPick(pick, false, "no higher tier") : null;
+    }
+    const higherPool = candidatePool(current, channels, tried, (tier) => TIER_RANK[tier] > TIER_RANK[current.tier], exclude);
+    if (higherPool.length > 0) {
+        const candidates = rankFailoverCandidates(higherPool, task, cfg, profile);
+        return makeClimbPick(toAssignment(candidates[0]), true);
+    }
+    const pick = nextChannel(current, task, cfg, channels, tried, profile, exclude);
+    return pick ? makeClimbPick(pick, false, "no higher tier has an untried channel") : null;
+}

package/dist/run/daemon.d.ts

@@ -126,6 +126,19 @@ export declare const WORKER_STARTUP_WINDOW_BYTES: number;
 /** Test seam — exercises both sides of the startup boundary without a production-length fixture. */
 export declare function setWorkerStartupWindowMsForTests(ms: number): void;
 export declare function resetWorkerStartupWindowMsForTests(): void;
+export interface StartupFailureEvidence {
+    matchedBytes: string;
+    offset: number;
+    row: string;
+    rowNumber: number;
+}
+/** 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 closed;
+    constructor(adapter: Pick<WorkerAdapter, "inputBox" | "harnessBannerRows">);
+    sample(output: string, launchedAt: number | undefined): StartupFailureEvidence | undefined;
+}
 /** Test seam — shrink the quota-banner silence gate without minute-long sleeps. */
 export declare function setQuotaBannerSilentMsForTests(ms: number): void;
 export declare function resetQuotaBannerSilentMsForTests(): void;