@gonrocca/nodd 0.1.1 → 0.2.0

package/src/models/picker.test.ts

@@ -3,130 +3,513 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { CANONICAL_STEPS } from "../manifest.ts";
 import { MECHANISM_PLACEHOLDER } from "./slots.ts";
-import { createPickerState, enter, moveCursor, renderRows, type PickerState } from "./picker.ts";
+import {
+  back,
+  createPickerState,
+  decodeKey,
+  enter,
+  navigate,
+  pickerTitle,
+  rebuildEntries,
+  submitText,
+  type PickerState,
+} from "./picker.ts";
 
 const groups = new Map([
-  ["anthropic", ["claude-sonnet-4-5", "claude-opus-4-1"]],
+  ["anthropic", ["claude-opus-4-1", "claude-sonnet-4-5"]],
   ["openai-codex", ["gpt-5-codex"]],
 ]);
 
-function open(models: Record<string, string> = {}): PickerState {
-  return createPickerState({ models, groups });
+function open(input: Partial<Parameters<typeof createPickerState>[0]> = {}): PickerState {
+  return createPickerState({ models: {}, thinking: {}, groups, ...input });
+}
+
+/** Move the cursor onto the row of the given kind, failing loudly if absent. */
+function focus(state: PickerState, kind: string, value?: string): PickerState {
+  const index = state.entries.findIndex((e) => e.kind === kind && (value === undefined || e.value === value));
+  assert.ok(index >= 0, `no ${kind} row${value ? ` for ${value}` : ""} in: ${state.entries.map((e) => e.kind)}`);
+  return { ...state, cursor: index } as PickerState;
+}
+
+/** Enter on the focused row, asserting the picker stays open. */
+function press(state: PickerState, kind: string, value?: string): PickerState {
+  const result = enter(focus(state, kind, value));
+  assert.equal(result.type, "state", `entering ${kind} should keep the picker open`);
+  if (result.type !== "state") throw new Error("unreachable");
+  return result.state;
+}
+
+/** Drill a slot all the way through provider → model → thinking. */
+function assign(state: PickerState, slot: string, provider: string, model: string, level: string): PickerState {
+  let next = press(state, "slot", slot);
+  next = press(next, "provider", provider);
+  next = press(next, "model", model);
+  return press(next, "thinking-level", level);
 }
 
 // ---------------------------------------------------------------------------
-// Display: seven steps, four of them mechanisms.
+// The main menu is profiles, not slots — a profile is what the agents read.
 // ---------------------------------------------------------------------------
-test("all seven canonical steps are displayed in protocol order", () => {
-  const rows = renderRows(open());
-  const stepRows = rows.filter((row) => row.kind === "step" || row.kind === "mechanism");
-  assert.deepEqual(stepRows.map((row) => row.id), [...CANONICAL_STEPS]);
-  assert.equal(stepRows.length, 7);
+test("the picker opens on the main screen with the cursor on the first row", () => {
+  const state = open();
+  assert.equal(state.screen, "main");
+  assert.equal(state.cursor, 0);
+  assert.ok(state.entries.length > 0);
 });
 
-test("the four mechanism rows say mecanismo · sin modelo and are not selectable", () => {
-  const mechanisms = renderRows(open()).filter((row) => row.kind === "mechanism");
-  assert.deepEqual(mechanisms.map((row) => row.id), ["authorize", "classify", "track", "close"]);
-  for (const row of mechanisms) {
-    assert.equal(row.value, MECHANISM_PLACEHOLDER);
-    assert.equal(row.selectable, false, `${row.id} must not be selectable`);
-  }
+test("the main screen lists one row per profile, sorted, plus new-profile and save", () => {
+  const state = open({ profiles: { quick: { models: {} }, careful: { models: {} } } });
+  const kinds = state.entries.map((e) => e.kind);
+  assert.deepEqual(
+    state.entries.filter((e) => e.kind === "profile").map((e) => e.value),
+    ["careful", "quick"],
+  );
+  assert.ok(kinds.includes("new-profile"));
+  assert.equal(kinds.at(-1), "save", "save-and-exit is the last row");
 });
 
-test("an assigned slot displays its model, an unassigned one its placeholder", () => {
-  const rows = renderRows(open({ implement: "anthropic/claude-opus-4-1" }));
-  assert.equal(rows.find((row) => row.id === "implement")!.value, "anthropic/claude-opus-4-1");
-  assert.equal(rows.find((row) => row.id === "explore")!.value, "sin asignar");
+test("the active profile is marked and the others are not", () => {
+  const state = open({ profiles: { quick: { models: {} }, careful: { models: {} } }, activeProfile: "quick" });
+  const rows = state.entries.filter((e) => e.kind === "profile");
+  assert.match(rows.find((e) => e.value === "quick")!.label, /activo/);
+  assert.ok(!/activo/.test(rows.find((e) => e.value === "careful")!.label));
 });
 
-test("there is a save row and a quit row, and they are selectable", () => {
-  const rows = renderRows(open());
-  const actions = rows.filter((row) => row.kind === "action");
-  assert.deepEqual(actions.map((row) => row.id), ["save", "quit"]);
-  for (const row of actions) assert.equal(row.selectable, true);
+test("a profile row summarises the providers it assigns", () => {
+  const state = open({
+    profiles: { mixed: { models: { implement: "anthropic/claude-opus-4-1", explore: "openai-codex/gpt-5-codex" } } },
+  });
+  const label = state.entries.find((e) => e.kind === "profile")!.label;
+  assert.match(label, /anthropic/);
+  assert.match(label, /openai-codex/);
+});
+
+test("with no profiles the menu offers editing the loose config; the row goes once one exists", () => {
+  assert.ok(open().entries.some((e) => e.kind === "edit-loose"));
+  assert.ok(!open({ profiles: { quick: { models: {} } } }).entries.some((e) => e.kind === "edit-loose"));
 });
 
 // ---------------------------------------------------------------------------
-// Navigation skips the non-selectable rows.
+// The slot screen: NODD's slots, with the four mechanisms shown but inert.
 // ---------------------------------------------------------------------------
-test("the cursor starts on the first selectable row", () => {
-  const rows = renderRows(open());
-  assert.equal(rows[open().cursor].selectable, true);
-  assert.equal(rows[open().cursor].id, "default");
+test("the slot screen shows the two globals and all seven canonical steps in order", () => {
+  const slots = press(open(), "edit-loose");
+  assert.equal(slots.screen, "slots");
+  const shown = slots.entries.filter((e) => e.kind === "slot" || e.kind === "mechanism");
+  assert.deepEqual(shown.map((e) => e.value), ["default", "orchestrator", ...CANONICAL_STEPS]);
 });
 
-test("navigation skips mechanism rows entirely", () => {
-  let state = open();
-  const visited: string[] = [];
-  for (let i = 0; i < 12; i++) {
-    visited.push(renderRows(state)[state.cursor].id);
-    state = moveCursor(state, 1);
+test("the four mechanism rows say mecanismo · sin modelo and cannot be entered", () => {
+  const slots = press(open(), "edit-loose");
+  const mechanisms = slots.entries.filter((e) => e.kind === "mechanism");
+  assert.deepEqual(mechanisms.map((e) => e.value), ["authorize", "classify", "track", "close"]);
+  for (const row of mechanisms) {
+    assert.ok(row.label.includes(MECHANISM_PLACEHOLDER), `${row.value}: ${row.label}`);
   }
-  for (const mechanism of ["authorize", "classify", "track", "close"]) {
-    assert.ok(!visited.includes(mechanism), `the cursor must never land on ${mechanism}`);
+
+  // Entering one must not open a provider list: the slot does not exist.
+  for (const mechanism of mechanisms) {
+    const after = press(slots, "mechanism", mechanism.value);
+    assert.equal(after.screen, "slots", `${mechanism.value} must not drill anywhere`);
+    assert.equal(after.drillSlot, null);
+    assert.match(after.notice ?? "", /mecanismo/, "the refusal must say why, not just do nothing");
   }
-  assert.deepEqual([...new Set(visited)], ["default", "orchestrator", "explore", "resolve-uncertainty", "implement", "save", "quit"]);
 });
 
-test("the cursor wraps at both ends and never leaves a selectable row", () => {
-  let state = open();
-  const up = moveCursor(state, -1);
-  assert.equal(renderRows(up)[up.cursor].id, "quit", "moving up from the top wraps to the last row");
-
-  for (let i = 0; i < 30; i++) {
-    state = moveCursor(state, i % 2 === 0 ? 1 : -1);
-    assert.equal(renderRows(state)[state.cursor].selectable, true);
+test("navigation never lands the cursor on a mechanism row", () => {
+  let state = press(open(), "edit-loose");
+  const visited: string[] = [];
+  for (let i = 0; i < state.entries.length * 2; i++) {
+    visited.push(state.entries[state.cursor].kind);
+    state = navigate(state, 1);
   }
+  assert.ok(!visited.includes("mechanism"), "the cursor must skip every mechanism row");
+  assert.ok(visited.includes("slot"), "the scan must actually have walked the slot rows");
+});
+
+test("a slot row shows its model and thinking level, or a placeholder", () => {
+  const slots = press(open({ models: { implement: "anthropic/claude-opus-4-1" }, thinking: { implement: "high" } }), "edit-loose");
+  const implement = slots.entries.find((e) => e.value === "implement")!;
+  assert.match(implement.label, /anthropic\/claude-opus-4-1/);
+  assert.match(implement.label, /high/);
+  assert.match(slots.entries.find((e) => e.value === "explore")!.label, /sin asignar/);
 });
 
 // ---------------------------------------------------------------------------
-// Outcomes: quit writes nothing, save returns the assignment set.
+// Editing: provider → model → thinking, committed atomically at the level.
 // ---------------------------------------------------------------------------
-test("quit returns no changes", () => {
-  let state = open({ implement: "anthropic/claude-opus-4-1" });
-  state = { ...state, staged: { ...state.staged, explore: "openai-codex/gpt-5-codex" } };
+test("entering a slot opens the providers of the live registry, sorted, plus a custom row", () => {
+  const providers = press(press(open(), "edit-loose"), "slot", "implement");
+  assert.equal(providers.screen, "provider");
+  assert.equal(providers.drillSlot, "implement");
+  assert.deepEqual(
+    providers.entries.filter((e) => e.kind === "provider").map((e) => e.value),
+    ["anthropic", "openai-codex"],
+  );
+  assert.ok(providers.entries.some((e) => e.kind === "custom-provider"));
+});
 
-  const rows = renderRows(state);
-  state = { ...state, cursor: rows.findIndex((row) => row.id === "quit") };
+test("entering a provider opens that provider's models plus a custom row", () => {
+  const models = press(press(press(open(), "edit-loose"), "slot", "implement"), "provider", "anthropic");
+  assert.equal(models.screen, "model");
+  assert.equal(models.drillProvider, "anthropic");
+  assert.deepEqual(
+    models.entries.filter((e) => e.kind === "model").map((e) => e.value),
+    ["claude-opus-4-1", "claude-sonnet-4-5"],
+  );
+  assert.ok(models.entries.some((e) => e.kind === "custom-model"));
+});
 
-  assert.deepEqual(enter(state), { type: "quit" });
+test("with no registry the provider screen is skipped: there is nothing to list", () => {
+  const state = press(press(open({ groups: new Map() }), "edit-loose"), "slot", "implement");
+  assert.equal(state.screen, "model", "an empty provider list must not be shown as a screen");
+  assert.equal(state.drillProvider, null);
+  assert.ok(state.entries.some((e) => e.kind === "custom-model"), "the typed escape is the only way through");
+
+  // A bare model id with no provider is what the registry-free path produces,
+  // and it is exactly what `validateAssignment` accepts. The typed row has to be
+  // entered first: `submitText` only commits against an open prompt.
+  const typed = submitText(press(state, "custom-model"), "some-model");
+  const committed = press(press(typed, "thinking-level", "medium"), "slot", "implement");
+  assert.equal(committed.edits.models.implement, "some-model");
+});
+
+test("choosing a model stages nothing yet: it advances to the thinking screen", () => {
+  let state = press(press(open(), "edit-loose"), "slot", "implement");
+  state = press(state, "provider", "anthropic");
+  state = press(state, "model", "claude-opus-4-1");
+
+  assert.equal(state.screen, "thinking");
+  assert.equal(state.drillModel, "claude-opus-4-1");
+  assert.deepEqual(state.edits.models, {}, "nothing is committed before a level is chosen");
+  assert.equal(state.edits.changed, false);
 });
 
-test("save returns the staged assignment set", () => {
-  let state = open({ implement: "anthropic/claude-opus-4-1" });
-  state = { ...state, staged: { ...state.staged, explore: "openai-codex/gpt-5-codex" } };
+test("the thinking screen offers exactly the six real levels", () => {
+  let state = press(press(open(), "edit-loose"), "slot", "implement");
+  state = press(press(state, "provider", "anthropic"), "model", "claude-opus-4-1");
+  assert.deepEqual(state.entries.map((e) => e.value), ["off", "minimal", "low", "medium", "high", "xhigh"]);
+});
 
-  const rows = renderRows(state);
-  state = { ...state, cursor: rows.findIndex((row) => row.id === "save") };
+test("choosing a level commits provider, model and level together, and returns to the slots", () => {
+  const state = assign(press(open(), "edit-loose"), "implement", "anthropic", "claude-opus-4-1", "xhigh");
 
-  assert.deepEqual(enter(state), {
-    type: "save",
-    models: { implement: "anthropic/claude-opus-4-1", explore: "openai-codex/gpt-5-codex" },
+  assert.deepEqual(state.edits.models, { implement: "anthropic/claude-opus-4-1" });
+  assert.deepEqual(state.edits.thinking, { implement: "xhigh" });
+  assert.equal(state.edits.changed, true);
+  assert.equal(state.screen, "slots");
+  assert.equal(state.drillSlot, null, "the drill context is cleared after the commit");
+  assert.equal(state.drillModel, null);
+});
+
+test("escaping the thinking screen commits no partial edit", () => {
+  let state = press(press(open(), "edit-loose"), "slot", "implement");
+  state = press(press(state, "provider", "anthropic"), "model", "claude-opus-4-1");
+
+  const result = back(state);
+  assert.equal(result.type, "state");
+  if (result.type !== "state") return;
+  assert.deepEqual(result.state.edits.models, {}, "a model with no level must not be written");
+  assert.deepEqual(result.state.edits.thinking, {});
+  assert.equal(result.state.drillModel, null);
+  assert.equal(result.state.screen, "slots");
+});
+
+test("a typed provider and a typed model reach the same commit path", () => {
+  let state = press(press(open(), "edit-loose"), "slot", "implement");
+  state = press(state, "custom-provider");
+  assert.equal(state.textPrompt?.for, "provider");
+
+  state = submitText(state, "  my-provider  ");
+  assert.equal(state.screen, "model", "a typed provider advances to the model list");
+  assert.equal(state.drillProvider, "my-provider", "the typed value is trimmed");
+  assert.equal(state.textPrompt, null);
+
+  state = press(state, "custom-model");
+  state = submitText(state, "my-model");
+  assert.equal(state.screen, "thinking", "a typed model still goes through the level screen");
+  state = press(state, "thinking-level", "low");
+  assert.deepEqual(state.edits.models, { implement: "my-provider/my-model" });
+  assert.deepEqual(state.edits.thinking, { implement: "low" });
+});
+
+test("an empty typed value commits nothing and just closes the prompt", () => {
+  let state = press(press(open(), "edit-loose"), "slot", "implement");
+  state = press(state, "custom-provider");
+  const after = submitText(state, "   ");
+  assert.equal(after.textPrompt, null);
+  assert.equal(after.screen, "provider", "the list comes back unchanged");
+  assert.equal(after.drillProvider, null);
+});
+
+// ---------------------------------------------------------------------------
+// Profiles: create, edit, activate, duplicate, delete — all staged.
+// ---------------------------------------------------------------------------
+test("opening a profile offers activate, edit, duplicate and delete", () => {
+  const state = press(open({ profiles: { quick: { models: {} } } }), "profile", "quick");
+  assert.equal(state.screen, "profile-actions");
+  assert.equal(state.drillProfile, "quick");
+  assert.deepEqual(state.entries.map((e) => e.kind), [
+    "profile-use",
+    "profile-edit",
+    "profile-duplicate",
+    "profile-delete",
+  ]);
+});
+
+test("the already-active profile says so instead of offering activation", () => {
+  const state = press(open({ profiles: { quick: { models: {} } }, activeProfile: "quick" }), "profile", "quick");
+  assert.deepEqual(state.entries.map((e) => e.kind), [
+    "profile-active-noop",
+    "profile-edit",
+    "profile-duplicate",
+    "profile-delete",
+  ]);
+  // The informational row does nothing at all.
+  const after = press(state, "profile-active-noop");
+  assert.equal(after.screen, "profile-actions");
+});
+
+test("editing a profile loads its slots without activating it", () => {
+  let state = open({
+    profiles: { quick: { models: { implement: "openai-codex/gpt-5-codex" }, thinking: { implement: "low" } } },
+    activeProfile: null,
   });
+  state = press(press(state, "profile", "quick"), "profile-edit");
+
+  assert.equal(state.screen, "slots");
+  assert.equal(state.edits.editingProfile, "quick");
+  assert.equal(state.edits.activeProfile, null, "editing is not activating");
+  assert.deepEqual(state.edits.models, { implement: "openai-codex/gpt-5-codex" });
+  assert.deepEqual(state.edits.thinking, { implement: "low" });
 });
 
-test("entering a slot row opens that slot's model list", () => {
-  const state = open();
-  const result = enter(state);
-  assert.equal(result.type, "choose");
-  if (result.type !== "choose") return;
-  assert.equal(result.slot, "default");
-  assert.deepEqual(result.options, ["anthropic/claude-sonnet-4-5", "anthropic/claude-opus-4-1", "openai-codex/gpt-5-codex"]);
+test("the title names what is being edited and whether it is active", () => {
+  const state = open({ profiles: { quick: { models: {} }, slow: { models: {} } }, activeProfile: "quick" });
+  assert.match(pickerTitle(state), /nodd/);
+
+  const editingActive = press(press(state, "profile", "quick"), "profile-edit");
+  assert.match(pickerTitle(editingActive), /quick/);
+  assert.match(pickerTitle(editingActive), /activo/);
+
+  const editingOther = press(press(state, "profile", "slow"), "profile-edit");
+  assert.match(pickerTitle(editingOther), /slow/);
+  assert.match(pickerTitle(editingOther), /no activo/);
+
+  assert.match(pickerTitle(press(open(), "edit-loose")), /sin perfil/);
+});
+
+test("creating the first profile names it in the title, not 'sin perfil'", () => {
+  // The first profile activates itself, and the slots opened right after are
+  // that profile's. A title reading "sin perfil" while editing «rapido» tells
+  // the user their choices are going somewhere other than where they are going.
+  const created = submitText(press(open(), "new-profile"), "rapido");
+
+  assert.equal(created.screen, "slots");
+  assert.match(pickerTitle(created), /rapido/);
+  assert.ok(!/sin perfil/.test(pickerTitle(created)), "the slots being edited belong to the new profile");
+});
+
+test("an edit lands in the profile being edited, not in the active one", () => {
+  let state = open({
+    profiles: { quick: { models: { implement: "openai-codex/gpt-5-codex" } }, slow: { models: {} } },
+    activeProfile: "quick",
+  });
+  state = press(press(state, "profile", "slow"), "profile-edit");
+  state = assign(state, "implement", "anthropic", "claude-opus-4-1", "high");
+
+  const result = back(state);
+  assert.equal(result.type, "state");
+  if (result.type !== "state") return;
+  assert.deepEqual(result.state.edits.profiles.slow, {
+    models: { implement: "anthropic/claude-opus-4-1" },
+    thinking: { implement: "high" },
+  });
+  assert.deepEqual(
+    result.state.edits.profiles.quick,
+    { models: { implement: "openai-codex/gpt-5-codex" } },
+    "the active profile must not be touched by editing another",
+  );
+});
+
+test("leaving the slot screen folds the edits into the profile they belong to", () => {
+  let state = open({ profiles: { quick: { models: {} } }, activeProfile: "quick" });
+  state = press(press(state, "profile", "quick"), "profile-edit");
+  state = assign(state, "explore", "anthropic", "claude-sonnet-4-5", "medium");
+  assert.deepEqual(state.edits.profiles.quick, { models: {} }, "not folded in until the screen is left");
+
+  const result = back(state);
+  assert.equal(result.type, "state");
+  if (result.type !== "state") return;
+  assert.deepEqual(result.state.edits.profiles.quick.models, { explore: "anthropic/claude-sonnet-4-5" });
+});
+
+test("activating a profile switches the live models and says a restart is needed", () => {
+  let state = open({
+    profiles: { quick: { models: { implement: "openai-codex/gpt-5-codex" } }, slow: { models: {} } },
+    activeProfile: "slow",
+  });
+  state = press(press(state, "profile", "quick"), "profile-use");
+
+  assert.equal(state.edits.activeProfile, "quick");
+  assert.deepEqual(state.edits.models, { implement: "openai-codex/gpt-5-codex" });
+  assert.equal(state.screen, "main");
+  assert.match(state.notice ?? "", /quick/);
 });
 
-test("staging a choice does not write and is visible in the rows", () => {
-  let state = open();
-  state = { ...state, staged: { ...state.staged, default: "anthropic/claude-opus-4-1" } };
-  assert.equal(renderRows(state).find((row) => row.id === "default")!.value, "anthropic/claude-opus-4-1");
-  assert.deepEqual(open().staged, {}, "the initial state stages nothing");
+test("creating a profile asks for a name, then opens its slots", () => {
+  let state = press(open(), "new-profile");
+  assert.equal(state.textPrompt?.for, "new-profile");
+
+  state = submitText(state, "fresh");
+  assert.equal(state.screen, "slots");
+  assert.ok("fresh" in state.edits.profiles);
+  assert.equal(state.edits.activeProfile, "fresh", "the very first profile is activated on creation");
+});
+
+test("creating a second profile does not steal the activation", () => {
+  let state = open({ profiles: { quick: { models: {} } }, activeProfile: "quick" });
+  state = submitText(press(state, "new-profile"), "second");
+  assert.equal(state.edits.activeProfile, "quick");
+  assert.equal(state.edits.editingProfile, "second");
+});
+
+test("an invalid or duplicate name creates nothing and says why", () => {
+  for (const bad of ["Bad Name", "use", ""]) {
+    const state = submitText(press(open(), "new-profile"), bad);
+    assert.deepEqual(state.edits.profiles, {}, `${bad} must create nothing`);
+    if (bad !== "") assert.match(state.notice ?? "", /inválido|invalido/i, `${bad} must be explained`);
+  }
+
+  const dup = submitText(press(open({ profiles: { quick: { models: {} } } }), "new-profile"), "quick");
+  assert.match(dup.notice ?? "", /quick/);
+  assert.deepEqual(Object.keys(dup.edits.profiles), ["quick"], "an existing profile is never overwritten by a name");
+});
+
+test("duplicating clones the chosen profile under a new name", () => {
+  let state = open({ profiles: { quick: { models: { implement: "anthropic/claude-opus-4-1" } } } });
+  state = press(press(state, "profile", "quick"), "profile-duplicate");
+  assert.equal(state.textPrompt?.for, "duplicate-profile");
+
+  state = submitText(state, "copy");
+  assert.deepEqual(state.edits.profiles.copy, { models: { implement: "anthropic/claude-opus-4-1" } });
+  assert.equal(state.screen, "main");
+});
+
+test("deleting a profile drops it and clears the activation it held", () => {
+  let state = open({ profiles: { quick: { models: {} }, slow: { models: {} } }, activeProfile: "quick" });
+  state = press(press(state, "profile", "quick"), "profile-delete");
+
+  assert.deepEqual(Object.keys(state.edits.profiles), ["slow"]);
+  assert.equal(state.edits.activeProfile, null);
+  assert.equal(state.screen, "main");
+  assert.match(state.notice ?? "", /quick/);
+});
+
+// ---------------------------------------------------------------------------
+// Going back, and leaving without writing.
+// ---------------------------------------------------------------------------
+test("esc walks back one screen at a time: model → provider is not skipped", () => {
+  let state = press(press(open(), "edit-loose"), "slot", "implement");
+  state = press(state, "provider", "anthropic");
+
+  const toProvider = back(state);
+  assert.equal(toProvider.type, "state");
+  if (toProvider.type !== "state") return;
+  assert.equal(toProvider.state.screen, "provider", "esc from the models returns to the providers");
+  assert.equal(toProvider.state.drillProvider, null);
+
+  const toSlots = back(toProvider.state);
+  assert.equal(toSlots.type === "state" && toSlots.state.screen, "slots");
+});
+
+test("esc from the slot screen returns to the menu, and from the menu it quits", () => {
+  const slots = press(open(), "edit-loose");
+  const toMain = back(slots);
+  assert.equal(toMain.type === "state" && toMain.state.screen, "main");
+
+  assert.deepEqual(back(toMain.type === "state" ? toMain.state : slots), { type: "quit" });
+});
+
+test("quit is the only way out that writes nothing, and save carries the edits", () => {
+  let state = assign(press(open(), "edit-loose"), "implement", "anthropic", "claude-opus-4-1", "high");
+  const toMain = back(state);
+  assert.equal(toMain.type, "state");
+  if (toMain.type !== "state") return;
+
+  assert.deepEqual(back(toMain.state), { type: "quit" }, "quit returns no edits at all");
+
+  const saved = enter(focus(toMain.state, "save"));
+  assert.equal(saved.type, "save");
+  if (saved.type !== "save") return;
+  assert.deepEqual(saved.state.edits.models, { implement: "anthropic/claude-opus-4-1" });
+  assert.deepEqual(saved.state.edits.thinking, { implement: "high" });
+});
+
+test("saving folds the open edits into their profile first", () => {
+  let state = open({ profiles: { quick: { models: {} } }, activeProfile: "quick" });
+  state = press(press(state, "profile", "quick"), "profile-edit");
+  state = assign(state, "implement", "anthropic", "claude-opus-4-1", "high");
+
+  // Save lives on the main menu, so this leaves the slot screen first — which is
+  // the point: the edits have to survive the trip and land in their profile.
+  const menu = back(state);
+  assert.equal(menu.type, "state");
+  if (menu.type !== "state") return;
+
+  const saved = enter(focus(menu.state, "save"));
+  assert.equal(saved.type, "save");
+  if (saved.type !== "save") return;
+  assert.deepEqual(saved.state.edits.profiles.quick.models, { implement: "anthropic/claude-opus-4-1" });
+});
+
+// ---------------------------------------------------------------------------
+// Rows, cursors and keys.
+// ---------------------------------------------------------------------------
+test("rebuildEntries is idempotent and clamps a cursor past the last row", () => {
+  const state = open({ profiles: { quick: { models: {} } } });
+  assert.deepEqual(rebuildEntries({ ...state }).entries, state.entries);
+
+  const clamped = rebuildEntries({ ...state, cursor: 99 });
+  assert.equal(clamped.cursor, clamped.entries.length - 1);
+  assert.equal(rebuildEntries({ ...state, cursor: -5 }).cursor, 0);
+});
+
+test("the cursor wraps at both ends", () => {
+  const state = open({ profiles: { quick: { models: {} } } });
+  assert.equal(navigate({ ...state, cursor: 0 }, -1).cursor, state.entries.length - 1);
+  assert.equal(navigate({ ...state, cursor: state.entries.length - 1 }, 1).cursor, 0);
+  assert.equal(navigate({ ...state, cursor: 0 }, 1).cursor, 1);
+});
+
+test("decodeKey accepts the legacy, SS3 and kitty forms of every picker key", () => {
+  assert.equal(decodeKey("\u001b[A"), "up");
+  assert.equal(decodeKey("\u001bOA"), "up");
+  assert.equal(decodeKey("\u001b[1;1:1A"), "up", "kitty press");
+  assert.equal(decodeKey("\u001b[1;1:2A"), "up", "kitty repeat: holding the key scrolls");
+  assert.equal(decodeKey("\u001b[B"), "down");
+  assert.equal(decodeKey("\u001b[1;1:1B"), "down");
+  assert.equal(decodeKey("\r"), "enter");
+  assert.equal(decodeKey("\n"), "enter");
+  assert.equal(decodeKey("\u001b[13u"), "enter");
+  assert.equal(decodeKey("\u001b"), "esc");
+  assert.equal(decodeKey("\u001b[27u"), "esc");
+  assert.equal(decodeKey("\u007f"), "backspace");
+  assert.equal(decodeKey("\u001b[127u"), "backspace");
+});
+
+test("decodeKey ignores releases, modified keys and printable text", () => {
+  assert.equal(decodeKey("\u001b[1;1:3A"), null, "a key release must not navigate");
+  assert.equal(decodeKey("\u001b[1;5A"), null, "ctrl+up is not a picker key");
+  assert.equal(decodeKey("q"), null);
+  assert.equal(decodeKey("A"), null);
+  assert.equal(decodeKey(""), null);
 });
 
 // ---------------------------------------------------------------------------
 // The module boundary is the point: no fs, no pi, no TUI.
 // ---------------------------------------------------------------------------
 test("the picker imports no node:fs, no pi and no TUI package", () => {
-  // Comments are free to name what the module refuses to import; executable
-  // lines are not.
   const source = readFileSync(new URL("./picker.ts", import.meta.url), "utf8")
     .split("\n")
     .filter((line) => !/^\s*(\/\/|\*|\/\*)/.test(line))
@@ -139,3 +522,10 @@ test("the picker imports no node:fs, no pi and no TUI package", () => {
     assert.ok(specifier.startsWith("."), `unexpected external import: ${specifier}`);
   }
 });
+
+test("no transition writes: every one returns state the caller may discard", () => {
+  // The guarantee behind "quit writes nothing" is structural, not a promise about
+  // a code path: the module cannot write, so only the command can.
+  const source = readFileSync(new URL("./picker.ts", import.meta.url), "utf8");
+  assert.ok(!/writeFileSync|readFileSync/.test(source), "the state machine performs no IO");
+});