tickmarkr 1.71.0 → 1.73.0

package/dist/cli/commands/fleet.js

@@ -1,11 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-import { emitKeypressEvents } from "node:readline";
-import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, readAutoPrefer } from "../../adapters/registry.js";
 import { fleetUnclassifiedModels } from "../../adapters/model-lints.js";
-import { GLYPHS, bold, legend as legendText, toggleActive, toggleInactive } from "../../brand.js";
 import { fleetEditableFromConfig, fleetEditableEquals, fleetRepoOverlayFromDelta, formatFleetPrint, globalConfigDir, harvestFleetProvenance, overlayBytesLoadError, overlayPreferShapes, readOverlayFile, repoOverlayPath, repoOverlayYaml, ROUTING_MODES, unifiedYamlDiff, } from "../../config/config.js";
 import { SHAPES, TIERS } from "../../graph/schema.js";
 import { candidateRow, costSignal, shapeCandidates } from "./fleet-picker.js";
@@ -14,8 +11,6 @@ import { resolveRunMode } from "../../run/daemon.js";
 import { loadRoutingProfile } from "../../run/journal.js";
 const NON_TTY_MSG = "tickmarkr fleet: interactive fleet editor requires a TTY — use `tickmarkr fleet --print` for non-interactive output";
 const QUIT = "fleet: quit without writing";
-const isDeniedAdapter = (id, editable) => editable.denyAdapters.includes(id);
-const isDeniedModel = (adapter, model, editable) => editable.denyModels.includes(`${adapter}:${model}`);
 // v1.60 T3: every preview surface ranks with the SAME exploration setting as the candidate picker
 // (rankCandidates routes noExplore so repeated calls agree) — a due probe must never make a
 // step-4/5 row disagree with the picker's rank-1 for the same shape and channel set.
@@ -37,14 +32,6 @@ function previewTask(shape) {
         evidence: { commits: [], artifacts: [], gateResults: [] },
     };
 }
