tickmarkr 1.90.8 → 1.92.0

package/dist/tui/ink/fleet-app.js

@@ -1,99 +1,14 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { emitKeypressEvents } from "node:readline";
-import { PassThrough } from "node:stream";
-import { render, Text, useApp, useInput } from "ink";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, render, Text, useApp, useInput } from "ink";
 import { useRef, useState } from "react";
 import { MODEL_ID_RE } from "../../adapters/types.js";
+import { retiredModelReason } from "../../adapters/model-lints.js";
 import { fleetFirstTouchProvenance } from "../../config/fleet-overlay.js";
 import { TIERS } from "../../graph/schema.js";
-import { FleetListScreen, FleetReviewScreen, ToggleMark } from "./components.js";
+import { windowRows } from "./components.js";
+import { clip, clipPathTail, ElisionMark, enterAltScreen, fmtCtx, fmtMs, fmtUsdPair, Glyph, INK, inkInput, inkOutput, KeyBar, OverlayPanel, padCell, padCellStart, Pointer, SearchRow, } from "./frame.js";
 const STEERING_KEYS = ["review", "consult"];
-const escape = String.fromCharCode(27);
 const CHANNELS = ["sub", "api"];
-const inkBookkeepingWrites = new Set(["", `${escape}[?25l`, `${escape}[?25h`, `${escape}[?2026h`, `${escape}[?2026l`]);
-function inkOutput(output) {
-    if (typeof output.on === "function" && typeof output.off === "function")
-        return output;
-    const facade = Object.create(output);
-    const write = output.write.bind(output);
-    facade.write = ((chunk, ...args) => {
-        const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
-        if (inkBookkeepingWrites.has(text))
-            return true;
-        return Reflect.apply(write, output, [chunk, ...args]);
-    });
-    facade.on = () => facade;
-    facade.off = () => facade;
-    return facade;
-}
-function inkInput(input, initialInput) {
-    const productionInput = typeof input.ref === "function" && typeof input.unref === "function";
-    // Isolate Ink's listeners on a bridge so every editor exit can detach the
-    // one listener it owns from the operator's terminal. Older injected FleetIO
-    // streams can arrive as decoded keypress events, while real TTYs forward raw
-    // data and leave decoding entirely to Ink.
-    const stream = new PassThrough();
-    stream.isTTY = input.isTTY;
-    stream.setRawMode = input.setRawMode?.bind(input);
-    stream.ref = () => {
-        if (productionInput)
-            input.ref();
-        return stream;
-    };
-    stream.unref = () => {
-        if (productionInput)
-            input.unref();
-        return stream;
-    };
-    const queued = [...initialInput];
-    let active = true;
-    let scheduled;
-    const pump = () => {
-        scheduled = undefined;
-        if (!active)
-            return;
-        const next = queued.shift();
-        if (next === undefined)
-            return;
-        stream.write(next);
-        scheduled = setTimeout(pump, 0);
-    };
-    const onData = (chunk) => {
-        queued.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
-        scheduled ??= setTimeout(pump, 0);
-    };
-    const onKeypress = (sequence, key) => {
-        const token = key?.sequence ?? sequence;
-        if (token === undefined)
-            return;
-        queued.push(token);
-        scheduled ??= setTimeout(pump, 0);
-    };
-    if (productionInput) {
-        input.on("data", onData);
-    }
-    else {
-        emitKeypressEvents(input);
-        input.on("keypress", onKeypress);
-    }
-    input.resume();
-    if (queued.length > 0)
-        scheduled = setTimeout(pump, 0);
-    return {
-        stream: stream,
-        stop() {
-            active = false;
-            if (scheduled)
-                clearTimeout(scheduled);
-            if (productionInput)
-                input.off("data", onData);
-            else
-                input.off("keypress", onKeypress);
-            input.pause();
-            stream.end();
-        },
-    };
-}
 export function formatDoctorAge(ageMs) {
     if (ageMs === null)
         return "no probe data";
@@ -108,123 +23,147 @@ function splitSeat(seat) {
     const at = seat.indexOf(":");
     return { adapter: seat.slice(0, at), model: seat.slice(at + 1) };
 }
-export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, entry = "probe", initialJudge = "", judgeSeats = [], }) {
+export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, entry = "probe", initialJudge = "", judgeSeats = [], viewRows = Number.POSITIVE_INFINITY, frameColumns = 100, frameRows, }) {
     const { exit } = useApp();
-    const [screen, setScreen] = useState(entry === "presets" ? "modes" : "probe");
-    const screenRef = useRef(screen);
-    const [cursor, setCursor] = useState(0);
-    const cursorRef = useRef(cursor);
-    const denyRef = useRef(undefined);
-    denyRef.current ??= new Set(initialDenyAdapters);
-    const [denyAdapters, setDenyAdapters] = useState(() => new Set(initialDenyAdapters));
-    const denyModelsRef = useRef(undefined);
-    denyModelsRef.current ??= new Set(initialDenyModels);
-    const [denyModels, setDenyModels] = useState(() => new Set(initialDenyModels));
-    const classificationsRef = useRef([]);
-    const [, setClassificationRevision] = useState(0);
-    const modelGroupRef = useRef(0);
-    const [modelGroup, setModelGroup] = useState(0);
-    const modelCursorRef = useRef(0);
-    const [modelCursor, setModelCursor] = useState(0);
-    const modelIdRef = useRef("");
-    const [modelId, setModelId] = useState("");
-    const channelCursorRef = useRef(0);
-    const [channelCursor, setChannelCursor] = useState(0);
-    const channelByAdapterRef = useRef({});
-    const tierCursorRef = useRef(0);
-    const [tierCursor, setTierCursor] = useState(0);
-    const pendingClassificationRef = useRef(null);
-    const noteRef = useRef("");
-    const [note, setNote] = useState("");
-    const [notice, setNotice] = useState("");
-    const modeCursorRef = useRef(undefined);
-    modeCursorRef.current ??= Math.max(modeOptions.findIndex((option) => option.id === initialMode), 0);
-    const [modeCursor, setModeCursor] = useState(modeCursorRef.current);
-    const selectedModeRef = useRef(initialMode);
-    const mapRef = useRef(undefined);
-    mapRef.current ??= structuredClone(initialMap);
-    const [map, setMap] = useState(() => structuredClone(initialMap));
-    const shapeCursorRef = useRef(0);
-    const [shapeCursor, setShapeCursor] = useState(0);
-    const candidateCursorRef = useRef(0);
-    const [candidateCursor, setCandidateCursor] = useState(0);
-    const candidatesRef = useRef([]);
-    const preferCursorRef = useRef(0);
-    const [preferCursor, setPreferCursor] = useState(0);
-    const preferRowsRef = useRef([]);
-    const preferChainRef = useRef([]);
-    const [, setPreferRevision] = useState(0);
-    const steeringRef = useRef(undefined);
-    steeringRef.current ??= structuredClone(initialSteering);
-    const [steering, setSteering] = useState(() => structuredClone(initialSteering));
-    const steeringCursorRef = useRef(0);
-    const [steeringCursor, setSteeringCursor] = useState(0);
-    const steeringPickerRef = useRef("review");
-    const steeringRowsRef = useRef([]);
-    const steeringChainRef = useRef([]);
-    const steeringPickerCursorRef = useRef(0);
-    const [steeringPickerCursor, setSteeringPickerCursor] = useState(0);
-    const [, setSteeringPickerRevision] = useState(0);
-    const judgeCursorRef = useRef(0);
-    const [judgeCursor, setJudgeCursor] = useState(0);
-    const judgeSeatRef = useRef(null);
-    const [judgeSeat, setJudgeSeat] = useState(null);
-    const reviewRef = useRef(null);
-    const [review, setReview] = useState(null);
-    const doneRef = useRef(false);
-    // entry === "presets": the first modes visit is the preset pick (mode → review, custom → the
-    // full walk). Once custom is chosen this flips off and modes behaves exactly as in probe entry.
-    const presetPickRef = useRef(entry === "presets");
-    // type-to-search on the long lists — reset on every screen change (per-screen-visit filter)
-    const filterRef = useRef("");
-    const [filter, setFilter] = useState("");
-    const enabledModelGroups = () => modelGroups.filter((group) => !denyRef.current?.has(group.adapter));
-    const stagedMap = () => mapRef.current;
-    const currentModelRows = () => {
-        const group = enabledModelGroups()[modelGroupRef.current];
-        if (!group)
-            return [];
+    const [, setRevision] = useState(0);
+    const uiRef = useRef(null);
+    uiRef.current ??= {
+        focus: "list",
+        view: "models",
+        railAt: 0,
+        adapterAt: -1,
+        listAt: 0,
+        filter: "",
+        searching: false,
+        stash: null,
+        quitArmed: false,
+        showAll: false,
+        presetsSeen: false,
+        notice: "",
+        deny: new Set(initialDenyAdapters),
+        denyModels: new Set(initialDenyModels),
+        classifications: [],
+        selectedMode: initialMode,
+        map: structuredClone(initialMap),
+        steering: structuredClone(initialSteering),
+        judgeSeat: null,
+        channelByAdapter: {},
+        // v1.92: no entry opens an overlay at launch — the browser opens on the models view (fleet
+        // scoping first); the presets overlay raises on the first Shapes entry instead (below).
+        overlay: null,
+        done: false,
+    };
+    const ui = uiRef.current;
+    const bump = () => setRevision((revision) => revision + 1);
+    // OBS-521/OBS-522: one truth for "is there staged work" — the Esc/q loss guard, the header
+    // chip, and the empty-`w` notice all read it. Counts staged EDITS, not diff hunks.
+    const initialDenySet = new Set(initialDenyAdapters);
+    const initialDenyModelSet = new Set(initialDenyModels);
+    const stagedCount = () => {
+        let n = ui.classifications.length
+            + (ui.selectedMode !== initialMode ? 1 : 0)
+            + (ui.judgeSeat !== null ? 1 : 0);
+        for (const adapter of ui.deny)
+            if (!initialDenySet.has(adapter))
+                n += 1;
+        for (const adapter of initialDenySet)
+            if (!ui.deny.has(adapter))
+                n += 1;
+        for (const model of ui.denyModels)
+            if (!initialDenyModelSet.has(model))
+                n += 1;
+        for (const model of initialDenyModelSet)
+            if (!ui.denyModels.has(model))
+                n += 1;
+        for (const shape of new Set([...Object.keys(initialMap), ...Object.keys(ui.map)])) {
+            // {} ≡ absent: pin-then-auto leaves an empty entry that writes nothing — not staged work
+            if (JSON.stringify(initialMap[shape] ?? {}) !== JSON.stringify(ui.map[shape] ?? {}))
+                n += 1;
+        }
+        for (const key of STEERING_KEYS) {
+            if (JSON.stringify(ui.steering[key]) !== JSON.stringify(initialSteering[key]))
+                n += 1;
+        }
+        return n;
+    };
+    // ── derived data ───────────────────────────────────────────────────────────
+    const enabledGroups = () => modelGroups.filter((group) => !ui.deny.has(group.adapter));
+    const scopedGroups = () => {
+        if (ui.adapterAt === -1)
+            return enabledGroups();
+        const group = modelGroups[ui.adapterAt];
+        return group && !ui.deny.has(group.adapter) ? [group] : [];
+    };
+    const groupRows = (group) => {
         const rows = group.rows.map((row) => {
-            const staged = classificationsRef.current.find((classification) => classification.adapter === group.adapter && classification.model === row.model);
-            return staged ? { ...row, tier: staged.tier } : row;
+            const staged = ui.classifications.find((classification) => classification.adapter === group.adapter && classification.model === row.model);
+            return {
+                adapter: group.adapter,
+                model: row.model,
+                tier: staged?.tier ?? row.tier,
+                detectedAt: row.detectedAt,
+                suggestion: row.suggestion,
+                evidence: row.evidence,
+                channel: group.channel,
+                denied: ui.denyModels.has(`${group.adapter}:${row.model}`),
+            };
         });
         const known = new Set(rows.map((row) => row.model));
-        for (const staged of classificationsRef.current) {
+        for (const staged of ui.classifications) {
             if (staged.adapter === group.adapter && !known.has(staged.model)) {
-                rows.push({ model: staged.model, tier: staged.tier });
+                rows.push({
+                    adapter: group.adapter,
+                    model: staged.model,
+                    tier: staged.tier,
+                    channel: group.channel,
+                    denied: ui.denyModels.has(`${group.adapter}:${staged.model}`),
+                });
             }
         }
         return rows;
     };
-    // type-to-search over the long lists: plain case-insensitive substring on the row's visible
-    // label. Each filterable screen derives its rows through these so input and render agree.
-    const matches = (label, f = filterRef.current) => f === "" || label.toLowerCase().includes(f.toLowerCase());
-    const filteredModelRows = (f = filterRef.current) => currentModelRows().filter((row) => matches(row.model, f));
-    const filteredCandidates = (f = filterRef.current) => candidatesRef.current.filter((candidate) => matches(candidate.label, f));
-    const filteredSteeringRows = (f = filterRef.current) => steeringRowsRef.current.filter((option) => matches(option, f));
+    const matches = (label, f) => f === "" || label.toLowerCase().includes(f.toLowerCase());
+    // Operator directive 2026-08-13: retired shapes (dated snapshots, previews, non-worker SKUs,
+    // legacy families) hide by DEFAULT. `a` reveals them; a CLASSIFIED row is never hidden.
+    const modelRows = (f = ui.filter) => scopedGroups().flatMap(groupRows).filter((row) => matches(`${row.adapter}/${row.model}`, f)
+        && (ui.showAll || row.tier !== undefined || retiredModelReason(row.model) === null));
+    const hiddenModelCount = (f = ui.filter) => scopedGroups().flatMap(groupRows).filter((row) => matches(`${row.adapter}/${row.model}`, f)).length
+        - modelRows(f).length;
+    /** rail counts mirror the list's retired-hide (never the text filter) so numbers agree on screen */
+    const visibleCount = (scope) => {
+        const groups = scope === -1 ? enabledGroups() : (modelGroups[scope] ? [modelGroups[scope]] : []);
+        return groups.flatMap(groupRows)
+            .filter((row) => ui.showAll || row.tier !== undefined || retiredModelReason(row.model) === null).length;
+    };
+    // three preview callbacks share it in lockstep — the staged deny truth every preview ranks under
+    const stagedDeny = () => ({ adapters: [...ui.deny].sort(), models: [...ui.denyModels].sort() });
+    const shapeList = () => shapeRows(ui.selectedMode, ui.map, stagedDeny());
+    const steeringList = () => [
+        ...STEERING_KEYS.map((key) => ({
+            id: key,
+            label: `${key}.prefer  →  ${ui.steering[key]?.join(", ") ?? "(none)"}`,
+        })),
+        { id: "judge", label: `judge  →  ${ui.judgeSeat ?? (initialJudge ? `${initialJudge} (default)` : "(default)")}` },
+    ];
     const judgeKeepRow = initialJudge ? `(keep default)  ${initialJudge}` : "(keep default)";
-    const filteredJudgeRows = (f = filterRef.current) => [judgeKeepRow, ...judgeSeats].filter((row) => matches(row, f));
-    // Shared filter-edit tail for the filterable screens: hotkeys run first in each screen block,
-    // whatever printable input is left appends here (space stays a toggle key, never a filter char).
-    const filterInput = (countFor, cursorRef, setCursorState, input, key) => {
-        // printable chars only: "\r" reaches here when an emptied list makes key.return a no-op
-        const printable = input > " " && !key.ctrl && !key.meta;
-        const next = key.backspace || key.delete
-            ? filterRef.current.slice(0, -1)
-            : (printable ? filterRef.current + input : null);
-        if (next === null)
-            return false;
-        filterRef.current = next;
-        setFilter(next);
-        const clamped = Math.min(cursorRef.current, Math.max(countFor(next) - 1, 0));
-        cursorRef.current = clamped;
-        setCursorState(clamped);
-        return true;
+    const listLength = () => {
+        if (ui.view === "models")
+            return modelRows().length;
+        if (ui.view === "shapes")
+            return shapeList().length;
+        return steeringList().length;
     };
+    const railRows = () => [
+        { kind: "view", view: "models", label: "All models", count: visibleCount(-1) },
+        { kind: "view", view: "shapes", label: "Shapes", count: shapeList().length },
+        { kind: "view", view: "steering", label: "Steering", count: STEERING_KEYS.length + 1 },
+        ...modelGroups.map((_, index) => ({ kind: "adapter", index })),
+    ];
+    // ── state transitions ──────────────────────────────────────────────────────
     const editorState = () => ({
-        denyAdapters: [...(denyRef.current ?? [])].sort(),
-        denyModels: [...(denyModelsRef.current ?? [])].sort(),
-        classifications: classificationsRef.current.map((classification) => classification.vendor && classification.channel
+        denyAdapters: [...ui.deny].sort(),
+        denyModels: [...ui.denyModels].sort(),
+        classifications: ui.classifications.map((classification) => classification.vendor && classification.channel
             ? {
                 ...classification,
                 note: fleetFirstTouchProvenance(classification.note, {
@@ -233,665 +172,1209 @@ export function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels
                 }),
             }
             : classification),
-        selectedMode: selectedModeRef.current,
-        map: stagedMap(),
-        ...(judgeSeatRef.current ? { judgeSeat: splitSeat(judgeSeatRef.current) } : {}),
-        steering: structuredClone(steeringRef.current),
+        selectedMode: ui.selectedMode,
+        map: ui.map,
+        ...(ui.judgeSeat ? { judgeSeat: splitSeat(ui.judgeSeat) } : {}),
+        steering: structuredClone(ui.steering),
     });
     const finish = (result) => {
-        if (doneRef.current)
+        if (ui.done)
             return;
-        doneRef.current = true;
+        ui.done = true;
         exit(result);
     };
-    const finishEditor = () => {
-        showScreen("steering");
-    };
-    const showScreen = (next) => {
-        filterRef.current = "";
-        setFilter("");
-        screenRef.current = next;
-        setScreen(next);
+    const setOverlay = (overlay) => {
+        // OBS-520: an overlay borrows ui.filter for its own search box — stash the browser's committed
+        // filter on open and restore it on close, so finishing an assignment/classification does not
+        // dump the operator back at the top of an unfiltered list.
+        if (ui.overlay === null && overlay !== null)
+            ui.stash = { filter: ui.filter };
+        ui.overlay = overlay;
+        if (overlay === null) {
+            ui.filter = ui.stash?.filter ?? "";
+            ui.stash = null;
+        }
+        else {
+            ui.filter = "";
+        }
+        ui.searching = false;
+        ui.notice = "";
+        bump();
     };
     // The one review funnel: an empty staged overlay finishes as no-changes, a real diff shows the
-    // confirm screen. Reached from the steering enter and, in preset entry, from a mode pick.
+    // confirm overlay. Reached from `w` and, in preset entry, from a preset pick.
     const goReview = () => {
         const nextReview = reviewOverlay(editorState());
         if (nextReview.kind === "empty") {
             finish({ kind: "no-changes" });
             return;
         }
-        reviewRef.current = nextReview;
-        setReview(reviewRef.current);
-        setNotice("");
-        showScreen("review");
+        setOverlay({ kind: "review", review: nextReview, scroll: 0 });
     };
-    const beginClassification = (group, model) => {
-        tierCursorRef.current = 0;
-        setTierCursor(0);
-        const firstTouch = !group.rows.some((row) => row.tier !== undefined);
-        const pending = {
-            adapter: group.adapter,
+    const stageSuggested = (adapter, rows, firstTouch) => {
+        ui.classifications = [
+            ...ui.classifications,
+            ...rows.map((row) => ({
+                adapter,
+                model: row.model,
+                tier: row.suggestion.tier,
+                note: row.suggestion.note,
+                ...firstTouch,
+            })),
+        ];
+        ui.notice = `staged ${rows.length} catalog-suggested classification(s) — nothing writes before the review diff`;
+        bump();
+    };
+    const groupOf = (adapter) => modelGroups.find((group) => group.adapter === adapter);
+    const beginClassification = (adapter, model) => {
+        const group = groupOf(adapter);
+        if (!group)
+            return;
+        // OBS-508: catalog evidence prefills the flow — the tier cursor lands on the suggested band and
+        // (when the operator keeps that band) the provenance note arrives pre-typed. Free to override.
+        const suggestion = group.rows.find((row) => row.model === model)?.suggestion ?? null;
+        const tierAt = suggestion ? Math.max(TIERS.indexOf(suggestion.tier), 0) : 0;
+        const firstTouch = !group.rows.some((row) => row.tier !== undefined)
+            && !ui.classifications.some((c) => c.adapter === adapter);
+        const base = {
+            kind: "classify",
+            adapter,
             model,
-            tier: TIERS[0],
+            channelAt: 0,
+            tierAt,
+            note: "",
+            suggestion,
         };
         if (!firstTouch) {
-            pendingClassificationRef.current = pending;
-            showScreen("tiers");
+            setOverlay({ ...base, stage: "tier" });
             return;
         }
         if (!group.vendor) {
-            setNotice(`fleet: ${group.adapter} has no vendor declaration — classification cannot be saved`);
+            ui.notice = `${adapter} has no vendor declaration — classification cannot be saved`;
+            bump();
             return;
         }
-        pending.vendor = group.vendor;
-        const answered = channelByAdapterRef.current[group.adapter];
+        const answered = ui.channelByAdapter[adapter];
         if (answered) {
-            pending.channel = answered;
-            pendingClassificationRef.current = pending;
-            showScreen("tiers");
+            setOverlay({ ...base, stage: "tier", vendor: group.vendor });
             return;
         }
-        pendingClassificationRef.current = pending;
-        channelCursorRef.current = 0;
-        setChannelCursor(0);
-        setNotice("");
-        showScreen("channel");
+        setOverlay({ ...base, stage: "channel", vendor: group.vendor });
     };
-    useInput((input, key) => {
-        if (doneRef.current)
-            return;
-        if (key.escape && (screenRef.current === "candidates" || screenRef.current === "shape-prefer")) {
-            showScreen("shapes");
-            return;
-        }
-        if (key.escape && (screenRef.current === "steering-prefer" || screenRef.current === "judge-pick")) {
-            showScreen("steering");
-            return;
-        }
-        if (key.escape && screenRef.current === "add-model") {
-            setNotice("");
-            showScreen("models");
-            return;
-        }
-        // v1.90.8 (operator field report): inside the init journey, one Esc must never discard the
-        // whole walk — from any walk screen it returns HOME to the presets screen; Esc there (or
-        // `q`/ctrl+c anywhere) remains the real quit. Sub-screen Escs above keep their tighter backs.
-        if (key.escape && entry === "presets" && screenRef.current !== "modes") {
-            setReview(null);
-            presetPickRef.current = true;
-            showScreen("modes");
-            return;
-        }
-        const typing = screenRef.current === "provenance" || screenRef.current === "add-model";
-        if (key.escape || (!typing && input === "q") || (key.ctrl && input === "c")) {
+    const applyClassification = (overlay) => {
+        const answered = overlay.vendor ? ui.channelByAdapter[overlay.adapter] : undefined;
+        ui.classifications = [
+            ...ui.classifications,
+            {
+                adapter: overlay.adapter,
+                model: overlay.model,
+                tier: TIERS[overlay.tierAt],
+                note: overlay.note.trim(),
+                ...(overlay.vendor && answered ? { vendor: overlay.vendor, channel: answered } : {}),
+            },
+        ];
+        setOverlay(null);
+    };
+    const clampList = () => {
+        ui.listAt = Math.min(ui.listAt, Math.max(listLength() - 1, 0));
+    };
+    // ── sizing (shared by the input handler and the render below) ──────────────
+    const width = Math.max(72, Math.min(frameColumns, 160));
+    const RAIL_W = 24;
+    const bodyW = width - RAIL_W - 5; // borders + padding
+    // OBS-523: reserve what the chrome actually uses — header 1, outer borders 2, padding 1,
+    // scope+search 2, elision marks 2, detail lines ≤2, keybar 1 — not 16. Six list rows were
+    // blank at every terminal size.
+    const capacity = Number.isFinite(viewRows) ? Math.max(4, viewRows) : Number.POSITIVE_INFINITY;
+    /** review diff rows: overlay chrome is one row shorter than the browser's (no scope header) */
+    const reviewCapacity = () => Number.isFinite(capacity) ? Math.min(Math.max(capacity + 1, 4), 400) : 400;
+    const reviewWindow = (overlay) => {
+        const lines = overlay.review.diff.split("\n");
+        const cap = reviewCapacity();
+        const maxScroll = Math.max(lines.length - cap, 0);
+        const scroll = Math.min(Math.max(overlay.scroll, 0), maxScroll);
+        return { lines, cap, maxScroll, scroll, visible: lines.slice(scroll, scroll + cap) };
+    };
+    // OBS-521: quitting with staged edits needs a second Esc/q — armed by the first press,
+    // disarmed by any other key. Ctrl+C stays an immediate exit.
+    const guardedQuit = (armed) => {
+        const staged = stagedCount();
+        if (staged === 0 || armed) {
             finish({ kind: "quit" });
-            return;
+            return true;
         }
-        if (screenRef.current === "probe") {
-            if (input === "r") {
-                finish({ kind: "refresh" });
-            }
-            else if (key.return) {
-                showScreen("agents");
-            }
+        ui.quitArmed = true;
+        ui.notice = `${staged} staged edit(s) not written — w reviews the diff · press again to discard and quit`;
+        bump();
+        return false;
+    };
+    // ── input ──────────────────────────────────────────────────────────────────
+    useInput((input, key) => {
+        if (ui.done)
             return;
-        }
-        if (screenRef.current === "agents") {
-            if (key.downArrow || input === "j") {
-                const next = Math.min(cursorRef.current + 1, Math.max(agents.length - 1, 0));
-                cursorRef.current = next;
-                setCursor(next);
-                return;
-            }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(cursorRef.current - 1, 0);
-                cursorRef.current = next;
-                setCursor(next);
-                return;
-            }
-            if (input === " " && agents.length > 0) {
-                const next = new Set(denyRef.current);
-                const id = agents[cursorRef.current].id;
-                if (next.has(id))
-                    next.delete(id);
-                else
-                    next.add(id);
-                denyRef.current = next;
-                setDenyAdapters(next);
-                return;
-            }
-            if (key.return) {
-                if (enabledModelGroups().length === 0)
-                    showScreen("modes");
-                else
-                    showScreen("models");
-            }
+        if (key.ctrl && input === "c") {
+            finish({ kind: "quit" });
             return;
         }
-        if (screenRef.current === "models") {
-            const rows = filteredModelRows();
-            if (key.downArrow || input === "j") {
-                const next = Math.min(modelCursorRef.current + 1, Math.max(rows.length - 1, 0));
-                modelCursorRef.current = next;
-                setModelCursor(next);
-                setNotice("");
+        const armed = ui.quitArmed;
+        ui.quitArmed = false;
+        const overlay = ui.overlay;
+        // Search is an EXPLICIT, visible mode: "/" enters it, Enter commits (filter stays applied),
+        // Esc cancels. While it is on, every printable char belongs to the search box so "kimi" or
+        // "fake-n" can actually be typed; outside it letters are ALWAYS commands — even with a
+        // committed filter applied. The old implicit rule (hotkeys dormant whenever the filter was
+        // non-empty) confused both directions in the field: the first letter of a query fired
+        // commands, and a live filter silently ate m/w/j/k. (operator field sessions, 2026-08-13
+        // and 2026-08-15)
+        const hotkey = ui.searching ? "" : input;
+        // filter editing shared by the searchable surfaces
+        const editFilter = (count, clampAt) => {
+            // a LEADING "/" is the browser's search affordance, not query text — swallow it so the
+            // muscle memory "/kimi" works in every searchable overlay too (no channel id starts with /).
+            // A real terminal may deliver fast typing or a paste as ONE keypress chunk ("/kimi"), so the
+            // strip handles the chunk form as well as the lone key. A pasted chunk may also carry a
+            // trailing newline ("glm-5.3\r") — control bytes are terminal framing, never query text;
+            // left in, they made every row "not match" until the operator retyped the query by hand.
+            const chunk = ui.filter === "" && input.startsWith("/") ? input.slice(1) : input;
+            const typed = chunk.replace(/[\u0000-\u001f\u007f]/g, "");
+            if (typed === "" && input.startsWith("/"))
+                return true;
+            const printable = typed > " " && !key.ctrl && !key.meta;
+            const next = key.backspace || key.delete
+                ? ui.filter.slice(0, -1)
+                : (printable ? ui.filter + typed : null);
+            if (next === null)
+                return false;
+            ui.filter = next;
+            // OBS-520: the clamp targets the surface being filtered — an overlay clamps ITS cursor,
+            // never the browser's listAt (typing in a picker used to drag the shapes cursor to row 0).
+            const max = Math.max(count(next) - 1, 0);
+            if (clampAt)
+                clampAt(max);
+            else
+                ui.listAt = Math.min(ui.listAt, max);
+            ui.notice = "";
+            bump();
+            return true;
+        };
+        if (overlay) {
+            if (overlay.kind === "presets") {
+                const rowCount = modeOptions.length + (overlay.home ? 1 : 0);
+                if (key.escape) {
+                    if (overlay.home) {
+                        guardedQuit(armed);
+                        return;
+                    }
+                    setOverlay(null);
+                    return;
+                }
+                if (hotkey === "q") {
+                    guardedQuit(armed);
+                    return;
+                }
+                if (key.downArrow || hotkey === "j") {
+                    overlay.at = Math.min(overlay.at + 1, rowCount - 1);
+                    bump();
+                    return;
+                }
+                if (key.upArrow || hotkey === "k") {
+                    overlay.at = Math.max(overlay.at - 1, 0);
+                    bump();
+                    return;
+                }
+                if (key.return) {
+                    if (overlay.home && overlay.at === modeOptions.length) {
+                        setOverlay(null); // custom → the browser IS the full editor
+                        return;
+                    }
+                    const option = modeOptions[overlay.at];
+                    if (!option)
+                        return;
+                    ui.selectedMode = option.id;
+                    if (overlay.home) {
+                        goReview(); // entry context: a preset pick goes straight to the diff confirm
+                        return;
+                    }
+                    setOverlay(null);
+                }
                 return;
             }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(modelCursorRef.current - 1, 0);
-                modelCursorRef.current = next;
-                setModelCursor(next);
-                setNotice("");
+            if (overlay.kind === "review") {
+                if (key.escape) {
+                    // non-destructive: back to the browser with everything still staged
+                    setOverlay(entry === "presets" ? { kind: "presets", at: 0, home: true } : null);
+                    return;
+                }
+                // OBS-524: the operator must be able to READ the whole diff they are approving —
+                // ↑↓/jk scroll a line, PgUp/PgDn a window; the elision rows carry the counts.
+                const window = reviewWindow(overlay);
+                if (key.downArrow || input === "j") {
+                    overlay.scroll = Math.min(window.scroll + 1, window.maxScroll);
+                    bump();
+                    return;
+                }
+                if (key.upArrow || input === "k") {
+                    overlay.scroll = Math.max(window.scroll - 1, 0);
+                    bump();
+                    return;
+                }
+                if (key.pageDown) {
+                    overlay.scroll = Math.min(window.scroll + window.cap, window.maxScroll);
+                    bump();
+                    return;
+                }
+                if (key.pageUp) {
+                    overlay.scroll = Math.max(window.scroll - window.cap, 0);
+                    bump();
+                    return;
+                }
+                if (input === "n") {
+                    finish({ kind: "discard" });
+                    return;
+                }
+                if (input === "q") {
+                    finish({ kind: "quit" });
+                    return;
+                }
+                if (input === "y") {
+                    const loadError = reloadGuard(overlay.review.after);
+                    if (loadError) {
+                        setOverlay(null);
+                        ui.notice = `config loader rejects the proposed overlay — ${loadError}`;
+                        bump();
+                        return;
+                    }
+                    finish({ kind: "write", review: overlay.review });
+                }
                 return;
             }
-            const group = enabledModelGroups()[modelGroupRef.current];
-            const row = rows[modelCursorRef.current];
-            if (input === " " && group && row?.tier) {
-                const id = `${group.adapter}:${row.model}`;
-                const next = new Set(denyModelsRef.current);
-                if (next.has(id))
-                    next.delete(id);
-                else
-                    next.add(id);
-                denyModelsRef.current = next;
-                setDenyModels(next);
+            if (overlay.kind === "classify") {
+                if (key.escape) {
+                    setOverlay(null);
+                    return;
+                }
+                if (overlay.stage === "channel") {
+                    if (key.downArrow || input === "j") {
+                        overlay.channelAt = Math.min(overlay.channelAt + 1, CHANNELS.length - 1);
+                        bump();
+                        return;
+                    }
+                    if (key.upArrow || input === "k") {
+                        overlay.channelAt = Math.max(overlay.channelAt - 1, 0);
+                        bump();
+                        return;
+                    }
+                    if (key.return) {
+                        const channel = CHANNELS[overlay.channelAt];
+                        ui.channelByAdapter[overlay.adapter] = channel;
+                        // OBS-508: a bulk stage waiting on the one first-touch channel answer resumes here.
+                        if (overlay.bulk) {
+                            stageSuggested(overlay.bulk.adapter, overlay.bulk.rows, { vendor: overlay.bulk.vendor, channel });
+                            const notice = ui.notice;
+                            setOverlay(null);
+                            ui.notice = notice;
+                            bump();
+                            return;
+                        }
+                        overlay.stage = "tier";
+                        bump();
+                    }
+                    return;
+                }
+                if (overlay.stage === "tier") {
+                    if (key.downArrow || input === "j") {
+                        overlay.tierAt = Math.min(overlay.tierAt + 1, TIERS.length - 1);
+                        bump();
+                        return;
+                    }
+                    if (key.upArrow || input === "k") {
+                        overlay.tierAt = Math.max(overlay.tierAt - 1, 0);
+                        bump();
+                        return;
+                    }
+                    if (key.return) {
+                        // OBS-508: keep the suggested band → the evidence note arrives pre-typed; override the
+                        // band → the note starts empty (the suggestion argues for a DIFFERENT tier).
+                        const chosen = TIERS[overlay.tierAt];
+                        overlay.note = overlay.suggestion && overlay.suggestion.tier === chosen ? overlay.suggestion.note : "";
+                        overlay.stage = "note";
+                        bump();
+                    }
+                    return;
+                }
+                // note stage — free text
+                if (key.return) {
+                    if (!overlay.note.trim()) {
+                        ui.notice = "a typed benchmark-provenance note is required";
+                        bump();
+                        return;
+                    }
+                    applyClassification(overlay);
+                    return;
+                }
+                if (key.backspace || key.delete) {
+                    overlay.note = overlay.note.slice(0, -1);
+                    bump();
+                    return;
+                }
+                if (input && !key.ctrl && !key.meta) {
+                    overlay.note += input;
+                    ui.notice = "";
+                    bump();
+                }
                 return;
             }
-            if (input === "t" && group && row) {
-                if (row.tier) {
-                    setNotice("fleet: tier reassignment on classified models is not supported in v1 — edit config directly");
+            if (overlay.kind === "add-model") {
+                if (key.escape) {
+                    setOverlay(null);
+                    return;
+                }
+                if (key.return) {
+                    const candidate = overlay.text;
+                    if (!MODEL_ID_RE.test(candidate)) {
+                        ui.notice = `model id must match ${MODEL_ID_RE.source}`;
+                        bump();
+                        return;
+                    }
+                    const group = groupOf(overlay.adapter);
+                    const exists = group
+                        && groupRows(group).some((row) => row.model === candidate);
+                    if (exists) {
+                        ui.notice = `${candidate} is already listed for ${overlay.adapter}`;
+                        bump();
+                        return;
+                    }
+                    beginClassification(overlay.adapter, candidate);
+                    return;
+                }
+                if (key.backspace || key.delete) {
+                    overlay.text = overlay.text.slice(0, -1);
+                    bump();
                     return;
                 }
-                beginClassification(group, row.model);
+                if (input && !key.ctrl && !key.meta) {
+                    overlay.text += input;
+                    ui.notice = "";
+                    bump();
+                }
                 return;
             }
-            if (input === "n" && group) {
-                modelIdRef.current = "";
-                setModelId("");
-                setNotice("");
-                showScreen("add-model");
+            if (overlay.kind === "assign") {
+                const rows = shapeList();
+                if (key.escape) {
+                    setOverlay(null);
+                    return;
+                }
+                if (key.downArrow || input === "j") {
+                    overlay.at = Math.min(overlay.at + 1, Math.max(rows.length - 1, 0));
+                    bump();
+                    return;
+                }
+                if (key.upArrow || input === "k") {
+                    overlay.at = Math.max(overlay.at - 1, 0);
+                    bump();
+                    return;
+                }
+                if (key.return && rows[overlay.at]) {
+                    const shape = rows[overlay.at].id;
+                    ui.map = { ...ui.map, [shape]: { pin: { via: overlay.adapter, model: overlay.model } } };
+                    setOverlay(null);
+                    ui.notice = `pinned ${shape} → ${overlay.adapter}:${overlay.model}`;
+                    bump();
+                }
                 return;
             }
-            if (key.return) {
-                if (modelGroupRef.current + 1 < enabledModelGroups().length) {
-                    const next = modelGroupRef.current + 1;
-                    modelGroupRef.current = next;
-                    setModelGroup(next);
-                    modelCursorRef.current = 0;
-                    setModelCursor(0);
-                    filterRef.current = "";
-                    setFilter("");
+            if (overlay.kind === "candidates") {
+                const rows = overlay.rows.filter((candidate) => matches(candidate.label, ui.filter));
+                if (key.escape) {
+                    setOverlay(null);
+                    return;
                 }
-                else {
-                    showScreen("modes");
+                if (key.downArrow) {
+                    overlay.at = Math.min(overlay.at + 1, Math.max(rows.length - 1, 0));
+                    bump();
+                    return;
+                }
+                if (key.upArrow) {
+                    overlay.at = Math.max(overlay.at - 1, 0);
+                    bump();
+                    return;
+                }
+                if (input === " " && rows[overlay.at]) {
+                    const id = rows[overlay.at].id;
+                    const at = overlay.chain.indexOf(id);
+                    if (at === -1)
+                        overlay.chain.push(id);
+                    else
+                        overlay.chain.splice(at, 1);
+                    bump();
+                    return;
+                }
+                if (key.return) {
+                    if (overlay.chain.length) {
+                        // a selection is a POOL, and its mode is a decision, not a default — the tiny
+                        // poolmode overlay asks it; Esc there restores this picker with the chain intact
+                        // OBS-525: an existing pool's mode seeds the cursor so a round-trip keeps it
+                        setOverlay({ kind: "poolmode", picker: overlay, at: ui.map[overlay.shape]?.pool?.mode === "ordered" ? 1 : 0 });
+                        return;
+                    }
+                    if (rows[overlay.at]) {
+                        ui.map = { ...ui.map, [overlay.shape]: { pin: rows[overlay.at].pin } };
+                        setOverlay(null);
+                        return;
+                    }
+                    return;
                 }
+                editFilter((f) => overlay.rows.filter((candidate) => matches(candidate.label, f)).length, (max) => {
+                    overlay.at = Math.min(overlay.at, max);
+                });
                 return;
             }
-            if (filterInput((f) => filteredModelRows(f).length, modelCursorRef, setModelCursor, input, key)) {
-                setNotice("");
-            }
-            return;
-        }
-        if (screenRef.current === "add-model") {
-            if (key.return) {
-                const group = enabledModelGroups()[modelGroupRef.current];
-                const candidate = modelIdRef.current;
-                if (!MODEL_ID_RE.test(candidate)) {
-                    setNotice(`fleet: model id must match ${MODEL_ID_RE.source}`);
+            if (overlay.kind === "poolmode") {
+                if (key.escape) {
+                    setOverlay(overlay.picker); // back to the picker — chain and cursor intact
                     return;
                 }
-                if (currentModelRows().some((row) => row.model === candidate)) {
-                    setNotice(`fleet: ${candidate} is already listed for ${group?.adapter ?? "this adapter"}`);
+                if (key.downArrow || input === "j") {
+                    overlay.at = 1;
+                    bump();
                     return;
                 }
-                if (group)
-                    beginClassification(group, candidate);
+                if (key.upArrow || input === "k") {
+                    overlay.at = 0;
+                    bump();
+                    return;
+                }
+                if (key.return) {
+                    const { shape, chain } = overlay.picker;
+                    // a pool is the shape's WHOLE declaration: pin and prefer leave with it (schema
+                    // exclusivity — pin+pool and pool+prefer both fail config load)
+                    const { pin: _pin, prefer: _prefer, pool: _pool, ...entry } = ui.map[shape] ?? {};
+                    ui.map = {
+                        ...ui.map,
+                        [shape]: { ...entry, pool: { mode: overlay.at === 0 ? "any" : "ordered", channels: chain.slice() } },
+                    };
+                    setOverlay(null);
+                }
                 return;
             }
-            if (key.backspace || key.delete) {
-                const next = modelIdRef.current.slice(0, -1);
-                modelIdRef.current = next;
-                setModelId(next);
+            if (overlay.kind === "prefer") {
+                const rows = overlay.rows.filter((option) => matches(option, ui.filter));
+                if (key.escape) {
+                    setOverlay(null);
+                    return;
+                }
+                if (key.downArrow) {
+                    overlay.at = Math.min(overlay.at + 1, Math.max(rows.length - 1, 0));
+                    bump();
+                    return;
+                }
+                if (key.upArrow) {
+                    overlay.at = Math.max(overlay.at - 1, 0);
+                    bump();
+                    return;
+                }
+                if (input === " " && rows[overlay.at]) {
+                    const option = rows[overlay.at];
+                    const at = overlay.chain.indexOf(option);
+                    if (at === -1)
+                        overlay.chain.push(option);
+                    else
+                        overlay.chain.splice(at, 1);
+                    bump();
+                    return;
+                }
+                if (key.return) {
+                    if ("shape" in overlay.target) {
+                        const shape = overlay.target.shape;
+                        const nextEntry = { ...ui.map[shape] };
+                        if (overlay.chain.length)
+                            nextEntry.prefer = overlay.chain.slice();
+                        else
+                            delete nextEntry.prefer;
+                        ui.map = { ...ui.map, [shape]: nextEntry };
+                    }
+                    else {
+                        ui.steering = {
+                            ...ui.steering,
+                            [overlay.target.steering]: overlay.chain.length ? overlay.chain.slice() : undefined,
+                        };
+                    }
+                    setOverlay(null);
+                    return;
+                }
+                editFilter((f) => overlay.rows.filter((option) => matches(option, f)).length, (max) => {
+                    overlay.at = Math.min(overlay.at, max);
+                });
                 return;
             }
-            if (input && !key.ctrl && !key.meta) {
-                const next = modelIdRef.current + input;
-                modelIdRef.current = next;
-                setModelId(next);
-                setNotice("");
-            }
-            return;
-        }
-        if (screenRef.current === "channel") {
-            if (key.downArrow || input === "j") {
-                const next = Math.min(channelCursorRef.current + 1, CHANNELS.length - 1);
-                channelCursorRef.current = next;
-                setChannelCursor(next);
+            // judge overlay
+            const rows = [judgeKeepRow, ...judgeSeats].filter((row) => matches(row, ui.filter));
+            if (key.escape) {
+                setOverlay(null);
                 return;
             }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(channelCursorRef.current - 1, 0);
-                channelCursorRef.current = next;
-                setChannelCursor(next);
+            if (key.downArrow) {
+                overlay.at = Math.min(overlay.at + 1, Math.max(rows.length - 1, 0));
+                bump();
                 return;
             }
-            if (key.return && pendingClassificationRef.current) {
-                const channel = CHANNELS[channelCursorRef.current];
-                channelByAdapterRef.current[pendingClassificationRef.current.adapter] = channel;
-                pendingClassificationRef.current.channel = channel;
-                showScreen("tiers");
-            }
-            return;
-        }
-        if (screenRef.current === "tiers") {
-            if (key.downArrow || input === "j") {
-                const next = Math.min(tierCursorRef.current + 1, TIERS.length - 1);
-                tierCursorRef.current = next;
-                setTierCursor(next);
+            if (key.upArrow) {
+                overlay.at = Math.max(overlay.at - 1, 0);
+                bump();
                 return;
             }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(tierCursorRef.current - 1, 0);
-                tierCursorRef.current = next;
-                setTierCursor(next);
+            if (key.return && rows[overlay.at]) {
+                // single-select: one seat or back to the config default — never a chain
+                const picked = rows[overlay.at];
+                ui.judgeSeat = picked === judgeKeepRow ? null : picked;
+                setOverlay(null);
                 return;
             }
-            if (key.return && pendingClassificationRef.current) {
-                pendingClassificationRef.current.tier = TIERS[tierCursorRef.current];
-                noteRef.current = "";
-                setNote("");
-                setNotice("");
-                showScreen("provenance");
-            }
+            editFilter((f) => [judgeKeepRow, ...judgeSeats].filter((row) => matches(row, f)).length, (max) => {
+                overlay.at = Math.min(overlay.at, max);
+            });
             return;
         }
-        if (screenRef.current === "provenance") {
-            if (key.return) {
-                if (!noteRef.current.trim()) {
-                    setNotice("fleet: a typed benchmark-provenance note is required");
-                    return;
-                }
-                const pending = pendingClassificationRef.current;
-                if (pending) {
-                    const next = [...classificationsRef.current, { ...pending, note: noteRef.current.trim() }];
-                    classificationsRef.current = next;
-                    setClassificationRevision((revision) => revision + 1);
-                }
-                pendingClassificationRef.current = null;
-                setNotice("");
-                showScreen("models");
+        // ── browser (no overlay) ─────────────────────────────────────────────────
+        if (ui.searching) {
+            if (key.escape) {
+                ui.searching = false;
+                ui.filter = "";
+                bump();
                 return;
             }
-            if (key.backspace || key.delete) {
-                const next = noteRef.current.slice(0, -1);
-                noteRef.current = next;
-                setNote(next);
+            if (key.return) {
+                ui.searching = false;
+                bump();
                 return;
             }
-            if (input && !key.ctrl && !key.meta) {
-                const next = noteRef.current + input;
-                noteRef.current = next;
-                setNote(next);
-            }
-        }
-        if (screenRef.current === "modes") {
-            // preset entry adds one final `custom` row after the modes — the full-walk escape hatch
-            const rowCount = modeOptions.length + (presetPickRef.current ? 1 : 0);
-            const currentModeCursor = modeCursorRef.current ?? 0;
-            if (key.downArrow || input === "j") {
-                const next = Math.min(currentModeCursor + 1, Math.max(rowCount - 1, 0));
-                modeCursorRef.current = next;
-                setModeCursor(next);
+            if (key.downArrow) {
+                ui.listAt = Math.min(ui.listAt + 1, Math.max(listLength() - 1, 0));
+                bump();
                 return;
             }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(currentModeCursor - 1, 0);
-                modeCursorRef.current = next;
-                setModeCursor(next);
+            if (key.upArrow) {
+                ui.listAt = Math.max(ui.listAt - 1, 0);
+                bump();
                 return;
             }
-            if (key.return) {
-                if (presetPickRef.current && currentModeCursor === modeOptions.length) {
-                    presetPickRef.current = false;
-                    showScreen("agents");
-                    return;
-                }
-                if (!modeOptions[currentModeCursor])
-                    return;
-                selectedModeRef.current = modeOptions[currentModeCursor].id;
-                if (presetPickRef.current) {
-                    // entry context: a preset pick goes straight to the diff confirm
-                    goReview();
-                    return;
-                }
-                showScreen("shapes");
-            }
+            editFilter((f) => modelRows(f).length);
             return;
         }
-        if (screenRef.current === "shapes") {
-            const rows = shapeRows(selectedModeRef.current, stagedMap());
-            if (key.downArrow || input === "j") {
-                const next = Math.min(shapeCursorRef.current + 1, Math.max(rows.length - 1, 0));
-                shapeCursorRef.current = next;
-                setShapeCursor(next);
-                return;
-            }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(shapeCursorRef.current - 1, 0);
-                shapeCursorRef.current = next;
-                setShapeCursor(next);
+        if (key.escape) {
+            if (ui.filter !== "") {
+                ui.filter = "";
+                bump();
                 return;
             }
-            const shape = rows[shapeCursorRef.current]?.id;
-            if (input === "a" && shape) {
-                const nextEntry = { ...stagedMap()[shape] };
-                delete nextEntry.pin;
-                const nextMap = { ...stagedMap(), [shape]: nextEntry };
-                mapRef.current = nextMap;
-                setMap(nextMap);
+            // v1.90.8: inside the init journey one Esc must never discard the whole walk — it returns
+            // HOME to the presets overlay; Esc there (or q/ctrl+c anywhere) remains the real quit.
+            if (entry === "presets") {
+                setOverlay({ kind: "presets", at: Math.max(modeOptions.findIndex((option) => option.id === ui.selectedMode), 0), home: true });
                 return;
             }
-            if (input === "p" && shape) {
-                candidatesRef.current = candidatesForShape(shape, selectedModeRef.current, stagedMap());
-                candidateCursorRef.current = 0;
-                setCandidateCursor(0);
-                showScreen("candidates");
-                return;
-            }
-            if (input === "f" && shape) {
-                const current = stagedMap()[shape]?.prefer ?? [];
-                preferRowsRef.current = preferOptionsForShape(shape, current);
-                preferChainRef.current = current.slice();
-                preferCursorRef.current = 0;
-                setPreferCursor(0);
-                showScreen("shape-prefer");
-                return;
-            }
-            if (key.return)
-                finishEditor();
+            guardedQuit(armed);
             return;
         }
-        if (screenRef.current === "candidates") {
-            const rows = filteredCandidates();
-            if (key.downArrow || input === "j") {
-                const next = Math.min(candidateCursorRef.current + 1, Math.max(rows.length - 1, 0));
-                candidateCursorRef.current = next;
-                setCandidateCursor(next);
-                return;
-            }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(candidateCursorRef.current - 1, 0);
-                candidateCursorRef.current = next;
-                setCandidateCursor(next);
+        if (hotkey === "q") {
+            guardedQuit(armed);
+            return;
+        }
+        if (hotkey === "r") {
+            finish({ kind: "refresh" });
+            return;
+        }
+        if (hotkey === "w") {
+            // OBS-522: an empty `w` used to EXIT the editor as no-changes — a save key must never
+            // double as quit. Say there is nothing to write and stay.
+            if (stagedCount() === 0) {
+                ui.notice = "no staged edits — nothing to write (Esc quits)";
+                bump();
                 return;
             }
-            if (key.return && rows[candidateCursorRef.current]) {
-                const shape = shapeRows(selectedModeRef.current, stagedMap())[shapeCursorRef.current]?.id;
-                if (shape) {
-                    const picked = rows[candidateCursorRef.current];
-                    const nextMap = { ...stagedMap(), [shape]: { pin: picked.pin } };
-                    mapRef.current = nextMap;
-                    setMap(nextMap);
-                }
-                showScreen("shapes");
+            goReview();
+            return;
+        }
+        if (hotkey === "m") {
+            setOverlay({ kind: "presets", at: Math.max(modeOptions.findIndex((option) => option.id === ui.selectedMode), 0), home: false });
+            return;
+        }
+        if (hotkey === "/" || (hotkey.startsWith("/") && hotkey.length > 1)) {
+            if (ui.view !== "models") {
+                // the shapes and steering lists are 9/3 fixed rows — nothing to search; say where search
+                // lives instead of eating the key silently (operator field report, 2026-08-16)
+                ui.notice = "this list is not searchable — / searches the models view (All models or an adapter in the rail)";
+                bump();
                 return;
             }
-            filterInput((f) => filteredCandidates(f).length, candidateCursorRef, setCandidateCursor, input, key);
+            ui.searching = true;
+            ui.focus = "list";
+            ui.notice = "";
+            // fast typing or a paste arrives as one chunk ("/kimi") — the tail is the query; control
+            // bytes (a pasted trailing "\r") are framing, not query text
+            ui.filter = hotkey.slice(1).replace(/[\u0000-\u001f\u007f]/g, "");
+            ui.listAt = Math.min(ui.listAt, Math.max(modelRows(ui.filter).length - 1, 0));
+            bump();
+            return;
+        }
+        // focus moves
+        if (key.leftArrow || (key.tab && ui.focus === "list")) {
+            ui.focus = "rail";
+            bump();
             return;
         }
-        if (screenRef.current === "shape-prefer") {
-            if (key.downArrow || input === "j") {
-                const next = Math.min(preferCursorRef.current + 1, Math.max(preferRowsRef.current.length - 1, 0));
-                preferCursorRef.current = next;
-                setPreferCursor(next);
+        if (key.rightArrow || (key.tab && ui.focus === "rail")) {
+            ui.focus = "list";
+            bump();
+            return;
+        }
+        if (ui.focus === "rail") {
+            const rows = railRows();
+            if (key.downArrow || hotkey === "j") {
+                ui.railAt = Math.min(ui.railAt + 1, rows.length - 1);
+                bump();
                 return;
             }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(preferCursorRef.current - 1, 0);
-                preferCursorRef.current = next;
-                setPreferCursor(next);
+            if (key.upArrow || hotkey === "k") {
+                ui.railAt = Math.max(ui.railAt - 1, 0);
+                bump();
                 return;
             }
-            if (input === " " && preferRowsRef.current[preferCursorRef.current]) {
-                const option = preferRowsRef.current[preferCursorRef.current];
-                const at = preferChainRef.current.indexOf(option);
-                if (at === -1)
-                    preferChainRef.current.push(option);
+            const row = rows[ui.railAt];
+            if (!row)
+                return;
+            if (input === " " && row.kind === "adapter") {
+                const id = modelGroups[row.index].adapter;
+                // membership can't fix auth — say so, or the ✗ reads as a toggle that refuses to move
+                // (operator field report, 2026-08-16: expired kimi token)
+                if (agents.find((agent) => agent.id === id)?.authed === false) {
+                    ui.notice = `${id} is not authed — Space only toggles fleet membership; re-auth the ${id} CLI, then run tickmarkr doctor`;
+                }
+                const next = new Set(ui.deny);
+                if (next.has(id))
+                    next.delete(id);
                 else
-                    preferChainRef.current.splice(at, 1);
-                setPreferRevision((revision) => revision + 1);
+                    next.add(id);
+                ui.deny = next;
+                clampList();
+                bump();
                 return;
             }
             if (key.return) {
-                const shape = shapeRows(selectedModeRef.current, stagedMap())[shapeCursorRef.current]?.id;
-                if (shape) {
-                    const nextEntry = { ...stagedMap()[shape] };
-                    if (preferChainRef.current.length)
-                        nextEntry.prefer = preferChainRef.current.slice();
-                    else
-                        delete nextEntry.prefer;
-                    const nextMap = { ...stagedMap(), [shape]: nextEntry };
-                    mapRef.current = nextMap;
-                    setMap(nextMap);
+                if (row.kind === "view") {
+                    ui.view = row.view;
+                    if (row.view === "models")
+                        ui.adapterAt = -1;
+                }
+                else {
+                    ui.view = "models";
+                    ui.adapterAt = row.index;
                 }
-                showScreen("shapes");
+                ui.focus = "list";
+                ui.listAt = 0;
+                ui.filter = "";
+                ui.notice = "";
+                // v1.92: the FIRST Shapes entry per session raises the presets overlay (both entries:
+                // fleet and init) — Esc from it lands right here in the shapes list, never quits.
+                if (ui.view === "shapes" && !ui.presetsSeen) {
+                    ui.presetsSeen = true;
+                    ui.overlay = {
+                        kind: "presets",
+                        at: Math.max(modeOptions.findIndex((option) => option.id === ui.selectedMode), 0),
+                        home: false,
+                    };
+                }
+                bump();
             }
             return;
         }
-        if (screenRef.current === "steering") {
-            // review.prefer + consult.prefer rows plus the single judge seat as the final row
-            if (key.downArrow || input === "j") {
-                const next = Math.min(steeringCursorRef.current + 1, STEERING_KEYS.length);
-                steeringCursorRef.current = next;
-                setSteeringCursor(next);
+        // list focus
+        if (key.downArrow || hotkey === "j") {
+            ui.listAt = Math.min(ui.listAt + 1, Math.max(listLength() - 1, 0));
+            ui.notice = "";
+            bump();
+            return;
+        }
+        if (key.upArrow || hotkey === "k") {
+            ui.listAt = Math.max(ui.listAt - 1, 0);
+            ui.notice = "";
+            bump();
+            return;
+        }
+        if (ui.view === "models") {
+            const rows = modelRows();
+            const row = rows[ui.listAt];
+            if (input === " " && row) {
+                if (!row.tier) {
+                    // v1.90.9: an unclassified model has no tier to route on — selecting IS classifying,
+                    // so Space opens the same channel → tier → provenance flow instead of dying silently.
+                    beginClassification(row.adapter, row.model);
+                    return;
+                }
+                const id = `${row.adapter}:${row.model}`;
+                const next = new Set(ui.denyModels);
+                if (next.has(id))
+                    next.delete(id);
+                else
+                    next.add(id);
+                ui.denyModels = next;
+                bump();
                 return;
             }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(steeringCursorRef.current - 1, 0);
-                steeringCursorRef.current = next;
-                setSteeringCursor(next);
+            if (key.return && row) {
+                if (!row.tier) {
+                    beginClassification(row.adapter, row.model);
+                    return;
+                }
+                if (row.denied || ui.deny.has(row.adapter)) {
+                    ui.notice = `${row.adapter}:${row.model} is out of the fleet — Space adds it before assigning`;
+                    bump();
+                    return;
+                }
+                // model-centric assignment: Enter pins the model to a shape (omp: Enter assigns roles)
+                setOverlay({ kind: "assign", adapter: row.adapter, model: row.model, at: 0 });
                 return;
             }
-            if (input === "f") {
-                if (steeringCursorRef.current === STEERING_KEYS.length) {
-                    judgeCursorRef.current = 0;
-                    setJudgeCursor(0);
-                    setNotice("");
-                    showScreen("judge-pick");
+            if (hotkey === "t" && row) {
+                if (row.tier) {
+                    ui.notice = "tier reassignment on classified models is not supported in v1 — edit config directly";
+                    bump();
                     return;
                 }
-                const which = STEERING_KEYS[steeringCursorRef.current];
-                const current = steeringRef.current?.[which] ?? [];
-                steeringPickerRef.current = which;
-                steeringRowsRef.current = steeringOptionsFor(which, current);
-                steeringChainRef.current = current.slice();
-                steeringPickerCursorRef.current = 0;
-                setSteeringPickerCursor(0);
-                setNotice("");
-                showScreen("steering-prefer");
+                beginClassification(row.adapter, row.model);
                 return;
             }
-            if (key.return)
-                goReview();
-            return;
-        }
-        if (screenRef.current === "judge-pick") {
-            const rows = filteredJudgeRows();
-            if (key.downArrow || input === "j") {
-                const next = Math.min(judgeCursorRef.current + 1, Math.max(rows.length - 1, 0));
-                judgeCursorRef.current = next;
-                setJudgeCursor(next);
+            if (hotkey === "n") {
+                if (ui.adapterAt === -1) {
+                    ui.notice = "select an adapter in the rail first — n adds a model to one adapter";
+                    bump();
+                    return;
+                }
+                setOverlay({ kind: "add-model", adapter: modelGroups[ui.adapterAt].adapter, text: "" });
                 return;
             }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(judgeCursorRef.current - 1, 0);
-                judgeCursorRef.current = next;
-                setJudgeCursor(next);
+            if (hotkey === "s") {
+                // OBS-508: bulk-stage every VISIBLE unclassified model carrying a catalog suggestion —
+                // visible means the type-to-search filter and the retired-hide both scope the batch.
+                // Adapter-scoped: first-touch channel/vendor provenance is a per-adapter answer.
+                if (ui.adapterAt === -1) {
+                    ui.notice = "select an adapter in the rail first — s stages one adapter's suggestions";
+                    bump();
+                    return;
+                }
+                const group = modelGroups[ui.adapterAt];
+                const suggested = rows
+                    .filter((candidate) => candidate.adapter === group.adapter && !candidate.tier && candidate.suggestion !== undefined)
+                    .map((candidate) => ({ model: candidate.model, suggestion: candidate.suggestion }));
+                if (!suggested.length) {
+                    ui.notice = "no catalog tier suggestions among the visible unclassified models — evidence comes from the cached catalogs (AA index / API pricing)";
+                    bump();
+                    return;
+                }
+                const firstTouch = !group.rows.some((candidate) => candidate.tier !== undefined)
+                    && !ui.classifications.some((c) => c.adapter === group.adapter);
+                if (!firstTouch) {
+                    stageSuggested(group.adapter, suggested);
+                    return;
+                }
+                if (!group.vendor) {
+                    ui.notice = `${group.adapter} has no vendor declaration — classification cannot be saved`;
+                    bump();
+                    return;
+                }
+                const answered = ui.channelByAdapter[group.adapter];
+                if (answered) {
+                    stageSuggested(group.adapter, suggested, { vendor: group.vendor, channel: answered });
+                    return;
+                }
+                setOverlay({
+                    kind: "classify",
+                    adapter: group.adapter,
+                    model: "",
+                    vendor: group.vendor,
+                    stage: "channel",
+                    channelAt: 0,
+                    tierAt: 0,
+                    note: "",
+                    suggestion: null,
+                    bulk: { adapter: group.adapter, vendor: group.vendor, rows: suggested },
+                });
                 return;
             }
-            if (key.return && rows[judgeCursorRef.current]) {
-                // single-select: one seat or back to the config default — never a chain
-                const picked = rows[judgeCursorRef.current];
-                const seat = picked === judgeKeepRow ? null : picked;
-                judgeSeatRef.current = seat;
-                setJudgeSeat(seat);
-                showScreen("steering");
+            if (hotkey === "a") {
+                ui.showAll = !ui.showAll;
+                clampList();
+                bump();
                 return;
             }
-            filterInput((f) => filteredJudgeRows(f).length, judgeCursorRef, setJudgeCursor, input, key);
             return;
         }
-        if (screenRef.current === "steering-prefer") {
-            const rows = filteredSteeringRows();
-            if (key.downArrow || input === "j") {
-                const next = Math.min(steeringPickerCursorRef.current + 1, Math.max(rows.length - 1, 0));
-                steeringPickerCursorRef.current = next;
-                setSteeringPickerCursor(next);
+        if (ui.view === "shapes") {
+            const rows = shapeList();
+            const shape = rows[ui.listAt]?.id;
+            if (!shape)
                 return;
-            }
-            if (key.upArrow || input === "k") {
-                const next = Math.max(steeringPickerCursorRef.current - 1, 0);
-                steeringPickerCursorRef.current = next;
-                setSteeringPickerCursor(next);
+            if (hotkey === "a") {
+                // OBS-525: auto reverts the shape's WHOLE routing declaration — pool included, not just
+                // the pin. prefer survives: it biases auto routing and is valid without pin/pool.
+                const nextEntry = { ...ui.map[shape] };
+                delete nextEntry.pin;
+                delete nextEntry.pool;
+                ui.map = { ...ui.map, [shape]: nextEntry };
+                bump();
                 return;
             }
-            if (input === " " && rows[steeringPickerCursorRef.current]) {
-                const option = rows[steeringPickerCursorRef.current];
-                const at = steeringChainRef.current.indexOf(option);
-                if (at === -1)
-                    steeringChainRef.current.push(option);
-                else
-                    steeringChainRef.current.splice(at, 1);
-                setSteeringPickerRevision((revision) => revision + 1);
+            if (key.return || hotkey === "p") {
+                const picked = candidatesForShape(shape, ui.selectedMode, ui.map, stagedDeny());
+                setOverlay({
+                    kind: "candidates",
+                    shape,
+                    rows: picked.rows,
+                    excludedNote: picked.excludedNote,
+                    // OBS-525: an existing pool round-trips — reopening the picker starts from the staged
+                    // channels instead of an empty selection that would silently replace the pool with a pin.
+                    chain: ui.map[shape]?.pool?.channels.slice() ?? [],
+                    at: 0,
+                });
                 return;
             }
-            if (key.return) {
-                const which = steeringPickerRef.current;
-                const next = {
-                    ...steeringRef.current,
-                    [which]: steeringChainRef.current.length ? steeringChainRef.current.slice() : undefined,
-                };
-                steeringRef.current = next;
-                setSteering(next);
-                setNotice("");
-                showScreen("steering");
-                return;
-            }
-            filterInput((f) => filteredSteeringRows(f).length, steeringPickerCursorRef, setSteeringPickerCursor, input, key);
+            if (hotkey === "f") {
+                if (ui.map[shape]?.pool !== undefined) {
+                    // OBS-525: pool+prefer fails the config exclusivity refine — blocking here beats
+                    // staging an invalid combination the reload guard bounces at the very end.
+                    ui.notice = `${shape} routes a pool — prefer applies to auto/pin routing; press a (auto) first or re-pool via Enter`;
+                    bump();
+                    return;
+                }
+                const current = ui.map[shape]?.prefer ?? [];
+                setOverlay({
+                    kind: "prefer",
+                    target: { shape },
+                    rows: preferOptionsForShape(shape, current),
+                    chain: current.slice(),
+                    at: 0,
+                });
+            }
             return;
         }
-        if (screenRef.current === "review") {
-            if (input === "n") {
-                finish({ kind: "discard" });
+        // steering view
+        const rows = steeringList();
+        const row = rows[ui.listAt];
+        if (!row)
+            return;
+        if (key.return || hotkey === "f") {
+            if (row.id === "judge") {
+                setOverlay({ kind: "judge", at: 0 });
                 return;
             }
-            if (input === "y" && reviewRef.current) {
-                const loadError = reloadGuard(reviewRef.current.after);
-                if (loadError) {
-                    setNotice(`fleet: config loader rejects the proposed overlay — ${loadError}`);
-                    reviewRef.current = null;
-                    setReview(null);
-                    showScreen(presetPickRef.current ? "modes" : "steering");
-                    return;
+            const which = row.id;
+            const current = ui.steering[which] ?? [];
+            setOverlay({
+                kind: "prefer",
+                target: { steering: which },
+                rows: steeringOptionsFor(which, current),
+                chain: current.slice(),
+                at: 0,
+            });
+        }
+    });
+    // ── render ─────────────────────────────────────────────────────────────────
+    const tierCell = (row) => {
+        if (row.tier === "frontier")
+            return { text: "frontier", color: INK.brand };
+        if (row.tier === "mid")
+            return { text: "mid" };
+        if (row.tier === "cheap")
+            return { text: "cheap", dim: true };
+        if (row.suggestion)
+            return { text: `→ ${row.suggestion.tier}?`, dim: true };
+        return { text: "", dim: true };
+    };
+    const priceCell = (row) => {
+        const usd = fmtUsdPair(row.evidence?.inputCostPerMtok, row.evidence?.outputCostPerMtok);
+        if (row.channel === "sub")
+            return "sub";
+        return usd;
+    };
+    const modelDetail = (row) => {
+        const parts = [
+            `${row.adapter}:${row.model}`,
+            row.tier ?? "unclassified",
+            row.evidence?.unauthed !== undefined ? `UNAUTHED — ${row.evidence.unauthed}` : "",
+            row.evidence?.contextWindow !== undefined ? `${fmtCtx(row.evidence.contextWindow)} ctx` : "",
+            row.evidence?.outputWindow !== undefined ? `${fmtCtx(row.evidence.outputWindow)} out` : "",
+            row.evidence?.inputCostPerMtok !== undefined || row.evidence?.outputCostPerMtok !== undefined
+                ? `${fmtUsdPair(row.evidence?.inputCostPerMtok, row.evidence?.outputCostPerMtok)} per Mtok`
+                : (row.channel === "sub" ? "sub flat-rate quota" : ""),
+            row.evidence?.probeMs !== undefined ? `probed ${fmtMs(row.evidence.probeMs)}` : "",
+            row.detectedAt ? `detected ${row.detectedAt}` : "",
+        ].filter(Boolean);
+        return parts.join(" · ");
+    };
+    const renderModelRow = (row, selected) => {
+        const tier = tierCell(row);
+        const showProbe = bodyW >= 76;
+        const showPrice = bodyW >= 60;
+        // every cell accounted for: pointer 2 + glyph 1 + gap 1 + tier 11 + ctx 6 (+ price 12 + probe 7)
+        const nameW = bodyW - 4 - 11 - 6 - (showPrice ? 12 : 0) - (showProbe ? 7 : 0);
+        // OBS-531: deep router ids (omp/prime-agent) clip tail-preserving — the LAST segment is the
+        // distinguishing half; end-clipping rendered ten identical "prime-agent/anthropic/claude-…" rows.
+        const name = clipPathTail(`${row.adapter}/${row.model}`, nameW);
+        const prefixLen = Math.min(name.length, row.adapter.length + 1);
+        return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Pointer, { on: selected }), row.denied
+                    ? _jsx(Glyph, { kind: "off" })
+                    : row.evidence?.unauthed !== undefined
+                        ? _jsx(Glyph, { kind: "fail" })
+                        : row.tier
+                            ? _jsx(Glyph, { kind: "on" })
+                            : _jsx(Glyph, { kind: "unknown" }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: row.denied, children: [_jsx(Text, { dimColor: true, children: name.slice(0, prefixLen) }), _jsx(Text, { bold: selected, children: name.slice(prefixLen).padEnd(Math.max(nameW - prefixLen, 0)) })] }), _jsx(Text, { color: tier.color, dimColor: tier.dim, children: padCellStart(tier.text, 11) }), _jsx(Text, { dimColor: true, children: padCellStart(fmtCtx(row.evidence?.contextWindow), 6) }), showPrice && _jsx(Text, { dimColor: priceCell(row) === "sub", children: padCellStart(priceCell(row), 12) }), showProbe && _jsx(Text, { dimColor: true, children: padCellStart(fmtMs(row.evidence?.probeMs), 7) })] }, `${row.adapter}:${row.model}`));
+    };
+    const renderPlainRow = (id, label, selected, rowW = bodyW - 2) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Pointer, { on: selected }), _jsx(Text, { bold: selected, children: clip(label, rowW) })] }, id));
+    const renderShapeRow = (row, selected, rowW = bodyW - 2) => {
+        const prefix = `${row.id}  →  `;
+        const rest = row.label.startsWith(prefix) ? row.label.slice(prefix.length) : row.label;
+        // The provenance chip is the row's decision token (fleet --why parity) — it right-aligns and
+        // never truncates; the assignment text absorbs the clipping instead.
+        const marker = " · source: ";
+        const markerAt = rest.lastIndexOf(marker);
+        const body = markerAt === -1 ? rest : rest.slice(0, markerAt);
+        const source = markerAt === -1 ? "" : rest.slice(markerAt + marker.length);
+        const sourceCell = source ? `source: ${source}` : "";
+        const bodyW2 = rowW - 12 - (sourceCell ? sourceCell.length + 2 : 0);
+        return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Pointer, { on: selected }), _jsx(Text, { bold: selected, color: selected ? INK.brand : undefined, children: padCell(row.id, 10) }), _jsx(Text, { children: padCell(body, Math.max(bodyW2, 8)) }), sourceCell !== "" && _jsx(Text, { dimColor: true, children: `  ${sourceCell}` })] }, row.id));
+    };
+    const railView = (row, index) => {
+        const active = ui.view === row.view && (row.view !== "models" || ui.adapterAt === -1);
+        const selected = ui.focus === "rail" && ui.railAt === index;
+        return (_jsxs(Text, { children: [selected ? _jsx(Text, { color: INK.brand, children: "❯ " }) : _jsx(Text, { children: "  " }), _jsx(Text, { bold: active, color: active ? INK.brand : undefined, children: padCell(row.label, 13) }), _jsx(Text, { dimColor: true, children: padCellStart(String(row.count), 5) })] }, row.view));
+    };
+    const railAdapter = (index, railIndex) => {
+        const group = modelGroups[index];
+        const agent = agents.find((candidate) => candidate.id === group.adapter);
+        const denied = ui.deny.has(group.adapter);
+        const active = ui.view === "models" && ui.adapterAt === index;
+        const selected = ui.focus === "rail" && ui.railAt === railIndex;
+        return (_jsxs(Text, { children: [selected ? _jsx(Text, { color: INK.brand, children: "❯ " }) : _jsx(Text, { children: "  " }), denied ? _jsx(Glyph, { kind: "off" }) : agent?.authed === false ? _jsx(Glyph, { kind: "fail" }) : _jsx(Glyph, { kind: "on" }), _jsx(Text, { children: " " }), _jsx(Text, { bold: active, color: active ? INK.brand : undefined, dimColor: denied, children: padCell(group.adapter, 12) }), _jsx(Text, { dimColor: true, children: padCellStart(String(visibleCount(index)), 4) })] }, group.adapter));
+    };
+    const rail = railRows();
+    const overlayNode = (() => {
+        const overlay = ui.overlay;
+        if (!overlay)
+            return null;
+        if (overlay.kind === "presets") {
+            const details = modeOptions[overlay.at] ? modePreview(modeOptions[overlay.at].id, ui.map, stagedDeny()) : [];
+            return (_jsxs(OverlayPanel, { title: overlay.home ? "routing preset" : "routing mode", width: bodyW, children: [_jsx(Text, { dimColor: true, children: overlay.home ? "a preset routes every shape — custom opens the browser" : "floors move with the mode; the browser edits the rest" }), _jsx(Text, { children: " " }), modeOptions.map((option, index) => (_jsxs(Text, { children: [_jsx(Pointer, { on: overlay.at === index }), option.id === ui.selectedMode ? _jsx(Glyph, { kind: "on" }) : _jsx(Text, { children: " " }), _jsx(Text, { bold: overlay.at === index, children: ` ${padCell(option.id, 12)}` }), _jsx(Text, { dimColor: true, children: clip(option.gloss, bodyW - 20) })] }, option.id))), overlay.home && (_jsxs(Text, { children: [_jsx(Pointer, { on: overlay.at === modeOptions.length }), _jsx(Text, { children: " " }), _jsx(Text, { bold: overlay.at === modeOptions.length, children: ` ${padCell("custom", 12)}` }), _jsx(Text, { dimColor: true, children: clip("open the fleet browser (models · shapes · steering)", bodyW - 20) })] })), _jsx(Text, { children: " " }), details.map((line) => _jsx(Text, { dimColor: true, children: line }, line))] }));
+        }
+        if (overlay.kind === "review") {
+            const { visible, scroll, cap, lines } = reviewWindow(overlay);
+            const below = lines.length - scroll - visible.length;
+            return (_jsxs(OverlayPanel, { title: `review · ${overlay.review.path}`, width: bodyW, children: [_jsx(Text, { dimColor: true, wrap: "truncate", children: clip("everything staged lands in this one diff — y writes, n discards, ↑↓ scroll, Esc keeps editing", bodyW - 4) }), scroll > 0 && _jsx(ElisionMark, { count: scroll, side: "above" }), visible.map((line, index) => (_jsx(Text, { wrap: "truncate", color: line.startsWith("+") ? INK.brand : line.startsWith("-") ? INK.fail : undefined, dimColor: line.startsWith("@") || line.startsWith("---") || line.startsWith("+++"), children: clip(line, bodyW - 6) || " " }, `${scroll + index}:${line}`))), below > 0 && _jsx(ElisionMark, { count: below, side: "below", hint: `↓ scrolls · PgDn jumps ${cap} lines` })] }));
+        }
+        if (overlay.kind === "classify") {
+            const subject = overlay.bulk
+                ? `${overlay.adapter} · ${overlay.bulk.rows.length} suggested models`
+                : `${overlay.adapter}:${overlay.model}`;
+            return (_jsxs(OverlayPanel, { title: `classify · ${subject}`, width: bodyW, children: [overlay.stage === "channel" && (_jsxs(_Fragment, { children: [_jsxs(Text, { dimColor: true, children: ["first touch for ", overlay.adapter, " \u2014 how is this CLI billed?"] }), _jsx(Text, { children: " " }), CHANNELS.map((channel, index) => (_jsxs(Text, { children: [_jsx(Pointer, { on: overlay.channelAt === index }), _jsx(Text, { bold: overlay.channelAt === index, children: padCell(channel, 5) }), _jsx(Text, { dimColor: true, children: channel === "sub" ? "flat-rate subscription quota" : "metered API billing" })] }, channel)))] })), overlay.stage === "tier" && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: overlay.suggestion
+                                    ? `catalog suggests ${overlay.suggestion.tier} — keep it and the provenance note arrives pre-typed`
+                                    : "pick the capability band this model routes as" }), _jsx(Text, { children: " " }), TIERS.map((tier, index) => (_jsxs(Text, { children: [_jsx(Pointer, { on: overlay.tierAt === index }), overlay.suggestion?.tier === tier ? _jsx(Glyph, { kind: "on" }) : _jsx(Text, { children: " " }), _jsx(Text, { bold: overlay.tierAt === index, children: ` ${padCell(tier, 9)}` }), _jsx(Text, { dimColor: true, children: tier === "frontier" ? "strongest band — integrity shapes" : tier === "mid" ? "capable daily driver" : "fast + cheap" })] }, tier)))] })), overlay.stage === "note" && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "benchmark provenance (required) \u2014 where does this tier claim come from?" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: INK.brand, children: "> " }), _jsx(Text, { children: clip(overlay.note, bodyW - 6) || "" }), _jsx(Text, { color: INK.brand, children: "\u2588" })] })] }))] }));
+        }
+        if (overlay.kind === "add-model") {
+            return (_jsxs(OverlayPanel, { title: `add model · ${overlay.adapter}`, width: bodyW, children: [_jsx(Text, { dimColor: true, children: "type the model id exactly as the CLI names it" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: INK.brand, children: "> " }), _jsx(Text, { children: clip(overlay.text, bodyW - 6) }), _jsx(Text, { color: INK.brand, children: "\u2588" })] })] }));
+        }
+        if (overlay.kind === "assign") {
+            const rows = shapeList();
+            return (_jsxs(OverlayPanel, { title: `pin ${overlay.adapter}:${overlay.model} to a shape`, width: bodyW, children: [_jsx(Text, { dimColor: true, children: "Enter pins this model as the shape's route \u2014 a on the shape later reverts to auto" }), _jsx(Text, { children: " " }), rows.map((row, index) => renderShapeRow(row, overlay.at === index, bodyW - 8))] }));
+        }
+        if (overlay.kind === "candidates") {
+            const rows = overlay.rows.filter((candidate) => matches(candidate.label, ui.filter));
+            const { visible, start, above, below } = windowRows(rows, overlay.at, capacity);
+            const chained = overlay.chain.length > 0;
+            return (_jsxs(OverlayPanel, { title: chained ? `pool · ${overlay.shape}` : `pin · ${overlay.shape}`, width: bodyW, children: [_jsx(Text, { dimColor: true, wrap: "truncate", children: clip("Enter pins one channel · Space selects a pool in order — Enter then asks its mode (pool replaces pin)", bodyW - 4) }), _jsx(SearchRow, { filter: ui.filter, active: true }), overlay.excludedNote !== undefined
+                        && _jsx(Text, { dimColor: true, wrap: "truncate", children: clip(overlay.excludedNote, bodyW - 4) }), above > 0 && _jsx(ElisionMark, { count: above, side: "above" }), visible.map((candidate, index) => {
+                        const at = overlay.chain.indexOf(candidate.id);
+                        const selected = start + index === overlay.at;
+                        return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Pointer, { on: selected }), at === -1 ? _jsx(Text, { dimColor: true, children: "· " }) : _jsx(Text, { color: INK.brand, children: `${at + 1} ` }), _jsx(Text, { bold: selected, children: clip(candidate.label, bodyW - 10) })] }, candidate.id));
+                    }), below > 0 && _jsx(ElisionMark, { count: below, side: "below" })] }));
+        }
+        if (overlay.kind === "poolmode") {
+            const modes = [
+                { id: "any", gloss: "economy engine picks within your selection (cost, then tier)" },
+                { id: "ordered", gloss: "walk your selection in order; first live wins" },
+            ];
+            return (_jsxs(OverlayPanel, { title: `pool mode · ${overlay.picker.shape}`, width: bodyW, children: [_jsx(Text, { dimColor: true, children: clip(`pool: ${overlay.picker.chain.join(" → ")}`, bodyW - 4) }), _jsx(Text, { children: " " }), modes.map((mode, index) => (_jsxs(Text, { children: [_jsx(Pointer, { on: overlay.at === index }), _jsx(Text, { bold: overlay.at === index, children: padCell(mode.id, 9) }), _jsx(Text, { dimColor: true, children: clip(`— ${mode.gloss}`, bodyW - 14) })] }, mode.id)))] }));
+        }
+        if (overlay.kind === "prefer") {
+            const title = "shape" in overlay.target ? `${overlay.target.shape}.prefer` : `${overlay.target.steering}.prefer`;
+            const rows = overlay.rows.filter((option) => matches(option, ui.filter));
+            const { visible, start, above, below } = windowRows(rows, overlay.at, capacity);
+            return (_jsxs(OverlayPanel, { title: `edit · ${title}`, width: bodyW, children: [_jsx(Text, { dimColor: true, wrap: "truncate", children: clip("Space adds/drops in order · Enter applies (empty clears) · ordered chain wins routing ties", bodyW - 4) }), _jsx(SearchRow, { filter: ui.filter, active: true }), above > 0 && _jsx(ElisionMark, { count: above, side: "above" }), visible.map((option, index) => {
+                        const at = overlay.chain.indexOf(option);
+                        const selected = start + index === overlay.at;
+                        return (_jsxs(Text, { children: [_jsx(Pointer, { on: selected }), at === -1 ? _jsx(Text, { dimColor: true, children: "· " }) : _jsx(Text, { color: INK.brand, children: `${at + 1} ` }), _jsx(Text, { bold: selected, children: clip(option, bodyW - 10) })] }, option));
+                    }), below > 0 && _jsx(ElisionMark, { count: below, side: "below" })] }));
+        }
+        // judge
+        const rows = [judgeKeepRow, ...judgeSeats].filter((row) => matches(row, ui.filter));
+        const { visible, start, above, below } = windowRows(rows, overlay.at, capacity);
+        const selectedSeat = ui.judgeSeat ?? judgeKeepRow;
+        return (_jsxs(OverlayPanel, { title: "pick \u00B7 judge", width: bodyW, children: [_jsx(Text, { dimColor: true, children: "one seat judges acceptance criteria \u2014 failover stays runtime (GATE-09)" }), _jsx(SearchRow, { filter: ui.filter, active: true }), above > 0 && _jsx(ElisionMark, { count: above, side: "above" }), visible.map((label, index) => (_jsxs(Text, { children: [_jsx(Pointer, { on: start + index === overlay.at }), label === selectedSeat ? _jsx(Glyph, { kind: "on" }) : _jsx(Text, { children: " " }), _jsx(Text, { bold: start + index === overlay.at, children: ` ${clip(label, bodyW - 10)}` })] }, label))), below > 0 && _jsx(ElisionMark, { count: below, side: "below" })] }));
+    })();
+    const listNode = (() => {
+        if (overlayNode)
+            return overlayNode;
+        if (ui.view === "models") {
+            const rows = modelRows();
+            const { visible, start, above, below } = windowRows(rows, ui.listAt, capacity);
+            const scopeLabel = ui.adapterAt === -1
+                ? "All models"
+                : modelGroups[ui.adapterAt]?.adapter ?? "";
+            const scopeDenied = ui.adapterAt !== -1 && ui.deny.has(modelGroups[ui.adapterAt]?.adapter ?? "");
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: scopeLabel }), _jsx(Text, { dimColor: true, children: `  ${rows.length}` })] }), _jsx(SearchRow, { filter: ui.filter, active: ui.searching, hint: "/ to search" }), scopeDenied && _jsx(Text, { color: INK.warn, children: `${modelGroups[ui.adapterAt]?.adapter} is out of the fleet — Space on its rail row adds it back` }), above > 0 && _jsx(ElisionMark, { count: above, side: "above" }), visible.map((row, index) => renderModelRow(row, ui.focus === "list" && start + index === ui.listAt)), below > 0 && _jsx(ElisionMark, { count: below, side: "below", hint: "/ to search" }), rows.length === 0 && !scopeDenied && _jsx(Text, { dimColor: true, children: "  no models match" })] }));
+        }
+        if (ui.view === "shapes") {
+            const rows = shapeList();
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Shapes" }), _jsx(Text, { dimColor: true, children: `  routed under ${ui.selectedMode}` })] }), _jsx(Text, { children: " " }), rows.map((row, index) => renderShapeRow(row, ui.focus === "list" && index === ui.listAt))] }));
+        }
+        const rows = steeringList();
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Steering" }), _jsx(Text, { dimColor: true, children: "  review · consult · judge" })] }), _jsx(Text, { children: " " }), rows.map((row, index) => renderPlainRow(row.id, row.label, ui.focus === "list" && index === ui.listAt))] }));
+    })();
+    // ── footer ─────────────────────────────────────────────────────────────────
+    const detailLines = () => {
+        if (ui.notice)
+            return [ui.notice];
+        const overlay = ui.overlay;
+        if (overlay) {
+            if (overlay.kind === "candidates") {
+                const rows = overlay.rows.filter((candidate) => matches(candidate.label, ui.filter));
+                return rows[overlay.at] ? [rows[overlay.at].label] : [];
+            }
+            if (overlay.kind === "prefer") {
+                return overlay.chain.length ? [`chain: ${overlay.chain.join(" → ")}`] : [];
+            }
+            return [];
+        }
+        if (ui.view === "models") {
+            const rows = modelRows();
+            const row = rows[ui.listAt];
+            const lines = [];
+            if (row) {
+                lines.push(modelDetail(row));
+                if (!row.tier) {
+                    lines.push(row.suggestion
+                        ? `catalog suggests ${row.suggestion.tier} — Space/Enter classifies with the note pre-typed · s stages every visible suggestion`
+                        : "unclassified — Space/Enter classifies; unclassified models are never routed");
                 }
-                finish({ kind: "write", review: reviewRef.current });
             }
+            const hidden = hiddenModelCount();
+            if (hidden > 0 && lines.length < 2)
+                lines.push(`${hidden} retired/preview/non-worker hidden — a shows all`);
+            if (ui.showAll && lines.length < 2)
+                lines.push("showing retired models — a hides them again");
+            return lines;
         }
-    });
-    if (screen === "probe") {
-        return (_jsx(FleetListScreen, { title: "step 1/6 \u00B7 probe data", legend: "enter continue \u00B7 r refresh via doctor \u00B7 esc/q quit", rows: [{
-                    id: "doctor",
-                    content: _jsx(Text, { children: `probe data: ${formatDoctorAge(ageMs)} (.tickmarkr/doctor.json)` }),
-                }], cursor: 0 }));
-    }
-    if (screen === "agents") {
-        const rows = agents.map((agent) => {
-            const active = !denyAdapters.has(agent.id);
-            return {
-                id: agent.id,
-                content: (_jsxs(_Fragment, { children: [_jsx(ToggleMark, { active: active }), _jsx(Text, { children: ` ${agent.id}  ${agent.version}  ${agent.authed ? "authed" : "unauthed"}` })] })),
-            };
-        });
-        return (_jsx(FleetListScreen, { title: "step 2/6 \u00B7 agent CLIs", legend: "\u2191\u2193/jk move \u00B7 space toggle \u00B7 enter next \u00B7 esc/q quit", rows: rows, cursor: cursor }));
-    }
-    const group = enabledModelGroups()[modelGroup];
-    if (screen === "models") {
-        const rows = filteredModelRows().map((row) => {
-            const denied = group ? denyModels.has(`${group.adapter}:${row.model}`) : false;
-            return {
-                id: row.model,
-                content: row.tier ? (_jsxs(_Fragment, { children: [_jsx(ToggleMark, { active: !denied }), _jsx(Text, { children: ` ${row.model}  ${row.tier}  ${denied ? "denied" : "allowed"}` })] })) : _jsx(Text, { children: `( ) ${row.model}  ???  unclassified${row.detectedAt ? ` (${row.detectedAt})` : ""}` }),
-            };
-        });
-        return (_jsx(FleetListScreen, { title: `step 3/6 · models · ${group?.adapter ?? ""}`, legend: "\u2191\u2193 to move \u00B7 Space to toggle \u00B7 t to classify tier \u00B7 n to add model \u00B7 Enter for next \u00B7 Type to search \u00B7 Esc to quit", rows: rows, cursor: modelCursor, details: notice ? [notice] : [], filter: filter }));
-    }
-    if (screen === "add-model")
-        return (_jsx(FleetListScreen, { title: `add model · ${group?.adapter ?? ""}`, legend: "type model id \u00B7 enter classify \u00B7 esc cancel", rows: [{ id: "model", content: _jsx(Text, { children: modelId || "model id (required):" }) }], cursor: 0, details: notice ? [notice] : [] }));
-    if (screen === "channel")
-        return (_jsx(FleetListScreen, { title: `channel · ${pendingClassificationRef.current?.adapter ?? ""}`, legend: "\u2191\u2193/jk move \u00B7 enter select \u00B7 esc/q quit", rows: CHANNELS.map((channel) => ({ id: channel, content: _jsx(Text, { children: channel }) })), cursor: channelCursor }));
-    if (screen === "tiers") {
-        return (_jsx(FleetListScreen, { title: `pick · tier · ${pendingClassificationRef.current?.adapter}:${pendingClassificationRef.current?.model}`, legend: "\u2191\u2193/jk move \u00B7 enter select \u00B7 esc/q quit", rows: TIERS.map((tier) => ({ id: tier, content: _jsx(Text, { children: tier }) })), cursor: tierCursor }));
-    }
-    if (screen === "provenance")
-        return (_jsx(FleetListScreen, { title: `benchmark provenance · ${pendingClassificationRef.current?.adapter}:${pendingClassificationRef.current?.model}`, legend: "type note \u00B7 enter apply \u00B7 esc cancel", rows: [{ id: "note", content: _jsx(Text, { children: note || "benchmark provenance note (required):" }) }], cursor: 0, details: notice ? [notice] : [] }));
-    if (screen === "modes") {
-        const presetPick = presetPickRef.current;
-        const rows = modeOptions.map((option) => ({
-            id: option.id,
-            content: (_jsxs(_Fragment, { children: [option.id === initialMode ? _jsx(ToggleMark, { active: true }) : _jsx(Text, { children: " " }), _jsx(Text, { children: ` ${option.id.padEnd(11)}  ${option.gloss}` })] })),
-        }));
-        if (presetPick) {
-            rows.push({
-                id: "custom",
-                content: (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { children: ` ${"custom".padEnd(11)}  walk the full editor (agents → models → shapes → seats)` })] })),
-            });
+        if (ui.view === "shapes") {
+            const row = shapeList()[ui.listAt];
+            return row ? [row.label] : [];
         }
