tickmarkr 1.70.0 → 1.72.0

package/dist/route/preference.js

@@ -1,4 +1,6 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
+import { validateGraph } from "../graph/schema.js";
+import { route, RoutingError } from "./router.js";
 const adapterIds = (adapters) => typeof adapters[0] === "string" ? adapters : adapters.map((a) => a.id);
 export function excludedChannels(cfg, adapters, health) {
     const { allow, deny } = cfg.routing;
@@ -47,3 +49,62 @@ export function disallowedBy(c, routing) {
     }
     return null;
 }
+// Delegates to route()'s preflightPrefer — doctor/resume preflight reuses the router grammar,
+// not a second colon/tier/model parser of the same config.
+const PREFLIGHT_SHAPE = "chore";
+const preflightTask = validateGraph({
+    version: 1, spec: { source: "prd", paths: ["p"], hash: "h" },
+    tasks: [{ id: "T0", title: "preflight", goal: "preflight", shape: PREFLIGHT_SHAPE, complexity: 1, acceptance: ["preflight"] }],
+}).tasks[0];
+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) {
+    if (!cfg.routing.allow && !cfg.routing.deny)
+        return null;
+    const probe = structuredClone(cfg);
+    probe.routing.map = { ...probe.routing.map, [PREFLIGHT_SHAPE]: { prefer: [p] } };
+    try {
+        route(preflightTask, probe, []);
+        return null;
+    }
+    catch (e) {
+        if (e instanceof RoutingError)
+            return disallowedFromPreferError(e.message);
+        throw e;
+    }
+}
+export function denyPreferCollisions(cfg) {
+    if (!cfg.routing.allow && !cfg.routing.deny)
+        return [];
+    const out = [];
+    for (const [shape, entry] of Object.entries(cfg.routing.map)) {
+        if (entry.pin) {
+            const d = disallowedBy({ adapter: entry.pin.via, model: entry.pin.model }, cfg.routing);
+            if (d) {
+                out.push({
+                    kind: "pin",
+                    shape,
+                    detail: `${entry.pin.via}:${entry.pin.model}`,
+                    disallowed: d,
+                });
+            }
+        }
+        const prefer = entry.prefer ?? [];
+        if (prefer.length && prefer.every((p) => preferEntryDenied(p, cfg) !== null)) {
+            out.push({
+                kind: "prefer",
+                shape,
+                detail: prefer.join(" > "),
+                disallowed: preferEntryDenied(prefer[0], cfg),
+            });
+        }
+    }
+    return out;
+}
+export function denyPreferCollisionLine({ kind, shape, detail, disallowed }) {
+    const surface = kind === "pin" ? `routing.map.${shape}.pin` : `routing.map.${shape}.prefer`;
+    const verb = kind === "pin" ? "is disallowed" : "fully disallowed";
+    return `deny∩prefer: ${surface} ${detail} ${verb} by routing.${disallowed.by} (${disallowed.entry}) — remove the ${disallowed.by} entry or adjust ${kind === "pin" ? "pin" : "prefer"}`;
+}

package/dist/run/daemon.d.ts

@@ -41,4 +41,8 @@ export interface RunSummary {
     lastMergedTask?: string;
 }
 export declare function formatSummary(s: RunSummary): string;
+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;
+export declare function resetEarlyLaunchLivenessMsForTests(): void;
 export declare function runDaemon(repoRoot: string, opts?: RunOptions): Promise<RunSummary>;

package/dist/run/daemon.js

@@ -74,6 +74,18 @@ const BLOCKED_POLL_MS = 30_000; // between trailer-wait slices, check whether th
 const PROVIDER_DEATH_REQUEUE_CAP = 2; // v1.46 T1: requeue same assignment twice, then fall through to the normal ladder
 const PROVIDER_DEATH_BACKOFF_MS = 500; // short backoff before provider-death requeue
 const NO_TRAILER_DEMOTION_STREAK = 2; // OBS-57: consecutive no-trailer windows demote a channel for the rest of the run
