tickmarkr 1.48.1 → 1.49.0

package/README.md

@@ -11,7 +11,7 @@
 
 tickmarkr is a spec-driven orchestration harness for AI coding agent CLIs. You write a spec with
 acceptance criteria; the engine routes tasks to the best installed agent CLI (claude-code, codex,
-cursor-agent, opencode, grok, pi) by cost and capability, dispatches work in git worktrees for
+cursor-agent, opencode, grok, pi, kimi) by cost and capability, dispatches work in git worktrees for
 change isolation — as interactive TUIs when running under [herdr](https://herdr.dev), headless
 subprocesses otherwise — and independently verifies each committed result by checking for no new
 baseline failures per task, then strictly verifying the integration tip. Green tasks consolidate onto a
@@ -51,8 +51,8 @@ prefer, every example below works with either.
 - **macOS or Linux.** Every command shells out through `bash`, so native Windows is not
   supported — use WSL (untested).
 - Node ≥ 20 and `git` on PATH.
-- At least one agent CLI on PATH (`claude`, `codex`, `cursor-agent`, `opencode`, `grok`, or
-  `pi`), authenticated through its own login. tickmarkr never handles vendor API keys itself.
+- At least one agent CLI on PATH (`claude`, `codex`, `cursor-agent`, `opencode`, `grok`, `pi`,
+  or `kimi`), authenticated through its own login. tickmarkr never handles vendor API keys itself.
 
 Then verify your fleet:
 
@@ -63,7 +63,11 @@ tickmarkr doctor   # probes installed adapters, herdr, auth; prints the capabili
 **Expect `doctor` (and `init`, which runs it) to take a while on first run:** auth detection is
 one real, short LLM call per configured model per installed CLI — honest, but not instant. A
 machine with three CLIs and several models each can take a minute or more; each probe is capped
-at 30s.
+at 60s.
+
+`doctor` also sweeps a catalog of known agent CLIs that have no adapter yet and prints an
+advisory `detected — no adapter; not routable` row for any found on PATH — a freshly installed
+harness is visible the day it lands, and never routed until an adapter ships for it.
 
 ## Quickstart (5 minutes)
 
@@ -113,6 +117,7 @@ tickmarkr resume <runId>       # continue an engagement from the local execution
 tickmarkr approve <runId> <taskId>   # approve a parked task (--reason to document)
 tickmarkr report <runId>       # cost/quality report
 tickmarkr profile              # show the learned routing profile
+tickmarkr profile --explain <shape> <channel>  # why a channel ranks where it does for a shape
 ```
 
 Green tasks land on `tickmarkr/<runId>`; merge to your mainline is always your call.
@@ -136,6 +141,41 @@ away from a failing adapter will never retry it in subsequent `tickmarkr resume`
 - The task has burned its full attempt budget without reaching a conclusive result
 - Approving grants a fresh attempt budget, routing around all previously-failed channels and adapters
 
+## Choosing your fleet: `tickmarkr fleet`
+
+`tickmarkr doctor` is a pure sensor; `tickmarkr fleet` is the actuator. It walks four screens —
+fleet overview, membership (allow/deny), model tiers, and per-shape routing — and ends in a
+unified diff of your config overlay that is written **only on explicit confirm**. Pressing Enter
+through every screen writes nothing. Assigning a tier to a model that has no classification yet
+requires a typed benchmark-provenance note, stored as a config comment beside the assignment.
+
+```bash
+tickmarkr fleet          # interactive editor (requires a TTY)
+tickmarkr fleet --print  # effective fleet state (repo > global > defaults), non-interactive — good for CI drift checks
+```
+
+Routing obeys a strict precedence — **pin > prefer > floors > marginal-cost auto**:
+
+- **pin** a shape to an exact channel: `map: { plan: { via: claude-code, model: fable } }`
+- **prefer**-rank adapters per shape: `map: { implement: { prefer: [cursor-agent, codex] } }`
+- **floors** set the minimum capability band per shape (`migration: frontier`, `tests: cheap`);
+  auto-routing then picks the cheapest authed channel at or above the floor
+- **deny/allow** bench models or whole adapters without touching tiers (see `deny.models` below)
+- **tiers** classify models into bands — only classified, doctor-authed models ever route
+
+More levers, all optional and absent-safe (absent config keeps default behavior):
+
+- `routing.explore` — fence the exploration budget: `mode: off`, `excludeShapes`,
+  `excludeComplexityAtOrAbove`, and a per-channel `cap`; `run --no-explore` disables
+  exploration probes for a single run
+- `tiers.<adapter>.windows` — declare context-window sizes per model; doctor grows a window
+  column and `plan` warns (advisory, never blocking) when a task's payload estimate exceeds
+  the routed model's window
+- `routing.sla` — per-shape latency expectations, surfaced as advisory plan lints against the
+  learned performance profile
+- `run --quality` — raise every capability floor one band for that run (it never lowers one),
+  disable exploration, and record the original and raised floor in routing provenance
+
 ## Model scoping and auth detection
 
 Each agent CLI exposes a list of available models. tickmarkr's routing works only with **classified** models — those you explicitly enter into the config under `tiers`. The `tickmarkr doctor` command probes these models to detect auth status and records the results, which routing consumes to avoid 401/403 dispatch failures.

package/dist/adapters/kimi.js

@@ -64,10 +64,15 @@ export const kimi = {
             : { ...h, authed: false, note: "no valid ~/.kimi-code/credentials/kimi-code.json (kimi login to fix)" };
     },
     channels: (cfg) => channelsFromConfig("kimi", cfg),
-    // KIMI-02 headless. -p prompt mode + -y yolo + explicit model. kimi 0.27.0 rejects -p combined
-    // with -y at parse time — tickmarkr still emits both per harness contract; interactive uses -y.
-    headlessCommand: (promptFile, model) => `kimi -p "$(cat ${shq(promptFile)})" -y --model ${shq(model)} --output-format text`,
-    interactiveCommand: (promptFile, model) => `kimi -y --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    // KIMI-02 headless. -p prompt mode + explicit model, NO permission flag: kimi 0.26.0 rejects
+    // -p combined with -y/--auto at argument parse time ("Cannot combine --prompt with --yolo",
+    // OBS-67 — doctor probes all failed on it), and prompt mode is already non-interactive with
+    // tool actions auto-approved (live-verified 2026-07-17: unattended file write succeeded).
+    headlessCommand: (promptFile, model) => `kimi -p "$(cat ${shq(promptFile)})" --model ${shq(model)} --output-format text`,
+    // kimi 0.26.0 has NO TUI argv-seeding surface: a positional prompt parses as a subcommand
+    // ("unknown command '…'", live-verified 2026-07-17, OBS-67) and -p is non-interactive-only.
+    // null → the daemon's print fallback (types.ts:101) keeps kimi workers visible without a TUI.
+    interactiveCommand: () => null,
     invoke(task, _cwd, a, ctx) {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };
     },