-        return (_jsx(FleetListScreen, { title: presetPick ? "tickmarkr init · act 3 of 3 — fleet · routing presets" : "step 4/6 · routing mode", legend: presetPick ? "↑↓ to move · Enter to apply preset · Enter on custom to walk the editor · Esc inside the walk returns here · Esc here closes" : "↑↓/jk move · enter select · esc/q quit", rows: rows, cursor: modeCursor, details: modeOptions[modeCursor] ? modePreview(modeOptions[modeCursor].id, map) : [] }));
-    }
-    const renderedShapes = shapeRows(selectedModeRef.current, map);
-    if (screen === "shapes") {
-        return (_jsx(FleetListScreen, { title: "step 5/6 \u00B7 shape routing", legend: "\u2191\u2193/jk move \u00B7 a auto \u00B7 p pin \u00B7 f prefer \u00B7 enter next \u00B7 esc/q quit", rows: renderedShapes.map((row) => ({ id: row.id, content: _jsx(Text, { children: row.label }) })), cursor: shapeCursor }));
-    }
-    const shape = renderedShapes[shapeCursor]?.id;
-    if (screen === "candidates") {
-        return (_jsx(FleetListScreen, { title: `pick · ${shape}`, legend: "\u2191\u2193 to move \u00B7 Enter to pin \u00B7 Type to search \u00B7 Esc to cancel \u00B7 q to quit", rows: filteredCandidates().map((candidate) => ({
-                id: candidate.id,
-                content: _jsx(Text, { children: candidate.label }),
-            })), cursor: candidateCursor, filter: filter }));
-    }
-    if (screen === "shape-prefer")
-        return (_jsx(FleetListScreen, { title: `pick · ${shape}.prefer`, legend: "\u2191\u2193/jk move \u00B7 space add/drop \u00B7 enter apply (empty clears) \u00B7 esc cancel \u00B7 q quit", rows: preferRowsRef.current.map((option) => {
-                const at = preferChainRef.current.indexOf(option);
-                return { id: option, content: _jsx(Text, { children: `${at === -1 ? "·" : String(at + 1)} ${option}` }) };
-            }), cursor: preferCursor }));
-    if (screen === "steering") {
-        return (_jsx(FleetListScreen, { title: "step 6/6 \u00B7 steering", legend: "\u2191\u2193 to move \u00B7 f to edit \u00B7 Enter to review \u00B7 Esc/q to quit", rows: [
-                ...STEERING_KEYS.map((key) => ({
-                    id: key,
-                    content: _jsx(Text, { children: `${key}.prefer  →  ${steering[key]?.join(", ") ?? "(none)"}` }),
-                })),
-                {
-                    id: "judge",
-                    content: _jsx(Text, { children: `judge  →  ${judgeSeat ?? (initialJudge ? `${initialJudge} (default)` : "(default)")}` }),
-                },
-            ], cursor: steeringCursor, details: notice ? [notice] : [] }));
-    }
-    if (screen === "judge-pick") {
-        const selected = judgeSeat ?? judgeKeepRow;
-        return (_jsx(FleetListScreen, { title: "pick \u00B7 judge", legend: "\u2191\u2193 to move \u00B7 Enter to select \u00B7 Type to search \u00B7 Esc to cancel \u00B7 q to quit", rows: filteredJudgeRows().map((label) => ({
-                id: label,
-                content: (_jsxs(_Fragment, { children: [label === selected ? _jsx(ToggleMark, { active: true }) : _jsx(Text, { children: " " }), _jsx(Text, { children: ` ${label}` })] })),
-            })), cursor: judgeCursor, filter: filter }));
-    }
-    if (screen === "steering-prefer") {
-        const which = steeringPickerRef.current;
-        return (_jsx(FleetListScreen, { title: `pick · ${which}.prefer`, legend: "\u2191\u2193 to move \u00B7 Space to add/drop \u00B7 Enter to apply (empty clears) \u00B7 Type to search \u00B7 Esc to cancel \u00B7 q to quit", rows: filteredSteeringRows().map((option) => {
-                const at = steeringChainRef.current.indexOf(option);
-                return { id: option, content: _jsx(Text, { children: `${at === -1 ? "·" : String(at + 1)} ${option}` }) };
-            }), cursor: steeringPickerCursor, filter: filter }));
-    }
-    return (_jsx(FleetReviewScreen, { title: "review \u00B7 overlay diff", legend: "y write \u00B7 n discard \u00B7 esc/q quit", diff: review?.diff ?? "" }));
+        const row = steeringList()[ui.listAt];
+        return row ? [row.label] : [];
+    };
+    const keyBinds = () => {
+        const overlay = ui.overlay;
+        if (overlay) {
+            if (overlay.kind === "presets") {
+                return overlay.home
+                    ? [{ key: "Enter", label: "apply preset" }, { key: "↑↓", label: "move" }, { key: "Esc", label: "quit" }]
+                    : [{ key: "Enter", label: "set mode" }, { key: "↑↓", label: "move" }, { key: "Esc", label: "back" }];
+            }
+            if (overlay.kind === "review") {
+                return [{ key: "y", label: "write" }, { key: "n", label: "discard" }, { key: "↑↓", label: "scroll" }, { key: "Esc", label: "keep editing" }];
+            }
+            if (overlay.kind === "classify") {
+                return overlay.stage === "note"
+                    ? [{ key: "type", label: "note" }, { key: "Enter", label: "stage" }, { key: "Esc", label: "cancel" }]
+                    : [{ key: "↑↓", label: "move" }, { key: "Enter", label: "next" }, { key: "Esc", label: "cancel" }];
+            }
+            if (overlay.kind === "assign") {
+                // OBS-526: assign has no search box — advertising "type search" here promised a dead key
+                return [{ key: "Enter", label: "pin to shape" }, { key: "↑↓", label: "move" }, { key: "Esc", label: "cancel" }];
+            }
+            if (overlay.kind === "add-model") {
+                return [{ key: "type", label: "model id" }, { key: "Enter", label: "classify" }, { key: "Esc", label: "cancel" }];
+            }
+            if (overlay.kind === "prefer") {
+                return [{ key: "Space", label: "add/drop" }, { key: "Enter", label: "apply" }, { key: "type", label: "search" }, { key: "Esc", label: "cancel" }];
+            }
+            if (overlay.kind === "candidates") {
+                return [
+                    { key: "Enter", label: overlay.chain.length ? "apply pool" : "pin" },
+                    { key: "Space", label: "pool in order" },
+                    { key: "type", label: "search" },
+                    { key: "Esc", label: "cancel" },
+                ];
+            }
+            if (overlay.kind === "poolmode") {
+                return [
+                    { key: "Enter", label: "apply pool" },
+                    { key: "↑↓", label: "move" },
+                    { key: "Esc", label: "back to picker" },
+                ];
+            }
+            return [{ key: "Enter", label: "select" }, { key: "↑↓", label: "move" }, { key: "type", label: "search" }, { key: "Esc", label: "cancel" }];
+        }
+        if (ui.searching) {
+            return [
+                { key: "type", label: "filter" },
+                { key: "Enter", label: "apply" },
+                { key: "↑↓", label: "move" },
+                { key: "Esc", label: "cancel" },
+            ];
+        }
+        const escLabel = ui.filter !== "" ? "clear search" : entry === "presets" ? "presets" : "quit";
+        if (ui.focus === "rail") {
+            return [
+                { key: "Enter", label: "open" },
+                { key: "↑↓", label: "move" },
+                { key: "Space", label: "fleet in/out CLI" },
+                { key: "→", label: "list" },
+                { key: "w", label: "review + write" },
+                { key: "Esc", label: escLabel },
+            ];
+        }
+        if (ui.view === "models") {
+            return [
+                { key: "Enter", label: "assign/classify" },
+                { key: "Space", label: "fleet in/out" },
+                { key: "m", label: "presets" },
+                { key: "w", label: "review + write" },
+                { key: "←", label: "rail" },
+                { key: "/", label: "search" },
+                { key: "Esc", label: escLabel },
+            ];
+        }
+        if (ui.view === "shapes") {
+            return [
+                { key: "Enter", label: "pin from candidates" },
+                { key: "f", label: "prefer chain" },
+                { key: "a", label: "auto" },
+                { key: "w", label: "review + write" },
+                { key: "←", label: "rail" },
+                { key: "Esc", label: escLabel },
+            ];
+        }
+        return [
+            { key: "Enter", label: "edit" },
+            { key: "w", label: "review + write" },
+            { key: "←", label: "rail" },
+            { key: "Esc", label: escLabel },
+        ];
+    };
+    const details = detailLines();
+    const staged = stagedCount();
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: frameRows, children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, color: INK.brand, children: " tickmarkr fleet" }), _jsx(Text, { dimColor: true, children: entry === "presets" ? " · init act 3 of 3" : "" }), _jsx(Text, { dimColor: true, children: ` · probe ${formatDoctorAge(ageMs)} · mode ` }), _jsx(Text, { children: ui.selectedMode }), staged > 0 && _jsx(Text, { color: INK.warn, children: ` · ${staged} staged` })] }), _jsxs(Box, { flexGrow: 1, borderStyle: "round", borderDimColor: true, children: [_jsxs(Box, { width: RAIL_W, flexDirection: "column", paddingLeft: 1, paddingTop: 1, children: [rail.slice(0, 3).map((row, index) => railView(row, index)), _jsx(Text, { dimColor: true, children: "─".repeat(RAIL_W - 2) }), rail.slice(3).map((row, index) => railAdapter(row.index, index + 3))] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, paddingX: 1, paddingTop: 1, borderStyle: "single", borderDimColor: true, borderTop: false, borderBottom: false, borderRight: false, children: listNode })] }), ui.notice
+                ? _jsx(Text, { color: INK.warn, children: ` ! ${clip(ui.notice, width - 4)}` })
+                : details.map((line) => _jsx(Text, { dimColor: true, children: ` ${clip(line, width - 2)}` }, line)), _jsx(KeyBar, { binds: keyBinds() })] }));
 }
 export async function runFleetInkEditor({ ageMs, adapters, health, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, entry = "probe", initialJudge = "", judgeSeats = [], initialInput = [], input, output, debug = false, }) {
     const agents = adapters.flatMap((adapter) => {
@@ -911,7 +1394,19 @@ export async function runFleetInkEditor({ ageMs, adapters, health, initialDenyAd
     }));
     const bridgedInput = inkInput(input, initialInput);
     const legacyOutput = typeof output.on !== "function" || typeof output.off !== "function";
-    const app = render(_jsx(FleetApp, { ageMs: ageMs, agents: agents, initialDenyAdapters: initialDenyAdapters, initialDenyModels: initialDenyModels, modelGroups: declaredModelGroups, initialMode: initialMode, modeOptions: modeOptions, initialMap: initialMap, modePreview: modePreview, shapeRows: shapeRows, candidatesForShape: candidatesForShape, preferOptionsForShape: preferOptionsForShape, initialSteering: initialSteering, steeringOptionsFor: steeringOptionsFor, reviewOverlay: reviewOverlay, reloadGuard: reloadGuard, entry: entry, initialJudge: initialJudge, judgeSeats: judgeSeats }), {
+    const realTty = output === process.stdout && output.isTTY === true;
+    const leaveAltScreen = enterAltScreen(output);
+    // OBS-527: the terminal geometry is a LIVE input, not a launch constant — the element is
+    // rebuilt from output.columns/rows so a pane resize re-renders at the new size. Same root
+    // element type on every rerender ⇒ React keeps the component instance, so staged edits,
+    // cursor, and overlays all survive the resize.
+    const editorElement = () => (_jsx(FleetApp, { ageMs: ageMs, agents: agents, initialDenyAdapters: initialDenyAdapters, initialDenyModels: initialDenyModels, modelGroups: declaredModelGroups, initialMode: initialMode, modeOptions: modeOptions, initialMap: initialMap, modePreview: modePreview, shapeRows: shapeRows, candidatesForShape: candidatesForShape, preferOptionsForShape: preferOptionsForShape, initialSteering: initialSteering, steeringOptionsFor: steeringOptionsFor, reviewOverlay: reviewOverlay, reloadGuard: reloadGuard, entry: entry, initialJudge: initialJudge, judgeSeats: judgeSeats, 
+        // v1.90.9: cap every list to the terminal minus chrome so the cursor and header can
+        // never scroll off-screen (omp's 218-model list did exactly that pre-cap).
+        // OBS-523: chrome is ≤12 rows worst case (header, borders, padding, scope+search,
+        // elisions, two detail lines, keybar) — the old -16 blanked six list rows at every size.
+        viewRows: Math.max(8, (output.rows ?? 40) - 12), frameColumns: output.columns ?? 100, frameRows: realTty ? output.rows : undefined }));
+    const app = render(editorElement(), {
         // FleetIO's injected stream predates Ink and did not require ref/unref.
         // Real terminal streams pass through unchanged; the compatibility facade
         // adds only those lifecycle methods and leaves input decoding to Ink.
@@ -924,13 +1419,19 @@ export async function runFleetInkEditor({ ageMs, adapters, health, initialDenyAd
         // cold-start byte sequence cannot collapse intermediate compatibility frames.
         debug: debug || legacyOutput,
     });
+    const onResize = () => app.rerender(editorElement());
+    if (!legacyOutput)
+        output.on("resize", onResize);
     let result;
     try {
         result = await app.waitUntilExit();
         return result;
     }
     finally {
+        if (!legacyOutput)
+            output.off("resize", onResize);
         app.unmount();
         bridgedInput.stop();
+        leaveAltScreen();
     }
 }