+// OBS-117 (v1.71 T6): a worker pane that never prints a byte by T+60s after dispatch is a dead
+// channel — don't burn the full stall window waiting for a silent launch failure. Checked on the
+// existing stall-wait poll cadence only (no new timer). Spinner/ANSI repaints count as output.
+export const EARLY_LAUNCH_LIVENESS_MS = 60_000;
+let earlyLaunchLivenessMs = EARLY_LAUNCH_LIVENESS_MS;
+/** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
+export function setEarlyLaunchLivenessMsForTests(ms) {
+    earlyLaunchLivenessMs = ms;
+}
+export function resetEarlyLaunchLivenessMsForTests() {
+    earlyLaunchLivenessMs = EARLY_LAUNCH_LIVENESS_MS;
+}
 async function commitsAheadOf(base, wt) {
     const head = await gitHead(wt);
     if (head === base)
@@ -217,6 +229,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         // GATE-08 lesson at the humanGate guard: condition on the data, not the code path). Dead-code
         // equivalence to the router.ts:194 profile⇒undefined pattern: no map entry ⇒ today's literal.
         const resume = opts.resume ? journal.replayResumeState() : new Map();
+        const replayedExclusions = opts.resume ? journal.replayExcludedChannels() : new Set();
         if (opts.resume) {
             // v1.53 T5: a superseded run is dead — resuming it beside its successor is the exact
             // two-concurrent-runs hazard supersession exists to prevent. Fail closed, naming the successor.
@@ -252,7 +265,10 @@ export async function runDaemon(repoRoot, opts = {}) {
                     continue;
                 graph = setStatus(graph, id, st);
             }
-            journal.append("run-resume", undefined, { pid: process.pid }); // v1.13 (VIS-11): record the live daemon pid for status liveness
+            journal.append("run-resume", undefined, {
+                pid: process.pid, // v1.13 (VIS-11): record the live daemon pid for status liveness
+                ...(replayedExclusions.size > 0 ? { excludedChannels: [...replayedExclusions].sort() } : {}),
+            });
         }
         else {
             baseRef = await gitHead(repoRoot);
@@ -301,7 +317,8 @@ export async function runDaemon(repoRoot, opts = {}) {
         const keptSlots = [];
         const runTag = runId.replace(/^run-/, ""); // full date-time — cross-run unique even across days
         // OBS-57: per-run in-run demotion — channels that burn consecutive no-trailer windows route around for later attempts.
-        const demotedChannels = new Set();
+        // v1.71 OBS-119: on resume, re-seed from the journal fold (replayedExclusions) before any dispatch.
+        const demotedChannels = new Set(replayedExclusions);
         const noTrailerStreak = new Map();
         // OBS-17 T2: reconcile at every safe point — run start/resume (just journaled above), each task
         // terminal event, and run-end. The desired set is the pure journal fold (reconcile.ts); the driver
@@ -394,7 +411,9 @@ export async function runDaemon(repoRoot, opts = {}) {
             // fresh-budget release, prefer nextChannel over the surviving tried-list so burned channels are
             // not re-tried first (consult bans / prior failovers survive the release).
             const rs = resume.get(t.id);
-            if (rs?.lastAssignment && rs.attempts > 0 && channels.some((c) => channelKey(c) === channelKey(rs.lastAssignment))) {
+            if (rs?.lastAssignment && rs.attempts > 0
+                && channels.some((c) => channelKey(c) === channelKey(rs.lastAssignment))
+                && !demotedChannels.has(channelKey(rs.lastAssignment))) {
                 assignment = rs.lastAssignment; // restore the consult-chosen assignment (bypasses route()'s static re-pick)
             }
             else if (rs && rs.tried.length) {
@@ -690,6 +709,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let output;
                 let exitCode;
                 let timedOut = false;
+                let earlyLaunchDead = false;
                 let settleParsed;
                 let seedResult;
                 if (interactive) {
@@ -724,12 +744,18 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // OBS-82: the stall clock compares NORMALIZED snapshots so a spinner glyph/elapsed-time
                         // repaint is silence, not activity. ONLY this inactivity compare sees normalized text —
                         // trailer detection, harvest, paging, and quota checks all read the raw pane.
+                        let everHadOutput = output.length > 0;
                         let lastStallSnapshot = normalizeStallSnapshot(output);
                         let lastOutputAt = Date.now();
                         while (Date.now() - lastOutputAt < stallWindowMs) {
                             const sliceStart = Date.now();
                             const remaining = stallWindowMs - (sliceStart - lastOutputAt);
-                            const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                            let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                            if (!everHadOutput) {
+                                const earlyLeft = earlyLaunchLivenessMs - (sliceStart - attemptStart);
+                                if (earlyLeft > 0)
+                                    slice = Math.min(slice, earlyLeft);
+                            }
                             if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
                                 // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing tickmarkr's
                                 // own source, where "TICKMARKR_EXIT:" is a string literal) must not end the wait. Only a
@@ -743,11 +769,20 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     break;
                                 }
                             }
-                            const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 1000));
+                            const paneText = await driver.read(slot, 1000);
+                            if (paneText.length > 0)
+                                everHadOutput = true;
+                            const currentStallSnapshot = normalizeStallSnapshot(paneText);
                             if (currentStallSnapshot !== lastStallSnapshot) {
                                 lastStallSnapshot = currentStallSnapshot;
                                 lastOutputAt = Date.now();
                             }
+                            // OBS-117 (v1.71 T6): zero raw output by the early-launch deadline is a dead channel now.
+                            if (!everHadOutput && Date.now() - attemptStart >= earlyLaunchLivenessMs) {
+                                earlyLaunchDead = true;
+                                output = paneText;
+                                break;
+                            }
                             // v1.23 T2: piggyback on this poll slice — same cadence as blocked/idle checks, no new timer.
                             await sampleContext();
                             // page on "idle" too: herdr's blocked-scrape is strict and proved flaky for TUI dialogs
@@ -828,21 +863,35 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // OBS-82: same normalized-snapshot compare as the interactive site — spinner-only repaints
                     // exhaust the budget here too; harvest below still reads the raw pane.
                     const stallWindowMs = taskTimeoutMinutes * 60_000;
-                    let lastStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 500));
+                    const initialPane = await driver.read(slot, 500);
+                    let everHadOutput = initialPane.length > 0;
+                    let lastStallSnapshot = normalizeStallSnapshot(initialPane);
                     let lastOutputAt = Date.now();
                     finished = false;
                     while (Date.now() - lastOutputAt < stallWindowMs) {
                         const remaining = stallWindowMs - (Date.now() - lastOutputAt);
-                        const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                        let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                        if (!everHadOutput) {
+                            const earlyLeft = earlyLaunchLivenessMs - (Date.now() - attemptStart);
+                            if (earlyLeft > 0)
+                                slice = Math.min(slice, earlyLeft);
+                        }
                         if (await driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
                             finished = true;
                             break;
                         }
-                        const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 500));
+                        const paneText = await driver.read(slot, 500);
+                        if (paneText.length > 0)
+                            everHadOutput = true;
+                        const currentStallSnapshot = normalizeStallSnapshot(paneText);
                         if (currentStallSnapshot !== lastStallSnapshot) {
                             lastStallSnapshot = currentStallSnapshot;
                             lastOutputAt = Date.now();
                         }
+                        if (!everHadOutput && Date.now() - attemptStart >= earlyLaunchLivenessMs) {
+                            earlyLaunchDead = true;
+                            break;
+                        }
                     }
                     output = await driver.read(slot, 500);
                     exitCode = Number(exitRe.exec(output)?.[1] ?? 1);
@@ -940,10 +989,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // AFTER the quota check so quota behavior stays byte-identical (a quota hit returns/continues
                 // before reaching here); provider-outage lands here only once the v1.46 same-channel requeue
                 // cap above is spent, so a transient blip still recovers in place.
-                const dead = classifyDeadChannel(result);
+                // OBS-117 (v1.71 T6): a silent launch failure has no CLI signature to parse — the same
+                // setup-required typed dead-channel path a late-harvest "command not found" would take.
+                const dead = classifyDeadChannel(result) ?? (earlyLaunchDead ? "setup-required" : undefined);
                 if (dead) {
                     const from = channelKey(assignment);
                     demotedChannels.add(from); // excluded for later attempts AND later tasks in this run
+                    journal.append("channel-exclusion", t.id, { channel: from, reason: dead, kind: "dead-channel" });
                     const next = failover("dead-channel");
                     journal.append("dead-channel-failover", t.id, { reason: dead, from, to: next ? channelKey(next) : null });
                     if (next) {
@@ -1130,9 +1182,14 @@ export async function runDaemon(repoRoot, opts = {}) {
             for (const t of ready) {
                 const p = execTask(t)
                     .catch(async (err) => {
+                    const taskEvents = journal.read().filter((e) => e.taskId === t.id);
+                    const dispatch = [...taskEvents].reverse().find((e) => e.event === "task-dispatch");
+                    const verifiedFailure = taskEvents.some((e) => e.event === "gate-result" && e.data.pass === false);
+                    const kind = verifiedFailure ? "gate-fail" : dispatch ? "dispatch" : "infra";
+                    const attempts = dispatch && Number.isInteger(dispatch.data.attempt) ? dispatch.data.attempt : 0;
                     graph = setStatus(graph, t.id, "failed");
                     saveGraph(repoRoot, graph);
-                    journal.append("task-failed", t.id, { error: String(err) });
+                    journal.append("task-failed", t.id, { error: String(err), kind, attempts });
                     journal.telemetry({ taskId: t.id, shape: t.shape, adapter: "-", model: "-", channel: "-", attempts: 0, outcome: "failed", durationMs: 0 });
                     await reconcile({ spareLiveLlm: true }); // task-failed is a terminal event
                 })

package/dist/run/interactive-seed.d.ts

@@ -4,6 +4,7 @@ export interface InteractiveSeedResult {
     output: string;
     seedFailed: boolean;
     seedError?: string;
+    sessionId?: string;
 }
 export declare function runInteractiveSeed(opts: {
     driver: Pick<ExecutorDriver, "run" | "waitOutput" | "read">;

package/dist/run/interactive-seed.js

@@ -6,9 +6,17 @@ export async function runInteractiveSeed(opts) {
     const seed = opts.adapter.interactiveSeed;
     await opts.driver.run(opts.slot, seed.launch(opts.assignment.model));
     const ready = await opts.driver.waitOutput(opts.slot, seed.readinessMatch, opts.taskTimeoutMinutes * 60_000);
+    const banner = await opts.driver.read(opts.slot, 1000);
     if (!ready) {
-        const output = await opts.driver.read(opts.slot, 1000);
-        return { output, seedFailed: true, seedError: `readiness pattern not seen: ${seed.readinessMatch}` };
+        return { output: banner, seedFailed: true, seedError: `readiness pattern not seen: ${seed.readinessMatch}` };
+    }
+    let sessionId;
+    if (seed.confirmBanner) {
+        const confirm = seed.confirmBanner(banner, opts.assignment.model);
+        if (!confirm.ok) {
+            return { output: banner, seedFailed: true, seedError: confirm.error };
+        }
+        sessionId = confirm.sessionId;
     }
     const seedText = seed.seedLine(opts.promptFile);
     await opts.driver.run(opts.slot, seedText);
@@ -18,8 +26,8 @@ export async function runInteractiveSeed(opts) {
         output = await opts.driver.read(opts.slot, 1000);
         const bottom = output.trimEnd().split("\n").pop() ?? "";
         if (!bottom.includes(seedText)) {
-            return { output, seedFailed: false };
+            return { output, seedFailed: false, ...(sessionId ? { sessionId } : {}) };
         }
     }
-    return { output, seedFailed: true, seedError: "seed line never left the input box" };
+    return { output, seedFailed: true, seedError: "seed line never left the input box", ...(sessionId ? { sessionId } : {}) };
 }

package/dist/run/journal.d.ts

@@ -15,13 +15,18 @@ export interface ResumeState {
     tried: string[];
     lastAssignment?: Assignment;
 }
+export declare const CHANNEL_EXCLUSION_KINDS: readonly ["dead-channel"];
+export type ChannelExclusionKind = (typeof CHANNEL_EXCLUSION_KINDS)[number];
 export declare const ATTEMPT_CAP_RELEASE: "attempt-cap";
-export declare const PARK_KINDS: readonly ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota", "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved"];
+export declare const PARK_KINDS: readonly ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota", "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved", "infra", "dispatch"];
 export type ParkKind = (typeof PARK_KINDS)[number];
 export declare const RETRY_MODES: readonly ["resume", "fresh"];
 export type RetryMode = (typeof RETRY_MODES)[number];
 export declare const WORKER_RESULT_CAUSES: readonly ["provider-death", "stall-timeout", "malformed-trailer", "clean-exit-no-trailer"];
 export type WorkerResultCause = (typeof WORKER_RESULT_CAUSES)[number];
+export declare function isQualityFailureParkKind(kind: ParkKind): boolean;
+export declare function recordedTaskFailureKind(events: JournalEvent[], taskId: string): ParkKind | undefined;
+export declare function runHasEnded(events: JournalEvent[]): boolean;
 /** OBS-53: classify worker-result failures so retries and routing see the true signal, not one lumped bucket. */
 export declare function classifyWorkerResultCause(opts: {
     output: string;
@@ -58,6 +63,8 @@ export declare const TelemetryRowSchema: z.ZodObject<{
         stall: "stall";
         "merge-conflict": "merge-conflict";
         "tip-moved": "tip-moved";
+        infra: "infra";
+        dispatch: "dispatch";
     }>>;
     tokens: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         input: z.ZodNumber;
@@ -139,6 +146,7 @@ export declare class Journal {
     read(): JournalEvent[];
     replayStatuses(): Map<string, TaskStatus>;
     replayResumeState(): Map<string, ResumeState>;
+    replayExcludedChannels(): Set<string>;
     telemetry(row: TelemetryRow): void;
     readTelemetry(): TelemetryRow[];
 }

package/dist/run/journal.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { channelKey, TokenUsageSchema } from "../adapters/types.js";
 import { stateDirName, tickmarkrDir } from "../graph/graph.js";
 import { TIERS } from "../graph/schema.js";
-import { buildProfile } from "../route/profile.js";
+import { buildProfile, classify } from "../route/profile.js";
 import { redactSecrets } from "./redact.js";
 export function formatJournalNarration({ event, taskId, data }) {
     const assignment = data.assignment;
@@ -26,6 +26,9 @@ export function formatJournalNarration({ event, taskId, data }) {
                             : String(direct);
     return [event, taskId, detail?.replace(/\s+/g, " ").slice(0, 120)].filter(Boolean).join(" — ");
 }
+// v1.71 OBS-119: run-wide channel exclusions derived from journal events — companion to
+// replayResumeState(), consumed by the daemon on resume to re-seed demotedChannels.
+export const CHANNEL_EXCLUSION_KINDS = ["dead-channel"];
 // v1.24 OBS-18: explicit data on task-approved when the operator releases an attempt-cap park.
 // Approve stamps this; replayResumeState zeros the attempt counter (fresh budget) while keeping
 // tried (consult bans / burned channels). Absent on pre-v1.24 events ⇒ inert (corpus outcome-identical).
@@ -40,9 +43,43 @@ const DispatchAssignmentSchema = z.object({
     tier: z.enum(TIERS),
 });
 export const PARK_KINDS = ["human-gate", "ladder-exhausted", "attempt-cap", "gate-fail", "quota",
-    "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved"];
+    "reroute-exhausted", "setup", "stall", "merge-conflict", "tip-moved", "infra", "dispatch"];
 export const RETRY_MODES = ["resume", "fresh"];
 export const WORKER_RESULT_CAUSES = ["provider-death", "stall-timeout", "malformed-trailer", "clean-exit-no-trailer"];
+// Status consumes the routing profile's existing quality split directly: verified park kinds classify
+// to 0, while availability/recovery noise classifies to null. Keep the synthetic row here at the
+// run↔route seam so presentation code never grows a second list of "bad" park kinds.
+export function isQualityFailureParkKind(kind) {
+    return classify({
+        shape: "", adapter: "-", model: "-", channel: "-", attempts: 0,
+        outcome: "human", durationMs: 0, parkKind: kind,
+    }) === 0;
+}
+// The newest terminal event owns the cause. Unknown/malformed kinds fail toward undefined so a
+// task-failed row keeps the legacy red treatment instead of being mistaken for recoverable noise.
+export function recordedTaskFailureKind(events, taskId) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const e = events[i];
+        if (e.taskId !== taskId || (e.event !== "task-human" && e.event !== "task-failed"))
+            continue;
+        return typeof e.data.kind === "string" && PARK_KINDS.includes(e.data.kind)
+            ? e.data.kind
+            : undefined;
+    }
+    return undefined;
+}
+// Runs can end and later resume in the same journal. The newest lifecycle marker decides whether
+// an unresolved task is still recoverable by this live daemon or belongs to an ended run.
+export function runHasEnded(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i].event;
+        if (event === "run-end" || event === "superseded")
+            return true;
+        if (event === "run-start" || event === "run-resume")
+            return false;
+    }
+    return false;
+}
 // OBS-53: provider-outage signatures in dead worker output ("Unable to reach the model provider" and kin).
 const PROVIDER_OUTAGE_RE = /Unable to reach the model provider|cannot reach the model provider|model provider.*(?:unavailable|unreachable)/i;
 /** OBS-53: classify worker-result failures so retries and routing see the true signal, not one lumped bucket. */