-function formatAge(ageMs) {
-    if (ageMs === null)
-        return "no probe data";
-    const mins = Math.floor(ageMs / 60_000);
-    if (mins < 60)
-        return `${mins}m old`;
-    return `${Math.floor(mins / 60)}h old`;
-}
 function currentRepoOverlayText(repoRoot) {
     const p = repoOverlayPath(repoRoot);
     return existsSync(p) ? readFileSync(p, "utf8") : "";
@@ -76,90 +63,6 @@ const MODE_GLOSS = {
     "risk-based": "risk-tiered default floors",
     "staff-led": "implement/refactor one band down · integrity shapes hold frontier",
 };
-const isAbort = (k) => k.name === "escape" || k.name === "q" || (k.ctrl === true && k.name === "c");
-const isNext = (k) => k.name === "return" || k.name === "enter";
-const isToggle = (k) => k.name === "space";
-function moveCursor(k, cursor, count) {
-    if (count === 0)
-        return cursor;
-    if (k.name === "down" || k.name === "j")
-        return Math.min(cursor + 1, count - 1);
-    if (k.name === "up" || k.name === "k")
-        return Math.max(cursor - 1, 0);
-    return cursor;
-}
-// step title (bold) + one dim key legend + rows; exactly one pointer glyph on the cursor row
-function listFrame(title, legend, rows, cursor) {
-    const lines = [bold(title), legendText(legend)];
-    rows.forEach((r, i) => lines.push(i === cursor ? `${GLYPHS.pointer} ${bold(r)}` : `  ${r}`));
-    return lines;
-}
-// Keypress terminal over the (injectable) input stream. Keypress events are decoded by
-// node's own emitKeypressEvents ON THE STREAM — no readline interface is held in keypress
-// mode, so the production path and the test seam are the same decoder (OBS-69).
-function openTerm(input, output) {
-    emitKeypressEvents(input);
-    const queue = [];
-    let pending = null;
-    const onKeypress = (str, key) => {
-        const k = key && (key.name !== undefined || key.sequence !== undefined) ? key : { name: str, sequence: str };
-        if (pending) {
-            const fn = pending;
-            pending = null;
-            fn(k);
-        }
-        else
-            queue.push(k);
-    };
-    const setRaw = (on) => void input.setRawMode?.(on);
-    input.on("keypress", onKeypress);
-    setRaw(true);
-    input.resume();
-    let prevLines = 0;
-    return {
-        key() {
-            const buffered = queue.shift();
-            if (buffered)
-                return Promise.resolve(buffered);
-            return new Promise((resolve) => {
-                pending = resolve;
-            });
-        },
-        frame(lines) {
-            const erase = prevLines > 0 ? `\x1b[${prevLines}F\x1b[0J` : "";
-            output.write(`${erase}${lines.join("\n")}\n`);
-            prevLines = lines.length;
-        },
-        // typed entry leaves keypress mode: raw off, transient line interface, closed after the
-        // question; keys the line editor leaked into the decoder are dropped (type-ahead kept)
-        async askTyped(prompt) {
-            const typedFrom = queue.length;
-            setRaw(false);
-            const rl = createInterface({
-                input: input,
-                output: output,
-            });
-            try {
-                return (await rl.question(prompt)).trim();
-            }
-            finally {
-                rl.close();
-                setRaw(true);
-                // rl.close() pauses the input stream — without a resume the next key() await has
-                // nothing keeping the event loop alive and the process silently exits 0 (OBS-77)
-                input.resume();
-                queue.splice(typedFrom);
-                prevLines = 0;
-            }
-        },
-        // every exit path: raw mode off, zero keypress listeners, stream paused (OBS-70)
-        close() {
-            input.off("keypress", onKeypress);
-            setRaw(false);
-            input.pause();
-        },
-    };
-}
 export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(), io = {}) {
     const { values } = parseArgs({
         args: argv,
@@ -200,346 +103,146 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     const initial = fleetEditableFromConfig(cfg, harvested.tiers);
     const editable = structuredClone(initial);
     const health = cached;
-    const term = openTerm(input, output);
-    try {
-        // step 1/6 — probe data
-        const ageLine = formatAge(doctorAgeMs(cwd));
-        term.frame(listFrame("step 1/6 · probe data", "enter continue · r refresh via doctor · esc/q quit", [`probe data: ${ageLine} (.tickmarkr/doctor.json)`], 0));
-        for (;;) {
-            const k = await term.key();
-            if (isAbort(k))
-                return QUIT;
-            if (k.name === "r") {
-                return "fleet: run `tickmarkr doctor` to refresh probe data, then re-run `tickmarkr fleet` (doctor is the sensor; fleet never re-probes)";
-            }
-            if (isNext(k))
-                break;
-        }
-        // step 2/6 — agent CLIs (space toggles adapter deny)
-        const installed = adapters.filter((a) => health[a.id]?.installed);
-        const adapterRows = () => installed.map((a) => {
-            const h = health[a.id];
-            const on = !isDeniedAdapter(a.id, editable);
-            return `${on ? toggleActive() : toggleInactive()} ${a.id}  ${h?.version ?? "installed"}  ${h?.authed ? "authed" : "unauthed"}`;
-        });
-        const listLegend = "↑↓/jk move · space toggle · enter next · esc/q quit";
-        let aCursor = 0;
-        term.frame(listFrame("step 2/6 · agent CLIs", listLegend, adapterRows(), aCursor));
-        for (;;) {
-            const k = await term.key();
-            if (isAbort(k))
-                return QUIT;
-            if (isNext(k))
-                break;
-            let changed = false;
-            const moved = moveCursor(k, aCursor, installed.length);
-            if (moved !== aCursor) {
-                aCursor = moved;
-                changed = true;
-            }
-            else if (isToggle(k) && installed.length > 0) {
-                const id = installed[aCursor].id;
-                const idx = editable.denyAdapters.indexOf(id);
-                if (idx === -1)
-                    editable.denyAdapters.push(id);
-                else
-                    editable.denyAdapters.splice(idx, 1);
-                editable.denyAdapters.sort();
-                changed = true;
-            }
-            if (changed)
-                term.frame(listFrame("step 2/6 · agent CLIs", listLegend, adapterRows(), aCursor));
-        }
-        // step 3/6 — models per enabled adapter (space toggles deny, t assigns tier from the row)
-        const enabledAdapters = installed.filter((a) => !isDeniedAdapter(a.id, editable));
-        for (const a of enabledAdapters) {
-            const unclassifiedAll = fleetUnclassifiedModels(cfg, health, adapters).filter((u) => u.adapter === a.id);
-            const rowsData = () => [
-                ...Object.keys(editable.tiers[a.id] ?? {}).map((m) => ({ kind: "classified", model: m })),
-                ...unclassifiedAll
-                    .filter((u) => !editable.tiers[a.id]?.[u.model])
-                    .map((u) => ({ kind: "unclassified", model: u.model, detectedAt: u.detectedAt })),
-            ];
-            const renderRows = (rows) => rows.map((r) => {
-                if (r.kind === "unclassified") {
-                    return `( ) ${r.model}  ???  unclassified${r.detectedAt ? ` (${r.detectedAt})` : ""}`;
-                }
-                const tier = editable.tiers[a.id]?.[r.model];
-                const denied = isDeniedModel(a.id, r.model, editable);
-                return `${denied ? toggleInactive() : toggleActive()} ${r.model}  ${tier?.tier ?? "???"}  ${denied ? "denied" : "allowed"}`;
-            });
-            const title = `step 3/6 · models · ${a.id}`;
-            const modelsLegend = "↑↓/jk move · space toggle · t tier · enter next · esc/q quit";
-            let mCursor = 0;
-            term.frame(listFrame(title, modelsLegend, renderRows(rowsData()), mCursor));
-            for (;;) {
-                const k = await term.key();
-                if (isAbort(k))
-                    return QUIT;
-                if (isNext(k))
-                    break;
-                const rows = rowsData();
-                let changed = false;
-                const moved = moveCursor(k, mCursor, rows.length);
-                if (moved !== mCursor) {
-                    mCursor = moved;
-                    changed = true;
-                }
-                else if (isToggle(k) && rows[mCursor]?.kind === "classified") {
-                    const key = `${a.id}:${rows[mCursor].model}`;
-                    const idx = editable.denyModels.indexOf(key);
-                    if (idx === -1)
-                        editable.denyModels.push(key);
-                    else
-                        editable.denyModels.splice(idx, 1);
-                    editable.denyModels.sort();
-                    changed = true;
-                }
-                else if (k.name === "t" && rows[mCursor]) {
-                    if (rows[mCursor].kind === "classified") {
-                        // v1.60 T2: t on a classified row is a step-3 input mistake like any other — the
-                        // notice renders inline and the session (with every in-session edit) stays alive
-                        term.frame([
-                            ...listFrame(title, modelsLegend, renderRows(rows), mCursor),
-                            "fleet: tier reassignment on classified models is not supported in v1 — edit config directly",
-                        ]);
-                        continue;
-                    }
-                    // v1.60 T2: an input mistake re-prompts the same field — a typo must never unwind
-                    // the whole editor and discard every in-session edit before the review screen
-                    let tier = (await term.askTyped(`tier (${TIERS.join("|")})> `));
-                    while (!TIERS.includes(tier)) {
-                        tier = (await term.askTyped(`fleet: invalid tier ${tier || "(empty)"} — tier (${TIERS.join("|")})> `));
-                    }
-                    let note = await term.askTyped("benchmark provenance note (required): ");
-                    while (!note) {
-                        note = await term.askTyped("fleet: a typed benchmark-provenance note is required — benchmark provenance note (required): ");
-                    }
-                    editable.tiers[a.id] ??= {};
-                    // stamp at typing time — the serializer writes provenance verbatim, so harvested notes
-                    // round-trip byte-for-byte instead of accreting a fresh date suffix every write (OBS-88)
-                    const today = new Date().toISOString().slice(0, 10);
-                    editable.tiers[a.id][rows[mCursor].model] = { tier, provenance: `${note} — fleet ${today}` };
-                    changed = true;
-                }
-                if (changed)
-                    term.frame(listFrame(title, modelsLegend, renderRows(rowsData()), mCursor));
-            }
-        }
-        // step 4/6 — routing mode (selection is in-memory; the write happens only through the diff confirm).
-        // Candidate floor tables come from the ONE preset compiler via resolveRunMode — no mode math here.
-        const modeCfgs = Object.fromEntries(ROUTING_MODES.map((m) => [m, m === rm.mode.mode ? rm : resolveRunMode(cwd, { flag: m, globalDir })]));
-        // v1.56 T3: both screens preview-route through ONE lens — the same live channel set, learned
-        // profile, and per-mode resolved floors — so the mode spend context and the shape rows can
-        // never disagree about what the router would do.
-        const channels = discoverChannels(cfg, adapters, health);
-        const profile = loadRoutingProfile(cwd, cfg, { preview: true });
-        const previewCfg = (m) => ({ ...cfg, routing: { ...cfg.routing, map: editable.map, floors: modeCfgs[m].cfg.routing.floors } });
-        // Estimated spend context under the highlighted mode: tier mix across all nine preview shapes,
-        // then channel economics — dollars only for api-routed shapes (plan.ts's rough per-task
-        // pricing table); a sub channel is flat-rate quota and never renders as a dollar amount.
-        const modeSpend = (cand) => {
-            const tierCount = {};
-            let subs = 0;
-            let apiN = 0;
-            let apiUsd = 0;
-            for (const shape of SHAPES) {
-                try {
-                    const a = route(previewTask(shape), previewCfg(cand), channels, profile, undefined, undefined, PREVIEW_EXPLORE).assignment;
-                    tierCount[a.tier] = (tierCount[a.tier] ?? 0) + 1;
-                    if (a.channel === "sub")
-                        subs += 1;
-                    else {
-                        apiN += 1;
-                        apiUsd += cfg.pricing[a.tier] ?? 0;
-                    }
-                }
-                catch {
-                    // unroutable under this mode's floors — the shape screen names the error per row
-                }
-            }
-            const mix = [...TIERS].reverse().flatMap((t) => (tierCount[t] ? [`${tierCount[t]} ${t}`] : [])).join(" · ");
-            const parts = [];
-            if (subs)
-                parts.push(`${subs === SHAPES.length ? "all" : subs} sub (flat-rate quota)`);
-            if (apiN)
-                parts.push(`${apiN} api · est. cost (API shapes only, rough): ~$${apiUsd.toFixed(2)}`);
-            const unroutable = SHAPES.length - subs - apiN;
-            if (unroutable)
-                parts.push(`${unroutable} unroutable`);
-            return `  mix: ${mix} — ${parts.join(" · ")}`;
-        };
-        const modeRows = () => ROUTING_MODES.map((m) => `${m === rm.mode.mode ? toggleActive() : " "} ${m.padEnd(11)}  ${MODE_GLOSS[m]}`);
-        // preview: the highlighted mode's resolved floor table diffed against the current mode
-        const floorPreview = (cand) => {
-            if (cand === rm.mode.mode)
-                return [];
-            const cur = cfg.routing.floors;
-            const next = modeCfgs[cand].cfg.routing.floors;
-            const changed = SHAPES.filter((s) => cur[s] !== next[s]);
-            return [
-                `  floors vs ${rm.mode.mode}:`,
-                ...(changed.length ? changed.map((s) => `    ${s}: ${cur[s]} → ${next[s]}`) : ["    (no floor changes)"]),
-            ];
+    const modelGroups = adapters
+        .filter((adapter) => health[adapter.id]?.installed)
+        .map((adapter) => {
+        const unclassified = fleetUnclassifiedModels(cfg, health, adapters).filter((row) => row.adapter === adapter.id);
+        return {
+            adapter: adapter.id,
+            rows: [
+                ...Object.entries(editable.tiers[adapter.id] ?? {}).map(([model, value]) => ({ model, tier: value?.tier })),
+                ...unclassified
+                    .filter((row) => !editable.tiers[adapter.id]?.[row.model])
+                    .map((row) => ({ model: row.model, detectedAt: row.detectedAt })),
+            ],
         };
-        const modeTitle = "step 4/6 · routing mode";
-        const modeLegend = "↑↓/jk move · enter select · esc/q quit";
-        let modeCursor = ROUTING_MODES.indexOf(rm.mode.mode);
-        let selectedMode = rm.mode.mode;
-        const modeFrame = () => [
-            ...listFrame(modeTitle, modeLegend, modeRows(), modeCursor),
-            modeSpend(ROUTING_MODES[modeCursor]),
-            ...floorPreview(ROUTING_MODES[modeCursor]),
-        ];
-        term.frame(modeFrame());
-        for (;;) {
-            const k = await term.key();
-            if (isAbort(k))
-                return QUIT;
-            if (isNext(k)) {
-                selectedMode = ROUTING_MODES[modeCursor];
-                break;
-            }
-            const moved = moveCursor(k, modeCursor, ROUTING_MODES.length);
-            if (moved !== modeCursor) {
-                modeCursor = moved;
-                term.frame(modeFrame());
-            }
-        }
-        // step 5/6 — shape routing (candidate picker for pin, typed entry for prefer);
-        // previews route under the SELECTED mode's resolved floors, never a floor edit of its own
-        const autoPrefer = readAutoPrefer(cwd);
-        const overlayShapes = overlayPreferShapes(cwd, { globalDir });
-        const shapeRows = () => SHAPES.map((shape) => {
-            let now;
+    });
+    // Steps 4–5 remain surfaces over production routing. Ink owns interaction and rendering;
+    // these callbacks retain the existing router, preset compiler, and candidate-ranker seams.
+    const modeCfgs = Object.fromEntries(ROUTING_MODES.map((mode) => [
+        mode,
+        mode === rm.mode.mode ? rm : resolveRunMode(cwd, { flag: mode, globalDir }),
+    ]));
+    const channels = discoverChannels(cfg, adapters, health);
+    const profile = loadRoutingProfile(cwd, cfg, { preview: true });
+    const previewCfg = (mode, map) => ({
+        ...cfg,
+        routing: { ...cfg.routing, map, floors: modeCfgs[mode].cfg.routing.floors },
+    });
+    const modeSpend = (mode, map) => {
+        const tierCount = {};
+        let subs = 0;
+        let apiN = 0;
+        let apiUsd = 0;
+        for (const shape of SHAPES) {
             try {
-                const r = route(previewTask(shape), previewCfg(selectedMode), channels, profile, undefined, undefined, PREVIEW_EXPLORE);
-                now = `${r.assignment.adapter}:${r.assignment.model} (${r.assignment.channel}, ${r.assignment.tier})  ${costSignal(r.assignment, cfg.pricing)}`;
-            }
-            catch (e) {
-                now = e.message;
-            }
-            const auto = autoPrefer?.[shape] && !overlayShapes.has(shape) ? "  (auto-prefer active)" : "";
-            return `${shape}  →  ${now}${auto}`;
-        });
-        const shapesTitle = "step 5/6 · shape routing";
-        // v1.52 T5: no map-tier editing action — routing.floors is the only band authority now.
-        const shapesLegend = "↑↓/jk move · a auto · p pin · f prefer · enter next · esc/q quit";
-        let sCursor = 0;
-        term.frame(listFrame(shapesTitle, shapesLegend, shapeRows(), sCursor));
-        for (;;) {
-            const k = await term.key();
-            if (isAbort(k))
-                return QUIT;
-            if (isNext(k))
-                break;
-            const shape = SHAPES[sCursor];
-            const entry = editable.map[shape] ?? {};
-            let changed = false;
-            const moved = moveCursor(k, sCursor, SHAPES.length);
-            if (moved !== sCursor) {
-                sCursor = moved;
-                changed = true;
-            }
-            else if (k.name === "a") {
-                const next = { ...entry };
-                delete next.pin;
-                editable.map[shape] = next;
-                changed = true;
-            }
-            else if (k.name === "p") {
-                // v1.56 T2: arrow-driven candidate picker replaces the typed pin entry (operator ruling:
-                // the suggestion proposes, the user disposes). Every rank is a production route() result
-                // (T1 seam); a pick mutates editable only — the write still funnels through the ONE
-                // diff-confirm + reload-guard path below. The picker adds no listeners of its own, so
-                // every exit path inherits term.close()'s release-and-pause contract in the finally.
-                const cand = shapeCandidates(previewTask(shape), previewCfg(selectedMode), channels, profile);
-                let pCursor = 0;
-                const pickerFrame = () => listFrame(`pick · ${shape}`, "↑↓/jk move · enter pin · esc cancel · q quit", cand.map((c) => candidateRow(c, cfg.pricing)), pCursor);
-                term.frame(pickerFrame());
-                for (;;) {
-                    const pk = await term.key();
-                    if (pk.name === "q" || (pk.ctrl === true && pk.name === "c"))
-                        return QUIT;
-                    if (pk.name === "escape")
-                        break;
-                    if (isNext(pk) && cand.length > 0) {
-                        const a = cand[pCursor].assignment;
-                        editable.map[shape] = { pin: { via: a.adapter, model: a.model } };
-                        break;
-                    }
-                    const pMoved = moveCursor(pk, pCursor, cand.length);
-                    if (pMoved !== pCursor) {
-                        pCursor = pMoved;
-                        term.frame(pickerFrame());
-                    }
+                const assignment = route(previewTask(shape), previewCfg(mode, map), channels, profile, undefined, undefined, PREVIEW_EXPLORE).assignment;
+                tierCount[assignment.tier] = (tierCount[assignment.tier] ?? 0) + 1;
+                if (assignment.channel === "sub")
+                    subs += 1;
+                else {
+                    apiN += 1;
+                    apiUsd += cfg.pricing[assignment.tier] ?? 0;
                 }
-                changed = true; // the picker replaced the frame — every exit redraws the shape screen
             }
-            else if (k.name === "f") {
-                const pref = await term.askTyped("prefer (comma-separated adapters or adapter:model)> ");
-                editable.map[shape] = { ...entry, prefer: pref.split(",").map((s) => s.trim()).filter(Boolean) };
-                changed = true;
+            catch {
+                // Unroutable under this mode's floors; the aggregate names it below.
             }
-            if (changed)
-                term.frame(listFrame(shapesTitle, shapesLegend, shapeRows(), sCursor));
         }
-        // step 6/6 — steering (v1.54 T4): review.prefer + consult.prefer via the same typed-entry
-        // pattern as the shape prefer action; edits are in-memory only and land on the merged overlay
-        // below, so they ride the ONE diff-confirm + reload-guard write path (never a second writer)
-        const STEER_KEYS = ["review", "consult"];
-        const initialSteering = {
-            review: cfg.review.prefer?.slice(),
-            consult: cfg.consult.prefer?.slice(),
-        };
-        const steering = structuredClone(initialSteering);
-        const steerRows = () => STEER_KEYS.map((k) => `${k}.prefer  →  ${steering[k]?.join(", ") ?? "(none)"}`);
-        const steerTitle = "step 6/6 · steering";
-        const steerLegend = "↑↓/jk move · f prefer · enter next · esc/q quit";
-        let stCursor = 0;
-        term.frame(listFrame(steerTitle, steerLegend, steerRows(), stCursor));
-        for (;;) {
-            const k = await term.key();
-            if (isAbort(k))
-                return QUIT;
-            if (isNext(k))
-                break;
-            let changed = false;
-            const moved = moveCursor(k, stCursor, STEER_KEYS.length);
-            if (moved !== stCursor) {
-                stCursor = moved;
-                changed = true;
-            }
-            else if (k.name === "f") {
-                const which = STEER_KEYS[stCursor];
-                const grammar = which === "consult" ? "adapter:model seats" : "adapters or adapter:model";
-                const raw = await term.askTyped(`${which}.prefer (comma-separated ${grammar}, empty clears)> `);
-                const list = raw.split(",").map((s) => s.trim()).filter(Boolean);
-                steering[which] = list.length ? list : undefined;
-                changed = true;
-            }
-            if (changed)
-                term.frame(listFrame(steerTitle, steerLegend, steerRows(), stCursor));
+        const mix = [...TIERS].reverse().flatMap((tier) => tierCount[tier] ? [`${tierCount[tier]} ${tier}`] : []).join(" · ");
+        const parts = [];
+        if (subs)
+            parts.push(`${subs === SHAPES.length ? "all" : subs} sub (flat-rate quota)`);
+        if (apiN)
+            parts.push(`${apiN} api · est. cost (API shapes only, rough): ~$${apiUsd.toFixed(2)}`);
+        const unroutable = SHAPES.length - subs - apiN;
+        if (unroutable)
+            parts.push(`${unroutable} unroutable`);
+        return `  mix: ${mix} — ${parts.join(" · ")}`;
+    };
+    const floorPreview = (mode) => {
+        if (mode === rm.mode.mode)
+            return [];
+        const current = cfg.routing.floors;
+        const next = modeCfgs[mode].cfg.routing.floors;
+        const changed = SHAPES.filter((shape) => current[shape] !== next[shape]);
+        return [
+            `  floors vs ${rm.mode.mode}:`,
+            ...(changed.length
+                ? changed.map((shape) => `    ${shape}: ${current[shape]} → ${next[shape]}`)
+                : ["    (no floor changes)"]),
+        ];
+    };
+    const autoPrefer = readAutoPrefer(cwd);
+    const overlayShapes = overlayPreferShapes(cwd, { globalDir });
+    const routedShapeRows = (mode, map) => SHAPES.map((shape) => {
+        let now;
+        try {
+            const routed = route(previewTask(shape), previewCfg(mode, map), channels, profile, undefined, undefined, PREVIEW_EXPLORE);
+            const assignment = routed.assignment;
+            now = `${assignment.adapter}:${assignment.model} (${assignment.channel}, ${assignment.tier})  ${costSignal(assignment, cfg.pricing)}`;
         }
-        // review — unified diff + typed confirm (the ONLY write path; the mode screen funnels through here)
+        catch (error) {
+            now = error.message;
+        }
+        const auto = autoPrefer?.[shape] && !overlayShapes.has(shape) ? "  (auto-prefer active)" : "";
+        return { id: shape, label: `${shape}  →  ${now}${auto}` };
+    });
+    const candidatesForShape = (shape, mode, map) => shapeCandidates(previewTask(shape), previewCfg(mode, map), channels, profile).map((candidate) => ({
+        id: `${candidate.assignment.adapter}:${candidate.assignment.model}`,
+        label: candidateRow(candidate, cfg.pricing),
+        pin: { via: candidate.assignment.adapter, model: candidate.assignment.model },
+    }));
+    const preferUniverse = [
+        ...new Set(channels.flatMap((channel) => [
+            channel.adapter,
+            channel.model,
+            `${channel.adapter}:${channel.model}`,
+        ])),
+    ];
+    const seats = [...new Set(channels.map((channel) => `${channel.adapter}:${channel.model}`))];
+    const reviewAdapters = [...new Set(channels.map((channel) => channel.adapter))];
+    const initialSteering = {
+        review: cfg.review.prefer?.slice(),
+        consult: cfg.consult.prefer?.slice(),
+    };
+    const steeringOptionsFor = (which, current) => {
+        const discovered = which === "review" ? [...reviewAdapters, ...seats] : seats;
+        return [...discovered, ...current.filter((entry) => !discovered.includes(entry))];
+    };
+    const reviewOverlay = (state) => {
+        const staged = structuredClone(initial);
+        staged.denyAdapters = state.denyAdapters;
+        staged.denyModels = state.denyModels;
+        staged.map = state.map;
+        const today = new Date().toISOString().slice(0, 10);
+        for (const classification of state.classifications) {
+            staged.tiers[classification.adapter] ??= {};
+            staged.tiers[classification.adapter][classification.model] = {
+                tier: classification.tier,
+                provenance: `${classification.note} — fleet ${today}`,
+            };
+        }
+        // This callback is the sole candidate-overlay builder. The Ink component renders
+        // the diff and asks for confirmation, but owns neither filesystem access nor a writer.
         const before = currentRepoOverlayText(cwd);
-        const existing = readOverlayFile(repoOverlayPath(cwd));
-        const modeChanged = selectedMode !== rm.mode.mode;
-        // preserve a repo-declared mode line verbatim; write a new one only when the selection changed it
-        const writeMode = modeChanged ? selectedMode : existing.routing?.mode;
-        const merged = fleetEditableEquals(initial, editable)
+        const path = repoOverlayPath(cwd);
+        const existing = readOverlayFile(path);
+        const modeChanged = state.selectedMode !== rm.mode.mode;
+        const writeMode = modeChanged
+            ? state.selectedMode
+            : existing.routing?.mode;
+        const merged = fleetEditableEquals(initial, staged)
             ? structuredClone(existing)
-            : fleetRepoOverlayFromDelta(initial, editable, existing);
-        // steering lands on the merged object and serializes via repoOverlayYaml's non-fleet
-        // passthrough; clearing removes the prefer key (and an emptied parent block) from the overlay
+            : fleetRepoOverlayFromDelta(initial, staged, existing);
         let steeringChanged = false;
-        for (const key of STEER_KEYS) {
-            if (JSON.stringify(steering[key]) === JSON.stringify(initialSteering[key]))
+        for (const key of ["review", "consult"]) {
+            if (JSON.stringify(state.steering[key]) === JSON.stringify(initialSteering[key]))
                 continue;
             steeringChanged = true;
             const block = { ...merged[key] };
-            if (steering[key])
-                block.prefer = steering[key];
+            if (state.steering[key])
+                block.prefer = state.steering[key];
             else
                 delete block.prefer;
             if (Object.keys(block).length)
@@ -547,35 +250,95 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
             else
                 delete merged[key];
         }
-        // OBS-88: session notes (which include the harvested ones attached at load) win per model;
-        // harvested notes alone cover entries with no editable seat — e.g. a null tombstone's comment
         const tierNotes = structuredClone(harvested.tiers);
-        for (const [ad, ms] of Object.entries(provenanceMap(editable))) {
-            for (const [m, n] of Object.entries(ms))
-                (tierNotes[ad] ??= {})[m] = n;
+        for (const [adapter, models] of Object.entries(provenanceMap(staged))) {
+            for (const [model, note] of Object.entries(models)) {
+                (tierNotes[adapter] ??= {})[model] = note;
+            }
         }
-        const after = withModeLine(repoOverlayYaml(merged, tierNotes, { adapters: harvested.denyAdapters, models: harvested.denyModels }), writeMode);
-        if ((!modeChanged && !steeringChanged && fleetEditableEquals(initial, editable)) || before === after) {
-            return "fleet: no overlay changes (empty diff)";
+        const after = withModeLine(repoOverlayYaml(merged, tierNotes, {
+            adapters: harvested.denyAdapters,
+            models: harvested.denyModels,
+        }), writeMode);
+        if ((!modeChanged && !steeringChanged && fleetEditableEquals(initial, staged)) || before === after) {
+            return { kind: "empty" };
         }
-        const diff = unifiedYamlDiff(before, after, repoOverlayPath(cwd));
-        output.write(`\n${diff}\n`);
-        const confirm = await term.askTyped("write overlay? [y/N] ");
-        if (!/^y(?:es)?$/i.test(confirm))
-            return "fleet: discarded overlay changes";
-        const path = repoOverlayPath(cwd);
-        // v1.52 T2 reload guard: the exact bytes about to land must reload through the production
-        // loader path, or the write is refused and the existing overlay stays untouched (OBS-75 class:
-        // fleet must never persist a config that bricks every later command).
-        const loadError = overlayBytesLoadError(cwd, after, { globalDir });
-        if (loadError) {
-            return { out: `fleet: refusing to write ${path} — the config loader rejects the proposed overlay:\n${loadError}`, code: 1 };
+        return {
+            kind: "diff",
+            before,
+            after,
+            diff: unifiedYamlDiff(before, after, path),
+            path,
+        };
+    };
+    const reloadGuard = io.reloadGuard
+        ?? ((bytes) => overlayBytesLoadError(cwd, bytes, { globalDir }));
+    // Keep Ink out of print, non-TTY, and missing-probe paths: the component runtime belongs
+    // exclusively to the interactive editor.
+    const initialInput = [];
+    const productionInput = input;
+    const captureStartupInput = typeof productionInput.ref === "function"
+        && typeof productionInput.unref === "function";
+    const onStartupInput = (chunk) => {
+        initialInput.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+    };
+    if (captureStartupInput) {
+        input.on("data", onStartupInput);
+        input.resume();
+    }
+    let runFleetInkEditor;
+    try {
+        ({ runFleetInkEditor } = await import("../../tui/ink/fleet-app.js"));
+    }
+    catch (error) {
+        if (captureStartupInput) {
+            input.off("data", onStartupInput);
+            input.pause();
         }
-        mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, after);
-        return `fleet: wrote ${path}`;
+        throw error;
     }
-    finally {
-        term.close();
+    if (captureStartupInput) {
+        input.off("data", onStartupInput);
+        input.pause();
+    }
+    const result = await runFleetInkEditor({
+        ageMs: doctorAgeMs(cwd),
+        adapters,
+        health,
+        initialDenyAdapters: editable.denyAdapters,
+        initialDenyModels: editable.denyModels,
+        modelGroups,
+        initialMode: rm.mode.mode,
+        modeOptions: ROUTING_MODES.map((mode) => ({ id: mode, gloss: MODE_GLOSS[mode] })),
+        initialMap: editable.map,
+        modePreview: (mode, map) => [modeSpend(mode, map), ...floorPreview(mode)],
+        shapeRows: routedShapeRows,
+        candidatesForShape,
+        preferOptionsForShape: (_shape, current) => [
+            ...preferUniverse,
+            ...current.filter((entry) => !preferUniverse.includes(entry)),
+        ],
+        initialSteering,
+        steeringOptionsFor,
+        reviewOverlay,
+        reloadGuard,
+        initialInput,
+        input: input,
+        output: output,
+        debug: io.debug,
+    });
+    if (result.kind === "quit")
+        return QUIT;
+    if (result.kind === "refresh") {
+        return "fleet: run `tickmarkr doctor` to refresh probe data, then re-run `tickmarkr fleet` (doctor is the sensor; fleet never re-probes)";
     }
+    if (result.kind === "no-changes")
+        return "fleet: no overlay changes (empty diff)";
+    if (result.kind === "discard")
+        return "fleet: discarded overlay changes";
+    // The command remains the single config actuator. Every interactive edit reaches this
+    // one write only after the component-rendered diff confirm and the production reload guard.
+    mkdirSync(dirname(result.review.path), { recursive: true });
+    writeFileSync(result.review.path, result.review.after);
+    return `fleet: wrote ${result.review.path}`;
 }