tickmarkr 2.5.4 → 2.5.6

package/dist/graph/graph.js

@@ -156,9 +156,53 @@ export function addEvidence(g, id, patch) {
             : t),
     };
 }
+// OBS-1018: chain depth = number of downstream edges on the longest dependency path from a task to
+// a leaf below it (a task nothing depends on is 0). Counted over the whole graph, status-blind: a
+// root's critical path does not shrink because part of it already ran.
+export function chainDepth(g) {
+    const dependents = new Map(g.tasks.map((t) => [t.id, []]));
+    for (const t of g.tasks)
+        for (const d of t.deps)
+            dependents.get(d)?.push(t.id);
+    const depth = new Map();
+    const visit = (id) => {
+        const known = depth.get(id);
+        if (known !== undefined)
+            return known;
+        const below = dependents.get(id) ?? [];
+        const value = below.length ? 1 + Math.max(...below.map(visit)) : 0; // acyclic: validateGraph rejects cycles
+        depth.set(id, value);
+        return value;
+    };
+    for (const t of g.tasks)
+        visit(t.id);
+    return depth;
+}
+// OBS-1018: admission is critical-path order — deepest chain root first, ties in declaration order.
+// The daemon's dispatch loop slices this list unchanged. Stated limit: resume-restore of previously
+// in-flight attempts keeps its own precedence (src/run/daemon.ts); only fresh admission is ordered here.
 export function readyTasks(g) {
     const done = new Set(g.tasks.filter((t) => t.status === "done").map((t) => t.id));
-    return g.tasks.filter((t) => t.status === "pending" && t.deps.every((d) => done.has(d)));
+    const depth = chainDepth(g);
+    return g.tasks
+        .filter((t) => t.status === "pending" && t.deps.every((d) => done.has(d)))
+        .sort((a, b) => depth.get(b.id) - depth.get(a.id)); // Array#sort is stable: equal depths keep declaration order
+}
+// OBS-1018: the dispatch wave each pending task would enter at `concurrency` slots if every wave
+// took one tick — computed by draining readyTasks, so plan and daemon can never disagree on order.
+// Tasks already past pending carry no wave.
+export function dispatchWaves(g, concurrency) {
+    const waves = new Map();
+    let sim = g;
+    for (let wave = 1;; wave++) {
+        const batch = readyTasks(sim).slice(0, Math.max(1, concurrency));
+        if (!batch.length)
+            return waves;
+        for (const t of batch) {
+            waves.set(t.id, wave);
+            sim = setStatus(sim, t.id, "done");
+        }
+    }
 }
 export function isComplete(g) {
     return g.tasks.every((t) => t.status === "done");

package/dist/route/preference.d.ts

@@ -28,10 +28,31 @@ export declare function preferRanks(c: {
     shape: string;
     rank: number;
 }[];
+export declare function isExplicitIdOfAliasFamily(candidateModel: string, alias: string): boolean;
+export declare function entryMatchesChannel(entry: string, c: {
+    adapter: string;
+    model: string;
+    identity?: string;
+}, allowFamilyMatching?: boolean): boolean;
+export interface ExclusionScope {
+    scope: string;
+    path: string;
+    configPath: string;
+    entry: string;
+    by: "deny" | "allow";
+}
+export declare function exclusionCollector(c: {
+    adapter: string;
+    model: string;
+    identity?: string;
+}, routingOrCfg: TickmarkrConfig["routing"] | TickmarkrConfig, role?: PreferenceRole): ExclusionScope[];
+export declare const collectExclusions: typeof exclusionCollector;
+export declare const exclusionProvenance: typeof exclusionCollector;
 export declare function disallowedBy(c: {
     adapter: string;
     model: string;
-}, routing: TickmarkrConfig["routing"], role?: PreferenceRole): Disallowed | null;
+    identity?: string;
+}, routingOrCfg: TickmarkrConfig["routing"] | TickmarkrConfig, role?: PreferenceRole): Disallowed | null;
 export interface DenyPreferCollision {
     kind: "prefer" | "pin" | "pool";
     shape: string;

package/dist/route/preference.js

@@ -5,19 +5,24 @@ const PREFERENCE_ROLES = ["worker", "judge", "review", "consult"];
 /** Provider identity comes from the served model, not a gateway adapter's stamped vendor. */
 export function modelProvider(model, fallback = "unknown") {
     const id = model.toLowerCase();
-    const prefix = id.includes("/") ? id.slice(0, id.indexOf("/")) : "";
-    if (prefix === "openai" || prefix === "openai-codex" || /^(?:gpt|o\d)/.test(id))
+    const sepIdx = id.search(/[/:\s]/);
+    const prefix = sepIdx !== -1 ? id.slice(0, sepIdx) : "";
+    const remainder = sepIdx !== -1 ? id.slice(sepIdx + 1) : id;
+    if (prefix === "openai" || prefix === "openai-codex" || /^(?:gpt|o\d)/.test(remainder))
         return "openai";
-    if (prefix === "anthropic" || /^(?:claude|opus|sonnet|haiku|fable)(?:-|$)/.test(id))
+    if (prefix === "anthropic" || /^(?:claude|opus|sonnet|haiku|fable)(?:-|$)/.test(remainder))
         return "anthropic";
-    if (prefix === "google" || /^gemini(?:-|$)/.test(id))
+    if (prefix === "google" || /^gemini(?:-|$)/.test(remainder))
         return "google";
-    if (prefix === "xai" || /^grok(?:-|$)/.test(id))
+    if (prefix === "xai" || prefix === "xai-oauth" || /^(?:grok|xai)(?:-|$)/.test(remainder) || id.startsWith("xai-oauth"))
         return "xai";
-    if (["zai", "zhipu", "zai-coding-plan"].includes(prefix) || /^glm(?:-|$)/.test(id))
+    if (["zai", "zhipu", "zai-coding-plan"].includes(prefix) || /^glm(?:-|$)/.test(remainder))
         return "zhipu";
-    if (["kimi-code", "moonshot"].includes(prefix) || /^kimi(?:-|$)/.test(id))
+    if (["kimi-code", "moonshot"].includes(prefix) || /^kimi(?:-|$)/.test(remainder))
         return "moonshot";
+    const normalizedFallback = fallback.toLowerCase();
+    if (normalizedFallback === "xai-oauth" || normalizedFallback === "xai")
+        return "xai";
     return fallback;
 }
 // Router naming remains explicit while sharing the review gate's exact function object.
@@ -51,7 +56,9 @@ export function excludedChannels(cfg, adapters, health) {
         if (!health[id]?.installed || !health[id]?.authed)
             continue;
         for (const c of channelsFromConfig(id, cfg)) {
-            const d = disallowedBy(c, cfg.routing);
+            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);
             if (d)
                 out.push({ key: channelKey(c), d });
         }
@@ -75,25 +82,116 @@ export function preferRanks(c, cfg) {
     }
     return out;
 }