package/dist/cli/commands/fleet.d.ts

@@ -1,5 +1,19 @@
 import type { WorkerAdapter } from "../../adapters/types.js";
-export declare function fleet(argv: string[], cwd?: string, adapters?: WorkerAdapter[]): Promise<string | {
+export type FleetInput = NodeJS.ReadableStream & {
+    isTTY?: boolean;
+    setRawMode?: (mode: boolean) => unknown;
+    pause: () => unknown;
+    resume: () => unknown;
+};
+export type FleetOutput = {
+    isTTY?: boolean;
+    write: (chunk: string) => unknown;
+};
+export type FleetIO = {
+    input?: FleetInput;
+    output?: FleetOutput;
+};
+export declare function fleet(argv: string[], cwd?: string, adapters?: WorkerAdapter[], io?: FleetIO): Promise<string | {
     out: string;
     code: number;
 }>;

package/dist/cli/commands/fleet.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
+import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, readAutoPrefer } from "../../adapters/registry.js";
@@ -9,6 +10,10 @@ import { SHAPES, TIERS } from "../../graph/schema.js";
 import { route } from "../../route/router.js";
 import { loadRoutingProfile } from "../../run/journal.js";
 const NON_TTY_MSG = "tickmarkr fleet: interactive fleet editor requires a TTY — use `tickmarkr fleet --print` for non-interactive output";