@@ -424,6 +461,20 @@ export class Journal {
         }
         return m;
     }
+    // v1.71 OBS-119: run-wide exclusion fold — same replay discipline as replayResumeState().
+    // channel-exclusion is the typed event; dead-channel-failover.from is the pre-v1.71 compat seam.
+    replayExcludedChannels() {
+        const excluded = new Set();
+        for (const e of this.read()) {
+            if (e.event === "channel-exclusion" && typeof e.data.channel === "string") {
+                excluded.add(e.data.channel);
+            }
+            else if (e.event === "dead-channel-failover" && typeof e.data.from === "string") {
+                excluded.add(e.data.from);
+            }
+        }
+        return excluded;
+    }
     telemetry(row) {
         // T3 secret redaction: same persistence seam as append — credential-free rows are byte-identical.
         appendFileSync(join(this.dir, "telemetry.jsonl"), redactSecrets(JSON.stringify(row)) + "\n");

package/dist/tui/ink/components.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+export type FleetListRow = {
+    id: string;
+    content: ReactNode;
+};
+export declare function ToggleMark({ active }: {
+    active: boolean;
+}): import("react").JSX.Element;
+export declare function FleetListScreen({ title, legend, rows, cursor, details, }: {
+    title: string;
+    legend: string;
+    rows: FleetListRow[];
+    cursor: number;
+    details?: string[];
+}): import("react").JSX.Element;
+export declare function FleetReviewScreen({ title, legend, diff, }: {
+    title: string;
+    legend: string;
+    diff: string;
+}): import("react").JSX.Element;

package/dist/tui/ink/components.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { GLYPHS } from "../../brand.js";
+export function ToggleMark({ active }) {
+    return active
+        ? _jsx(Text, { color: "ansi256(41)", children: GLYPHS.toggleActive })
+        : _jsx(Text, { dimColor: true, children: GLYPHS.toggleInactive });
+}
+export function FleetListScreen({ title, legend, rows, cursor, details = [], }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), rows.map((row, index) => (_jsxs(Text, { bold: index === cursor, children: [index === cursor ? `${GLYPHS.pointer} ` : "  ", row.content] }, row.id))), details.map((detail) => _jsx(Text, { children: detail }, detail))] }));
+}
+export function FleetReviewScreen({ title, legend, diff, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), _jsx(Text, { children: diff })] }));
+}