-// entries in either list accept adapter id, model id, or adapter:model (grammar A1)
-export function disallowedBy(c, routing, role = "worker") {
-    const { allow, deny } = routing;
-    const matches = (e) => e === c.adapter || e === c.model || e === channelKey(c);
-    const workerDeny = role === "worker" ? deny?.workers : undefined;
-    const d = [
-        ...(deny?.adapters ?? []),
-        ...(deny?.models ?? []),
-        ...(workerDeny?.adapters ?? []),
-        ...(workerDeny?.models ?? []),
-    ].find(matches);
-    if (d)
-        return { by: "deny", entry: d };
+export function isExplicitIdOfAliasFamily(candidateModel, alias) {
+    if (candidateModel === alias)
+        return true;
+    const tokens = candidateModel.toLowerCase().split(/[^a-z0-9]+/);
+    return tokens.includes(alias.toLowerCase());
+}
+export function entryMatchesChannel(entry, c, allowFamilyMatching = false) {
+    if (entry === c.adapter)
+        return true;
+    if (entry === c.model)
+        return true;
+    if (entry === channelKey(c))
+        return true;
+    if (c.identity) {
+        if (entry === c.identity)
+            return true;
+        if (entry === `${c.adapter}:${c.identity}`)
+            return true;
+    }
+    if (!c.identity && allowFamilyMatching) {
+        const colon = entry.indexOf(":");
+        if (colon !== -1) {
+            const entryAdapter = entry.slice(0, colon);
+            const entryModel = entry.slice(colon + 1);
+            if (entryAdapter === c.adapter && isExplicitIdOfAliasFamily(entryModel, c.model)) {
+                return true;
+            }
+        }
+        else {
+            if (isExplicitIdOfAliasFamily(entry, c.model)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function exclusionCollector(c, routingOrCfg, role = "worker") {
+    const routing = "routing" in routingOrCfg ? routingOrCfg.routing : routingOrCfg;
+    const out = [];
+    const { allow, deny } = routing ?? {};
+    for (const entry of deny?.adapters ?? []) {
+        if (entryMatchesChannel(entry, c, true)) {
+            out.push({
+                scope: "routing.deny.adapters",
+                path: "routing.deny.adapters",
+                configPath: "routing.deny.adapters",
+                entry,
+                by: "deny",
+            });
+        }
+    }
+    for (const entry of deny?.models ?? []) {
+        if (entryMatchesChannel(entry, c, true)) {
+            out.push({
+                scope: "routing.deny.models",
+                path: "routing.deny.models",
+                configPath: "routing.deny.models",
+                entry,
+                by: "deny",
+            });
+        }
+    }
+    if (role === "worker") {
+        for (const entry of deny?.workers?.adapters ?? []) {
+            if (entryMatchesChannel(entry, c, true)) {
+                out.push({
+                    scope: "routing.deny.workers.adapters",
+                    path: "routing.deny.workers.adapters",
+                    configPath: "routing.deny.workers.adapters",
+                    entry,
+                    by: "deny",
+                });
+            }
+        }
+        for (const entry of deny?.workers?.models ?? []) {
+            if (entryMatchesChannel(entry, c, true)) {
+                out.push({
+                    scope: "routing.deny.workers.models",
+                    path: "routing.deny.workers.models",
+                    configPath: "routing.deny.workers.models",
+                    entry,
+                    by: "deny",
+                });
+            }
+        }
+    }
     if (allow) {
-        const entries = [...(allow.adapters ?? []), ...(allow.models ?? [])];
-        if (!entries.some(matches))
-            return { by: "allow", entry: entries.join(", ") || "(empty allowlist)" };
+        const allAllow = [...(allow.adapters ?? []), ...(allow.models ?? [])];
+        const admitted = allAllow.some((e) => entryMatchesChannel(e, c, false));
+        if (!admitted) {
+            out.push({
+                scope: "routing.allow",
+                path: "routing.allow",
+                configPath: "routing.allow",
+                entry: allAllow.join(", ") || "(empty allowlist)",
+                by: "allow",
+            });
+        }
     }
-    return null;
+    return out;
+}
+export const collectExclusions = exclusionCollector;
+export const exclusionProvenance = exclusionCollector;
+// entries in either list accept adapter id, model id, or adapter:model (grammar A1)
+export function disallowedBy(c, routingOrCfg, role = "worker") {
+    const exclusions = exclusionCollector(c, routingOrCfg, role);
+    if (exclusions.length === 0)
+        return null;
+    const first = exclusions[0];
+    return { by: first.by, entry: first.entry };
 }
 // Delegates to route()'s preflightPrefer — doctor/resume preflight reuses the router grammar,
 // not a second colon/tier/model parser of the same config.

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 ?? [])

package/dist/run/consult.js

@@ -164,10 +164,11 @@ opts = {}) {
             out = r.stdout + r.stderr;
         }
         else {
-            // Preserve the adapter contract for CLIs that cannot seed their TUI: supported adapters use
-            // the interactive form, while a declared null keeps the existing visible print fallback.
-            const command = adapter.interactiveCommand(promptFile, seatModel)
-                ?? adapter.headlessCommand(promptFile, seatModel);
+            // OBS-1009: the pane runs the HEADLESS command. A seeded interactive session answers on screen
+            // 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);
             // 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}`,

package/dist/run/daemon.d.ts

@@ -6,6 +6,8 @@ import { type Baseline } from "../gates/baseline.js";
 import type { GateResult } from "../gates/types.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 setAttemptHardTimeoutMsForTests(ms: number): void;
+export declare function resetAttemptHardTimeoutMsForTests(): void;
 export { harvestCpuFlatWindowMs, resetHarvestCpuFlatMsForTests, setHarvestCpuFlatMsForTests, workerTreeCpuMs, } from "./stall.js";
 export interface RunOptions {
     runId?: string;
@@ -126,6 +128,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;