+const QUIT = "fleet: quit without writing";
+const BOLD = (s) => `\x1b[1m${s}\x1b[0m`;
+const DIM = (s) => `\x1b[2m${s}\x1b[0m`;
+const POINTER = "❯";
 const isDeniedAdapter = (id, editable) => editable.denyAdapters.includes(id);
 const isDeniedModel = (adapter, model, editable) => editable.denyModels.includes(`${adapter}:${model}`);
 function previewTask(shape) {
@@ -56,10 +61,88 @@ function proposedOverlayText(initial, editable, repoRoot) {
     const merged = fleetRepoOverlayFromDelta(initial, editable, readOverlayFile(repoOverlayPath(repoRoot)));
     return repoOverlayYaml(merged, provenanceMap(editable));
 }
-async function ask(rl, prompt) {
-    return (await rl.question(prompt)).trim();
+const isAbort = (k) => k.name === "escape" || k.name === "q" || (k.ctrl === true && k.name === "c");
+const isNext = (k) => k.name === "return" || k.name === "enter";
+const isToggle = (k) => k.name === "space";
+function moveCursor(k, cursor, count) {
+    if (count === 0)
+        return cursor;
+    if (k.name === "down" || k.name === "j")
+        return Math.min(cursor + 1, count - 1);
+    if (k.name === "up" || k.name === "k")
+        return Math.max(cursor - 1, 0);
+    return cursor;
 }
-export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters()) {
+// step title (bold) + one dim key legend + rows; exactly one pointer glyph on the cursor row
+function listFrame(title, legend, rows, cursor) {
+    const lines = [BOLD(title), DIM(legend)];
+    rows.forEach((r, i) => lines.push(i === cursor ? `${POINTER} ${BOLD(r)}` : `  ${r}`));
+    return lines;
+}
+// Keypress terminal over the (injectable) input stream. Keypress events are decoded by
+// node's own emitKeypressEvents ON THE STREAM — no readline interface is held in keypress
+// mode, so the production path and the test seam are the same decoder (OBS-69).
+function openTerm(input, output) {
+    emitKeypressEvents(input);
+    const queue = [];
+    let pending = null;
+    const onKeypress = (str, key) => {
+        const k = key && (key.name !== undefined || key.sequence !== undefined) ? key : { name: str, sequence: str };
+        if (pending) {
+            const fn = pending;
+            pending = null;
+            fn(k);
+        }
+        else
+            queue.push(k);
+    };
+    const setRaw = (on) => void input.setRawMode?.(on);
+    input.on("keypress", onKeypress);
+    setRaw(true);
+    input.resume();
+    let prevLines = 0;
+    return {
+        key() {
+            const buffered = queue.shift();
+            if (buffered)
+                return Promise.resolve(buffered);
+            return new Promise((resolve) => {
+                pending = resolve;
+            });
+        },
+        frame(lines) {
+            const erase = prevLines > 0 ? `\x1b[${prevLines}F\x1b[0J` : "";
+            output.write(`${erase}${lines.join("\n")}\n`);
+            prevLines = lines.length;
+        },
+        // typed entry leaves keypress mode: raw off, transient line interface, closed after the
+        // question; keys the line editor leaked into the decoder are dropped (type-ahead kept)
+        async askTyped(prompt) {
+            const typedFrom = queue.length;
+            setRaw(false);
+            const rl = createInterface({
+                input: input,
+                output: output,
+            });
+            try {
+                return (await rl.question(prompt)).trim();
+            }
+            finally {
+                rl.close();
+                setRaw(true);
+                queue.splice(typedFrom);
+                prevLines = 0;
+            }
+        },
+        // every exit path: raw mode off, zero keypress listeners, stream paused (OBS-70)
+        close() {
+            input.off("keypress", onKeypress);
+            setRaw(false);
+            input.pause();
+        },
+    };
+}
+export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(), io = {}) {
     const { values } = parseArgs({
         args: argv,
         options: {
@@ -70,7 +153,9 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters())
     });
     const globalDir = values["global-dir"] ?? globalConfigDir();
     const print = values.print ?? false;
-    const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+    const input = io.input ?? process.stdin;
+    const output = io.output ?? process.stdout;
+    const interactive = input.isTTY === true && output.isTTY === true;
     if (print)
         return formatFleetPrint(cwd, { globalDir });
     if (!interactive)
@@ -87,153 +172,194 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters())
     const initial = fleetEditableFromConfig(cfg);
     const editable = structuredClone(initial);
     const health = cached;
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const term = openTerm(input, output);
     try {
-        // screen 0 — sensor freshness
+        // step 1/4 — probe data
         const ageLine = formatAge(doctorAgeMs(cwd));
-        let step = await ask(rl, `tickmarkr fleet — scope your fleet\n  probe data: ${ageLine} (.tickmarkr/doctor.json)\n  [Enter] use it   [r] refresh via doctor   [q] quit\n> `);
-        if (/^q$/i.test(step))
-            return "fleet: quit without writing";
-        if (/^r$/i.test(step)) {
-            return "fleet: run `tickmarkr doctor` to refresh probe data, then re-run `tickmarkr fleet` (doctor is the sensor; fleet never re-probes)";
+        term.frame(listFrame("step 1/4 · probe data", "enter continue · r refresh via doctor · esc/q quit", [`probe data: ${ageLine} (.tickmarkr/doctor.json)`], 0));
+        for (;;) {
+            const k = await term.key();
+            if (isAbort(k))
+                return QUIT;
+            if (k.name === "r") {
+                return "fleet: run `tickmarkr doctor` to refresh probe data, then re-run `tickmarkr fleet` (doctor is the sensor; fleet never re-probes)";
+            }
+            if (isNext(k))
+                break;
         }
-        // screen 1 — adapter membership (deny adapters)
+        // step 2/4 — agent CLIs (space toggles adapter deny)
         const installed = adapters.filter((a) => health[a.id]?.installed);
-        const adapterLines = installed.map((a, i) => {
+        const adapterRows = () => installed.map((a) => {
             const h = health[a.id];
             const on = !isDeniedAdapter(a.id, editable);
-            const mark = on ? "x" : " ";
-            const auth = h?.authed ? "authed" : "unauthed";
-            return `  ${i + 1}. [${mark}] ${a.id}  ${h?.version ?? "installed"}  ${auth}`;
+            return `[${on ? "x" : " "}] ${a.id}  ${h?.version ?? "installed"}  ${h?.authed ? "authed" : "unauthed"}`;
         });
-        step = await ask(rl, `screen 1/4 — agent CLIs  [number]=toggle  [Enter]=next\n${adapterLines.join("\n")}\n> `);
-        if (/^q$/i.test(step))
-            return "fleet: quit without writing";
-        if (step && step !== "") {
-            const n = Number.parseInt(step, 10);
-            if (Number.isInteger(n) && n >= 1 && n <= installed.length) {
-                const id = installed[n - 1].id;
+        const listLegend = "↑↓/jk move · space toggle · enter next · esc/q quit";
+        let aCursor = 0;
+        term.frame(listFrame("step 2/4 · agent CLIs", listLegend, adapterRows(), aCursor));
+        for (;;) {
+            const k = await term.key();
+            if (isAbort(k))
+                return QUIT;
+            if (isNext(k))
+                break;
+            let changed = false;
+            const moved = moveCursor(k, aCursor, installed.length);
+            if (moved !== aCursor) {
+                aCursor = moved;
+                changed = true;
+            }
+            else if (isToggle(k) && installed.length > 0) {
+                const id = installed[aCursor].id;
                 const idx = editable.denyAdapters.indexOf(id);
                 if (idx === -1)
                     editable.denyAdapters.push(id);
                 else
                     editable.denyAdapters.splice(idx, 1);
                 editable.denyAdapters.sort();
+                changed = true;
             }
+            if (changed)
+                term.frame(listFrame("step 2/4 · agent CLIs", listLegend, adapterRows(), aCursor));
         }
-        // screen 2 — models per enabled adapter
+        // step 3/4 — models per enabled adapter (space toggles deny, t assigns tier from the row)
         const enabledAdapters = installed.filter((a) => !isDeniedAdapter(a.id, editable));
         for (const a of enabledAdapters) {
-            const classified = editable.tiers[a.id] ?? {};
-            const models = Object.keys(classified);
-            const unclassified = fleetUnclassifiedModels(cfg, health, adapters).filter((u) => u.adapter === a.id);
-            const rows = [];
-            let row = 1;
-            const indexFor = new Map();
-            for (const m of models) {
-                const tier = classified[m];
-                const denied = isDeniedModel(a.id, m, editable) ? "deny" : "allow";
-                const mark = denied === "deny" ? " " : "x";
-                rows.push(`  ${row}. [${mark}] ${m}  ${tier?.tier ?? "???"}  ${denied === "deny" ? "denied" : "allowed"}`);
-                indexFor.set(String(row), { kind: "classified", model: m });
-                row++;
-            }
-            for (const u of unclassified) {
-                rows.push(`  ${row}. ( ) ${u.model}  ???  unclassified${u.detectedAt ? ` (${u.detectedAt})` : ""}`);
-                indexFor.set(String(row), { kind: "unclassified", model: u.model });
-                row++;
-            }
-            step = await ask(rl, `screen 2/4 — models · ${a.id}  [number]=toggle deny  [t <n> <tier>]=assign tier  [Enter]=next\n${rows.join("\n")}\n> `);
-            if (/^q$/i.test(step))
-                return "fleet: quit without writing";
-            if (step.startsWith("t ")) {
-                const [, numRaw, tierRaw] = step.split(/\s+/);
-                const tier = tierRaw;
-                if (!indexFor.has(numRaw) || !TIERS.includes(tier)) {
-                    return { out: "fleet: tier assignment requires a valid model number and tier (cheap|mid|frontier)", code: 1 };
+            const unclassifiedAll = fleetUnclassifiedModels(cfg, health, adapters).filter((u) => u.adapter === a.id);
+            const rowsData = () => [
+                ...Object.keys(editable.tiers[a.id] ?? {}).map((m) => ({ kind: "classified", model: m })),
+                ...unclassifiedAll
+                    .filter((u) => !editable.tiers[a.id]?.[u.model])
+                    .map((u) => ({ kind: "unclassified", model: u.model, detectedAt: u.detectedAt })),
+            ];
+            const renderRows = (rows) => rows.map((r) => {
+                if (r.kind === "unclassified") {
+                    return `( ) ${r.model}  ???  unclassified${r.detectedAt ? ` (${r.detectedAt})` : ""}`;
                 }
-                const target = indexFor.get(numRaw);
-                if (target.kind !== "unclassified") {
-                    return { out: "fleet: tier reassignment on classified models is not supported in v1 — edit config directly", code: 1 };
+                const tier = editable.tiers[a.id]?.[r.model];
+                const denied = isDeniedModel(a.id, r.model, editable);
+                return `[${denied ? " " : "x"}] ${r.model}  ${tier?.tier ?? "???"}  ${denied ? "denied" : "allowed"}`;
+            });
+            const title = `step 3/4 · models · ${a.id}`;
+            const modelsLegend = "↑↓/jk move · space toggle · t tier · enter next · esc/q quit";
+            let mCursor = 0;
+            term.frame(listFrame(title, modelsLegend, renderRows(rowsData()), mCursor));
+            for (;;) {
+                const k = await term.key();
+                if (isAbort(k))
+                    return QUIT;
+                if (isNext(k))
+                    break;
+                const rows = rowsData();
+                let changed = false;
+                const moved = moveCursor(k, mCursor, rows.length);
+                if (moved !== mCursor) {
+                    mCursor = moved;
+                    changed = true;
                 }
-                const note = await ask(rl, "benchmark provenance note (required): ");
-                if (!note.trim())
-                    return { out: "fleet: assigning a tier to an unclassified model requires a typed benchmark-provenance note", code: 1 };
-                editable.tiers[a.id] ??= {};
-                editable.tiers[a.id][target.model] = { tier, provenance: note.trim() };
-            }
-            else if (step && /^\d+$/.test(step)) {
-                const target = indexFor.get(step);
-                if (target?.kind === "classified") {
-                    const key = `${a.id}:${target.model}`;
+                else if (isToggle(k) && rows[mCursor]?.kind === "classified") {
+                    const key = `${a.id}:${rows[mCursor].model}`;
                     const idx = editable.denyModels.indexOf(key);
                     if (idx === -1)
                         editable.denyModels.push(key);
                     else
                         editable.denyModels.splice(idx, 1);
                     editable.denyModels.sort();
+                    changed = true;
                 }
+                else if (k.name === "t" && rows[mCursor]) {
+                    if (rows[mCursor].kind === "classified") {
+                        return { out: "fleet: tier reassignment on classified models is not supported in v1 — edit config directly", code: 1 };
+                    }
+                    const tier = (await term.askTyped(`tier (${TIERS.join("|")})> `));
+                    if (!TIERS.includes(tier))
+                        return { out: `fleet: invalid tier ${tier}`, code: 1 };
+                    const note = await term.askTyped("benchmark provenance note (required): ");
+                    if (!note)
+                        return { out: "fleet: assigning a tier to an unclassified model requires a typed benchmark-provenance note", code: 1 };
+                    editable.tiers[a.id] ??= {};
+                    editable.tiers[a.id][rows[mCursor].model] = { tier, provenance: note };
+                    changed = true;
+                }
+                if (changed)
+                    term.frame(listFrame(title, modelsLegend, renderRows(rowsData()), mCursor));
             }
         }
-        // screen 3 — per-shape routing
+        // step 4/4 — shape routing (typed entry for pin/tier/prefer from the highlighted row)
         const channels = discoverChannels(cfg, adapters, health);
         const profile = loadRoutingProfile(cwd, cfg, { preview: true });
         const autoPrefer = readAutoPrefer(cwd);
         const overlayShapes = overlayPreferShapes(cwd, { globalDir });
-        for (let si = 0; si < SHAPES.length; si++) {
-            const shape = SHAPES[si];
-            const entry = editable.map[shape] ?? {};
-            let now = "";
+        const shapeRows = () => SHAPES.map((shape) => {
+            let now;
             try {
                 const r = route(previewTask(shape), { ...cfg, routing: { ...cfg.routing, map: editable.map, floors: editable.floors } }, channels, profile);
-                now = `${r.provenance}\n       → ${r.assignment.adapter}:${r.assignment.model} (${r.assignment.channel}, ${r.assignment.tier})`;
+                now = `${r.assignment.adapter}:${r.assignment.model} (${r.assignment.channel}, ${r.assignment.tier})`;
             }
             catch (e) {
                 now = e.message;
             }
-            const autoNote = autoPrefer?.[shape] && !overlayShapes.has(shape)
-                ? `\n  auto-prefer active — explicit prefer overrides it`
-                : "";
-            step = await ask(rl, `screen 3/4 — shape routing · ${shape} (${si + 1}/${SHAPES.length})\n  now: ${now}\n  [1] auto within tier  [2] pin channel  [3] edit tier  [4] edit prefer  [Enter]=keep${autoNote}\n> `);
-            if (/^q$/i.test(step))
-                return "fleet: quit without writing";
-            if (!step)
-                continue;
-            if (step === "1") {
+            const auto = autoPrefer?.[shape] && !overlayShapes.has(shape) ? "  (auto-prefer active)" : "";
+            return `${shape}  →  ${now}${auto}`;
+        });
+        const shapesTitle = "step 4/4 · shape routing";
+        const shapesLegend = "↑↓/jk move · a auto · p pin · t tier · f prefer · enter next · esc/q quit";
+        let sCursor = 0;
+        term.frame(listFrame(shapesTitle, shapesLegend, shapeRows(), sCursor));
+        for (;;) {
+            const k = await term.key();
+            if (isAbort(k))
+                return QUIT;
+            if (isNext(k))
+                break;
+            const shape = SHAPES[sCursor];
+            const entry = editable.map[shape] ?? {};
+            let changed = false;
+            const moved = moveCursor(k, sCursor, SHAPES.length);
+            if (moved !== sCursor) {
+                sCursor = moved;
+                changed = true;
+            }
+            else if (k.name === "a") {
                 const next = { ...entry };
                 delete next.pin;
                 editable.map[shape] = next;
+                changed = true;
             }
-            else if (step === "2") {
-                const pin = await ask(rl, "pin adapter:model> ");
+            else if (k.name === "p") {
+                const pin = await term.askTyped("pin adapter:model> ");
                 const i = pin.indexOf(":");
                 if (i < 1)
                     return { out: "fleet: pin must be adapter:model", code: 1 };
                 editable.map[shape] = { pin: { via: pin.slice(0, i), model: pin.slice(i + 1) } };
+                changed = true;
             }
-            else if (step === "3") {
-                const tier = await ask(rl, `tier (${TIERS.join("|")})> `);
+            else if (k.name === "t") {
+                const tier = (await term.askTyped(`tier (${TIERS.join("|")})> `));
                 if (!TIERS.includes(tier))
                     return { out: `fleet: invalid tier ${tier}`, code: 1 };
                 const next = { ...entry, tier };
                 delete next.pin;
                 editable.map[shape] = next;
+                changed = true;
             }
-            else if (step === "4") {
-                const pref = await ask(rl, "prefer (comma-separated adapters or adapter:model)> ");
-                const prefer = pref.split(",").map((s) => s.trim()).filter(Boolean);
-                editable.map[shape] = { ...entry, prefer };
+            else if (k.name === "f") {
+                const pref = await term.askTyped("prefer (comma-separated adapters or adapter:model)> ");
+                editable.map[shape] = { ...entry, prefer: pref.split(",").map((s) => s.trim()).filter(Boolean) };
+                changed = true;
             }
+            if (changed)
+                term.frame(listFrame(shapesTitle, shapesLegend, shapeRows(), sCursor));
         }
-        // review — unified diff + confirm
+        // review — unified diff + typed confirm
         const before = currentRepoOverlayText(cwd);
         const after = proposedOverlayText(initial, editable, cwd);
         if (fleetEditableEquals(initial, editable) || before === after) {
             return "fleet: no overlay changes (empty diff)";
         }
         const diff = unifiedYamlDiff(before, after, repoOverlayPath(cwd));
-        process.stdout.write(`\n${diff}\n`);
-        const confirm = await ask(rl, "write overlay? [y/N] ");
+        output.write(`\n${diff}\n`);
+        const confirm = await term.askTyped("write overlay? [y/N] ");
         if (!/^y(?:es)?$/i.test(confirm))
             return "fleet: discarded overlay changes";
         const merged = fleetRepoOverlayFromDelta(initial, editable, readOverlayFile(repoOverlayPath(cwd)));
@@ -244,6 +370,6 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters())
         return `fleet: wrote ${path}`;
     }
     finally {
-        rl.close();
+        term.close();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.48.1",
+  "version": "1.49.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",