package/dist/tui/ink/fleet-app.d.ts

@@ -0,0 +1,113 @@
+import type { AuthHealth, WorkerAdapter } from "../../adapters/types.js";
+import type { MapEntry, RoutingMode, Tier } from "../../config/config.js";
+import { type Shape } from "../../graph/schema.js";
+export type FleetSteeringKey = "review" | "consult";
+export type FleetEditorState = {
+    denyAdapters: string[];
+    denyModels: string[];
+    classifications: FleetClassification[];
+    selectedMode: RoutingMode;
+    map: Record<string, MapEntry>;
+    steering: Record<FleetSteeringKey, string[] | undefined>;
+};
+export type FleetOverlayReview = {
+    kind: "empty";
+} | {
+    kind: "diff";
+    before: string;
+    after: string;
+    diff: string;
+    path: string;
+};
+export type FleetEditorResult = {
+    kind: "write";
+    review: Extract<FleetOverlayReview, {
+        kind: "diff";
+    }>;
+} | {
+    kind: "discard";
+} | {
+    kind: "no-changes";
+} | {
+    kind: "quit";
+} | {
+    kind: "refresh";
+};
+type AgentCli = {
+    id: string;
+    version: string;
+    authed: boolean;
+};
+export type FleetModelGroup = {
+    adapter: string;
+    rows: Array<{
+        model: string;
+        tier?: Tier;
+        detectedAt?: string;
+    }>;
+};
+export type FleetClassification = {
+    adapter: string;
+    model: string;
+    tier: Tier;
+    note: string;
+};
+export type FleetModeOption = {
+    id: RoutingMode;
+    gloss: string;
+};
+export type FleetShapeRow = {
+    id: Shape;
+    label: string;
+};
+export type FleetCandidateOption = {
+    id: string;
+    label: string;
+    pin: {
+        via: string;
+        model: string;
+    };
+};
+export declare function formatDoctorAge(ageMs: number | null): string;
+export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, }: {
+    ageMs: number | null;
+    agents: AgentCli[];
+    initialDenyAdapters: string[];
+    initialDenyModels: string[];
+    modelGroups: FleetModelGroup[];
+    initialMode: RoutingMode;
+    modeOptions: FleetModeOption[];
+    initialMap: Record<string, MapEntry>;
+    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>) => string[];
+    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>) => FleetShapeRow[];
+    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>) => FleetCandidateOption[];
+    preferOptionsForShape: (shape: Shape, current: string[]) => string[];
+    initialSteering: Record<FleetSteeringKey, string[] | undefined>;
+    steeringOptionsFor: (which: FleetSteeringKey, current: string[]) => string[];
+    reviewOverlay: (state: FleetEditorState) => FleetOverlayReview;
+    reloadGuard: (bytes: string) => string | null;
+}): import("react").JSX.Element;
+export declare function runFleetInkEditor({ ageMs, adapters, health, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, initialInput, input, output, debug, }: {
+    ageMs: number | null;
+    adapters: WorkerAdapter[];
+    health: Record<string, AuthHealth>;
+    initialDenyAdapters: string[];
+    initialDenyModels: string[];
+    modelGroups: FleetModelGroup[];
+    initialMode: RoutingMode;
+    modeOptions: FleetModeOption[];
+    initialMap: Record<string, MapEntry>;
+    modePreview: (mode: RoutingMode, map: Record<string, MapEntry>) => string[];
+    shapeRows: (mode: RoutingMode, map: Record<string, MapEntry>) => FleetShapeRow[];
+    candidatesForShape: (shape: Shape, mode: RoutingMode, map: Record<string, MapEntry>) => FleetCandidateOption[];
+    preferOptionsForShape: (shape: Shape, current: string[]) => string[];
+    initialSteering: Record<FleetSteeringKey, string[] | undefined>;
+    steeringOptionsFor: (which: FleetSteeringKey, current: string[]) => string[];
+    reviewOverlay: (state: FleetEditorState) => FleetOverlayReview;
+    reloadGuard: (bytes: string) => string | null;
+    initialInput?: string[];
+    input: NodeJS.ReadStream;
+    output: NodeJS.WriteStream;
+    debug?: boolean;
+}): Promise<FleetEditorResult>;
+export {};