@gonrocca/nodd 0.1.1 → 0.2.0

package/src/models/picker.ts

@@ -1,98 +1,677 @@
 // The picker's decisions, as a pure state machine.
 //
-// Dependency-free by design, after `zero-models-picker.ts:5-11`: no `node:fs`,
-// no pi, and above all no TUI package — not even as a type. The host in
-// `extensions/nodd-models.ts` owns rendering and keystrokes and holds one
-// `PickerState`; every navigation and staging decision is here, where
+// Adapted from `zero-models-picker.ts` — adapted, never imported. Dependency-free
+// by design: no `node:fs`, no pi, and above all no TUI package, not even as a
+// type. The host in `extensions/nodd-models.ts` owns rendering and keystrokes and
+// holds one `PickerState`; every navigation and staging decision is here, where
 // `node --test` can reach it without a terminal.
 //
-// Two properties the tests pin down, because both are easy to lose in a
-// refactor: the four mechanism rows are displayed but never selectable (a cursor
-// that can land on `classify` implies a slot that does not exist), and this
-// module writes nothing. It returns outcomes; the command decides.
+// Three properties the tests pin down, because all three are easy to lose in a
+// refactor:
+//
+//  1. The four mechanism rows are displayed but never enterable, and entering one
+//     explains why rather than doing nothing. A cursor that can land on
+//     `classify` implies a slot that does not exist.
+//  2. This module writes nothing. It returns outcomes; the command decides. That
+//     is what makes "quit writes nothing" structural instead of a promise about a
+//     code path.
+//  3. Model, provider and level commit together, at the level screen. Escaping
+//     before it leaves the slot exactly as it was — a model saved without a level
+//     would run at an effort nobody chose.
+//
+// Forge's autotune screen is deliberately absent: autotune is a forge feature and
+// NODD has no learning loop to configure.
 
-import { SLOT_ROWS, type SlotRow } from "./slots.ts";
+import { SLOT_ROWS, isMechanismSlot } from "./slots.ts";
+import { THINKING_LEVELS, type SlotThinking, type ThinkingLevel } from "./thinking.ts";
+import { isValidProfileName, type Profile } from "./profiles.ts";
 
-export type Row = SlotRow & {
-  /** `action` rows are save/quit; the rest come from the slot table. */
-  kind: SlotRow["kind"] | "action";
-  /** The model to show, or the row's placeholder. */
+/** Which sub-screen the picker is showing. */
+export type Screen = "main" | "slots" | "provider" | "model" | "thinking" | "profile-actions";
+
+/** One row of the current screen. */
+export type MenuEntry = {
+  kind:
+    | "profile" // a concrete profile                    (main)
+    | "new-profile" // — nuevo perfil —                  (main)
+    | "edit-loose" // configurar sin perfil              (main, only with none)
+    | "save" // — guardar y salir —                      (main)
+    | "profile-use" // activar                           (profile-actions)
+    | "profile-active-noop" // ya está activo            (profile-actions)
+    | "profile-edit" // editar modelos por slot          (profile-actions)
+    | "profile-duplicate" // duplicar                    (profile-actions)
+    | "profile-delete" // borrar                         (profile-actions)
+    | "slot" // an assignable slot                       (slots)
+    | "mechanism" // a displayed, inert canonical step   (slots)
+    | "provider" // a concrete provider id               (provider)
+    | "custom-provider" // — otro provider (escribir) —
+    | "model" // a concrete model id                     (model)
+    | "custom-model" // — otro modelo (escribir) —
+    | "thinking-level"; // off | minimal | … | xhigh     (thinking)
+  label: string;
+  /** Payload: profile name, slot id, provider id, model id or level. */
   value: string;
-  selectable: boolean;
+};
+
+/** Edits accumulated in memory. Written to `nodd.json` once, on save. */
+export type StagedEdits = {
+  /** slot -> `provider/model`, for the slot set currently being edited. */
+  models: Record<string, string>;
+  /** slot -> level, parallel to `models`. Partial: an absent slot has no level. */
+  thinking: SlotThinking;
+  /** Any slot assignment changed. */
+  changed: boolean;
+  profiles: Record<string, Profile>;
+  activeProfile: string | null;
+  /**
+   * The profile the maps above are editing. `null` means the loose config, which
+   * is the active profile's content when there is one. Distinct from
+   * `activeProfile`: a profile can be edited without being activated.
+   */
+  editingProfile: string | null;
+  /** A profile was created, deleted, duplicated or activated. */
+  profilesChanged: boolean;
 };
 
 export type PickerState = {
+  screen: Screen;
   cursor: number;
-  /** slot -> `provider/model`, as read from config. */
-  models: Record<string, string>;
-  /** Edits not yet saved. Empty until the user chooses something. */
-  staged: Record<string, string>;
+  /** Rows of the current screen — derived, never hand-mutated. */
+  entries: MenuEntry[];
+  edits: StagedEdits;
+  /** provider -> model ids, captured from pi's registry when the picker opened. */
   groups: Map<string, string[]>;
+  /** Drill context: the slot being edited. */
+  drillSlot: string | null;
+  /** Drill context: the provider chosen so far. */
+  drillProvider: string | null;
+  /** Drill context: the model chosen, awaiting a level. Held out of `edits`. */
+  drillModel: string | null;
+  /** Drill context: the profile chosen from the list. */
+  drillProfile: string | null;
+  /**
+   * Has a slot been edited since these maps were loaded? Decides whether to fold
+   * them into the target profile. `edits.changed` will not do: it is sticky for
+   * the whole picker, so after editing one profile, opening a second would fold
+   * untouched maps over it.
+   */
+  dirtySinceLoad: boolean;
+  /** When set, the host shows an inline text input for this. */
+  textPrompt: { for: "provider" | "model" | "new-profile" | "duplicate-profile"; label: string } | null;
+  /** A one-line notice under the title. Cleared by the next transition. */
+  notice: string | null;
 };
 
 export type EnterResult =
-  | { type: "choose"; slot: string; options: string[] }
-  | { type: "save"; models: Record<string, string> }
-  | { type: "quit" };
+  | { type: "state"; state: PickerState } // stay open, re-render
+  | { type: "save"; state: PickerState } // close, persist the edits
+  | { type: "quit" }; // close, write nothing
 
-const ACTION_ROWS: Row[] = [
-  { id: "save", kind: "action", placeholder: "", value: "— guardar y salir —", selectable: true },
-  { id: "quit", kind: "action", placeholder: "", value: "— salir sin guardar —", selectable: true },
-];
+const CUSTOM_PROVIDER_LABEL = "— otro provider (escribir) —";
+const CUSTOM_MODEL_LABEL = "— otro modelo (escribir) —";
+const SAVE_LABEL = "— guardar y salir —";
+const NEW_PROFILE_LABEL = "— nuevo perfil —";
+const LOOSE_LABEL = "— configurar modelos sin perfil —";
 
 export function createPickerState(input: {
   models: Record<string, string>;
+  thinking: SlotThinking;
   groups: Map<string, string[]>;
+  profiles?: Record<string, Profile>;
+  activeProfile?: string | null;
 }): PickerState {
-  const state: PickerState = { cursor: 0, models: { ...input.models }, staged: {}, groups: input.groups };
-  // Start on a row the user can actually act on, whatever the table's shape.
-  return { ...state, cursor: nextSelectable(state, 0, 1) };
-}
-
-/** The full display, in order: globals, the seven steps, then the actions. */
-export function renderRows(state: PickerState): Row[] {
-  const assigned = { ...state.models, ...state.staged };
-  const slots = SLOT_ROWS.map((row): Row => ({
-    ...row,
-    value: row.kind === "mechanism" ? row.placeholder : assigned[row.id] ?? row.placeholder,
-    selectable: row.kind !== "mechanism",
-  }));
-  return [...slots, ...ACTION_ROWS];
-}
-
-/** Every `provider/model` pi can resolve, qualified, in registry order. */
-export function modelOptions(groups: Map<string, string[]>): string[] {
-  const out: string[] = [];
-  for (const [provider, ids] of groups) {
-    for (const id of ids) out.push(`${provider}/${id}`);
-  }
+  return rebuildEntries({
+    screen: "main",
+    cursor: 0,
+    entries: [],
+    edits: {
+      models: { ...input.models },
+      thinking: { ...input.thinking },
+      changed: false,
+      profiles: cloneProfiles(input.profiles ?? {}),
+      activeProfile: input.activeProfile ?? null,
+      // Editing starts on the live config, which is the active profile's content
+      // when there is one: so opening the picker and touching a slot edits it.
+      editingProfile: null,
+      profilesChanged: false,
+    },
+    groups: input.groups,
+    drillSlot: null,
+    drillProvider: null,
+    drillModel: null,
+    drillProfile: null,
+    dirtySinceLoad: false,
+    textPrompt: null,
+    notice: null,
+  });
+}
+
+/** Deep copy: staged edits must never mutate what the caller read from disk. */
+function cloneProfiles(profiles: Record<string, Profile>): Record<string, Profile> {
+  const out: Record<string, Profile> = {};
+  for (const [name, profile] of Object.entries(profiles)) out[name] = cloneProfile(profile);
   return out;
 }
 
-function nextSelectable(state: PickerState, from: number, step: number): number {
-  const rows = renderRows(state);
-  for (let i = 0; i < rows.length; i++) {
-    const index = (((from + i * step) % rows.length) + rows.length) % rows.length;
-    if (rows[index].selectable) return index;
+function cloneProfile(profile: Profile): Profile {
+  return profile.thinking
+    ? { models: { ...profile.models }, thinking: { ...profile.thinking } }
+    : { models: { ...profile.models } };
+}
+
+/** The maps being edited, as a profile. `thinking` is omitted when empty. */
+function snapshotEdits(edits: StagedEdits): Profile {
+  return Object.keys(edits.thinking).length > 0
+    ? { models: { ...edits.models }, thinking: { ...edits.thinking } }
+    : { models: { ...edits.models } };
+}
+
+/**
+ * Fold the maps being edited into the profile they belong to.
+ *
+ * The target is the profile being edited, or the active one when editing the
+ * loose config. With neither there is nowhere to fold and the maps stay as the
+ * flat config.
+ *
+ * Only folds when a slot was actually edited since these maps were loaded.
+ * Without that guard, merely opening another profile would overwrite the target
+ * with maps nobody touched.
+ */
+function flushEdits(state: PickerState): PickerState {
+  if (!state.dirtySinceLoad) return state;
+  const target = state.edits.editingProfile ?? state.edits.activeProfile;
+  if (target === null) return state;
+  return {
+    ...state,
+    edits: { ...state.edits, profiles: { ...state.edits.profiles, [target]: snapshotEdits(state.edits) } },
+    dirtySinceLoad: false,
+  };
+}
+
+/** Load a profile into the editing maps, folding the previous one first. */
+function loadProfile(state: PickerState, name: string): PickerState {
+  const profile = state.edits.profiles[name];
+  if (profile === undefined) return state;
+  const flushed = flushEdits(state);
+  return {
+    ...flushed,
+    edits: {
+      ...flushed.edits,
+      models: { ...profile.models },
+      thinking: { ...(profile.thinking ?? {}) },
+      editingProfile: name,
+    },
+    dirtySinceLoad: false,
+  };
+}
+
+/** The frame title: always say what is being touched. */
+export function pickerTitle(state: PickerState): string {
+  if (state.screen === "main") return "nodd · perfiles de modelos";
+  if (state.screen === "profile-actions") return `nodd · perfil «${state.drillProfile ?? ""}»`;
+
+  const editing = state.edits.editingProfile;
+  if (editing === null) return "nodd · modelos sin perfil";
+  return `nodd · perfil «${editing}»${editing === state.edits.activeProfile ? " · activo" : " · no activo"}`;
+}
+
+// ---------------------------------------------------------------------------
+// Rows per screen
+// ---------------------------------------------------------------------------
+
+/** The providers a profile assigns — a short summary for its menu row. */
+function profileSummary(profile: Profile): string {
+  const providers = new Set<string>();
+  for (const value of Object.values(profile.models)) {
+    const slash = value.indexOf("/");
+    if (slash > 0) providers.add(value.slice(0, slash));
+  }
+  return [...providers].sort().join(", ");
+}
+
+function profileRowLabel(state: PickerState, name: string): string {
+  const active = name === state.edits.activeProfile;
+  const bits = [active ? "activo" : "", profileSummary(state.edits.profiles[name])].filter((s) => s !== "");
+  return `${active ? "●" : "○"} ${name}${bits.length > 0 ? `   (${bits.join(" · ")})` : ""}`;
+}
+
+function mainEntries(state: PickerState): MenuEntry[] {
+  const entries: MenuEntry[] = [];
+
+  // Profiles first: a profile is what the generated agents actually read.
+  for (const name of Object.keys(state.edits.profiles).sort()) {
+    entries.push({ kind: "profile", label: profileRowLabel(state, name), value: name });
+  }
+  entries.push({ kind: "new-profile", label: NEW_PROFILE_LABEL, value: "" });
+
+  // The loose config is only offered while no profile exists — it is the state of
+  // someone who has not migrated, and the row goes when the first one is created.
+  if (Object.keys(state.edits.profiles).length === 0) {
+    entries.push({ kind: "edit-loose", label: LOOSE_LABEL, value: "loose" });
+  }
+
+  entries.push({ kind: "save", label: SAVE_LABEL, value: "save" });
+  return entries;
+}
+
+function profileActionEntries(state: PickerState): MenuEntry[] {
+  const name = state.drillProfile ?? "";
+  const isActive = name === state.edits.activeProfile;
+  return [
+    isActive
+      ? { kind: "profile-active-noop" as const, label: "● ya es el perfil activo", value: name }
+      : { kind: "profile-use" as const, label: "activar — los agentes de NODD usan este", value: name },
+    { kind: "profile-edit" as const, label: "editar modelos por slot…", value: name },
+    { kind: "profile-duplicate" as const, label: "duplicar en un perfil nuevo…", value: name },
+    {
+      kind: "profile-delete" as const,
+      label: isActive ? "borrar (queda sin perfil activo)" : "borrar",
+      value: name,
+    },
+  ];
+}
+
+/**
+ * The slot screen: the two globals, then the seven canonical steps in protocol
+ * order. The four mechanisms are rows like any other — visible, so the mechanized
+ * half of ODD stays legible — but their kind makes them inert.
+ */
+function slotEntries(state: PickerState): MenuEntry[] {
+  const width = Math.max(...SLOT_ROWS.map((row) => row.id.length));
+  return SLOT_ROWS.map((row): MenuEntry => {
+    if (isMechanismSlot(row.id)) {
+      return { kind: "mechanism", label: `${row.id.padEnd(width)}   ·   ${row.placeholder}`, value: row.id };
+    }
+    const model = state.edits.models[row.id] ?? row.placeholder;
+    const level = state.edits.thinking[row.id];
+    return {
+      kind: "slot",
+      label: `${row.id.padEnd(width)}   →   ${model}${level ? ` · thinking ${level}` : ""}`,
+      value: row.id,
+    };
+  });
+}
+
+function providerEntries(state: PickerState): MenuEntry[] {
+  const entries: MenuEntry[] = [...state.groups.keys()]
+    .sort()
+    .map((provider) => ({ kind: "provider" as const, label: provider, value: provider }));
+  entries.push({ kind: "custom-provider", label: CUSTOM_PROVIDER_LABEL, value: "" });
+  return entries;
+}
+
+function modelEntries(state: PickerState): MenuEntry[] {
+  const models = state.drillProvider !== null ? (state.groups.get(state.drillProvider) ?? []) : [];
+  const entries: MenuEntry[] = models.map((model) => ({ kind: "model" as const, label: model, value: model }));
+  entries.push({ kind: "custom-model", label: CUSTOM_MODEL_LABEL, value: "" });
+  return entries;
+}
+
+function thinkingEntries(): MenuEntry[] {
+  return THINKING_LEVELS.map((level) => ({ kind: "thinking-level" as const, label: level, value: level }));
+}
+
+/**
+ * Recompute `state.entries` for the current screen and drill context.
+ *
+ * Idempotent. Afterwards the cursor is clamped into range, so a transition that
+ * shrinks the row list never leaves the highlight out of bounds, and it is nudged
+ * off a mechanism row, which cannot be selected.
+ */
+export function rebuildEntries(state: PickerState): PickerState {
+  const entries =
+    state.screen === "main" ? mainEntries(state)
+    : state.screen === "slots" ? slotEntries(state)
+    : state.screen === "provider" ? providerEntries(state)
+    : state.screen === "model" ? modelEntries(state)
+    : state.screen === "thinking" ? thinkingEntries()
+    : profileActionEntries(state);
+
+  const clamped = entries.length === 0 ? 0 : Math.min(Math.max(0, state.cursor), entries.length - 1);
+  const next = { ...state, entries, cursor: clamped };
+  return entries[clamped]?.kind === "mechanism" ? navigate(next, 1) : next;
+}
+
+// ---------------------------------------------------------------------------
+// Cursor
+// ---------------------------------------------------------------------------
+
+/**
+ * Move the highlight by `dir`, wrapping at both ends and skipping the mechanism
+ * rows: they are displayed, never selected.
+ */
+export function navigate(state: PickerState, dir: -1 | 1): PickerState {
+  const n = state.entries.length;
+  if (n === 0) return { ...state, cursor: 0 };
+
+  for (let step = 1; step <= n; step++) {
+    const index = (state.cursor + dir * step + n * step) % n;
+    if (state.entries[index].kind !== "mechanism") return { ...state, cursor: index };
   }
-  return from;
+  return state;
 }
 
-/** Move the cursor, wrapping at both ends and skipping mechanism rows. */
-export function moveCursor(state: PickerState, step: number): PickerState {
-  const rows = renderRows(state);
-  const start = (((state.cursor + step) % rows.length) + rows.length) % rows.length;
-  return { ...state, cursor: nextSelectable(state, start, step >= 0 ? 1 : -1) };
+// ---------------------------------------------------------------------------
+// Keys
+// ---------------------------------------------------------------------------
+
+export type PickerKey = "up" | "down" | "enter" | "esc" | "backspace";
+
+/**
+ * One functional key under the kitty keyboard protocol: `CSI <code>`, an optional
+ * `;1` (no modifiers), an optional `:1` (press) or `:2` (repeat), then the final
+ * byte. A `:3` release or any real modifier does not match — releases must be
+ * ignored, and a modified key is not a picker key.
+ */
+function kittyPressOrRepeat(code: string, final: string): RegExp {
+  return new RegExp(`^\u001b\\[${code}(?:;1(?::[12])?)?${final}$`);
+}
+
+const KITTY_UP = kittyPressOrRepeat("1", "A");
+const KITTY_DOWN = kittyPressOrRepeat("1", "B");
+const KITTY_ENTER = kittyPressOrRepeat("13", "u");
+const KITTY_ESC = kittyPressOrRepeat("27", "u");
+const KITTY_BACKSPACE = kittyPressOrRepeat("127", "u");
+
+/**
+ * Decode one raw stdin sequence into a picker key, or `null` when it is not one.
+ *
+ * pi-tui negotiates kitty keyboard flags with the terminal, and a terminal that
+ * grants them encodes arrows as `CSI 1;1:1 A/B` and Esc as `CSI 27 u` — never the
+ * legacy forms. A terminal that does not keeps the legacy or SS3 forms. Both
+ * worlds are accepted, and kitty repeats navigate too so holding an arrow scrolls.
+ */
+export function decodeKey(data: string): PickerKey | null {
+  if (data === "\u001b[A" || data === "\u001bOA" || KITTY_UP.test(data)) return "up";
+  if (data === "\u001b[B" || data === "\u001bOB" || KITTY_DOWN.test(data)) return "down";
+  if (data === "\r" || data === "\n" || data === "\r\n" || KITTY_ENTER.test(data)) return "enter";
+  if (data === "\u001b" || KITTY_ESC.test(data)) return "esc";
+  if (data === "\u007f" || data === "\b" || KITTY_BACKSPACE.test(data)) return "backspace";
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Enter
+// ---------------------------------------------------------------------------
+
+/** Go to a screen with the cursor at the top and the rows rebuilt. */
+function goto(state: PickerState, screen: Screen, patch: Partial<PickerState> = {}): EnterResult {
+  return { type: "state", state: rebuildEntries({ ...state, ...patch, screen, cursor: 0 }) };
 }
 
 export function enter(state: PickerState): EnterResult {
-  const row = renderRows(state)[state.cursor];
-  if (row.id === "quit") return { type: "quit" };
-  if (row.id === "save") return { type: "save", models: { ...state.models, ...state.staged } };
-  return { type: "choose", slot: row.id, options: modelOptions(state.groups) };
+  const entry = state.entries[state.cursor];
+  if (!entry) return { type: "state", state };
+
+  // Any key that advances clears the previous transition's notice.
+  const current: PickerState = { ...state, notice: null };
+
+  switch (entry.kind) {
+    case "mechanism":
+      // Displayed, never assignable. Saying why beats a dead keypress: the model
+      // is not the problem, the slot does not exist.
+      return {
+        type: "state",
+        state: {
+          ...current,
+          notice: `${entry.value} es un mecanismo: es código determinista y no corre ningún modelo`,
+        },
+      };
+
+    case "slot":
+      // With no registry there is no provider list worth showing, so the typed
+      // escape on the model screen is the way through.
+      return goto(current, current.groups.size === 0 ? "model" : "provider", {
+        drillSlot: entry.value,
+        drillProvider: null,
+      });
+
+    case "provider":
+      return goto(current, "model", { drillProvider: entry.value });
+
+    case "custom-provider":
+      return { type: "state", state: { ...current, textPrompt: { for: "provider", label: entry.label } } };
+
+    case "custom-model":
+      return { type: "state", state: { ...current, textPrompt: { for: "model", label: entry.label } } };
+
+    case "model":
+      // Choosing a model does not commit: it stages the model and advances to the
+      // level screen, so model, provider and level are written together. An esc
+      // before that leaves `edits` untouched.
+      return goto(current, "thinking", { drillModel: entry.value });
+
+    case "thinking-level":
+      return goto(commitDrill(current, entry.value as ThinkingLevel), "slots", {
+        drillSlot: null,
+        drillProvider: null,
+        drillModel: null,
+      });
+
+    case "edit-loose":
+      return goto(current, "slots", { ...{ edits: { ...current.edits, editingProfile: null } } });
+
+    case "profile":
+      return goto(current, "profile-actions", { drillProfile: entry.value });
+
+    case "profile-active-noop":
+      // Informational row: there is nothing to activate.
+      return { type: "state", state: current };
+
+    case "new-profile":
+      return {
+        type: "state",
+        state: { ...current, textPrompt: { for: "new-profile", label: "nombre del perfil nuevo:" } },
+      };
+
+    case "profile-duplicate":
+      return {
+        type: "state",
+        state: {
+          ...current,
+          textPrompt: { for: "duplicate-profile", label: `nombre del duplicado de «${entry.value}»:` },
+        },
+      };
+
+    case "profile-edit":
+      // Load that profile's slots. This does not activate it: an inactive profile
+      // is editable.
+      return goto(loadProfile(current, entry.value), "slots");
+
+    case "profile-use": {
+      // Activating means that profile becomes the live config. What was being
+      // edited is folded in first, so no unsaved change is lost.
+      const loaded = loadProfile(current, entry.value);
+      return goto(
+        {
+          ...loaded,
+          edits: { ...loaded.edits, activeProfile: entry.value, profilesChanged: true, changed: true },
+        },
+        "main",
+        {
+          drillProfile: null,
+          notice: `perfil «${entry.value}» activo — guardá y reiniciá pi para que los agentes lo tomen`,
+        },
+      );
+    }
+
+    case "profile-delete": {
+      const profiles = { ...current.edits.profiles };
+      delete profiles[entry.value];
+      // Deleting does not change the models in use: it only removes the profile
+      // the edits would have been folded into.
+      return goto(
+        {
+          ...current,
+          edits: {
+            ...current.edits,
+            profiles,
+            profilesChanged: true,
+            activeProfile: current.edits.activeProfile === entry.value ? null : current.edits.activeProfile,
+            editingProfile: current.edits.editingProfile === entry.value ? null : current.edits.editingProfile,
+          },
+        },
+        "main",
+        { drillProfile: null, notice: `perfil «${entry.value}» borrado` },
+      );
+    }
+
+    case "save":
+      // Fold what is open into its profile before closing, or the slots just
+      // edited would never reach it.
+      return { type: "save", state: flushEdits(current) };
+  }
+}
+
+/** The single commit point: slot, provider, model and level, together. */
+function commitDrill(state: PickerState, level: ThinkingLevel): PickerState {
+  const { drillSlot, drillProvider, drillModel } = state;
+  if (drillSlot === null || drillModel === null) return state;
+
+  // No provider is a bare model id — which is what the empty-registry path
+  // produces, and what the command's validation accepts.
+  const qualified = drillProvider ? `${drillProvider}/${drillModel}` : drillModel;
+  return {
+    ...state,
+    edits: {
+      ...state.edits,
+      models: { ...state.edits.models, [drillSlot]: qualified },
+      thinking: { ...state.edits.thinking, [drillSlot]: level },
+      changed: true,
+    },
+    dirtySinceLoad: true,
+  };
 }
 
-/** Stage a choice. Nothing is written until the user picks the save row. */
-export function stage(state: PickerState, slot: string, model: string): PickerState {
-  return { ...state, staged: { ...state.staged, [slot]: model } };
+// ---------------------------------------------------------------------------
+// Esc
+// ---------------------------------------------------------------------------
+
+/**
+ * Go back one screen. From the main screen it quits, so the host closes the
+ * picker without writing anything.
+ *
+ * One screen at a time, not straight to the menu: the way out of a wrong model is
+ * the provider list, and the way out of a wrong provider is the slot list.
+ */
+export function back(state: PickerState): EnterResult {
+  const current: PickerState = { ...state, notice: null, textPrompt: null };
+
+  if (current.screen === "main") return { type: "quit" };
+
+  if (current.screen === "model") {
+    // One step back, to the providers. With no registry that screen was skipped,
+    // so returning to it would land on a screen the user never saw.
+    return current.groups.size === 0
+      ? goto(current, "slots", { drillSlot: null, drillProvider: null, drillModel: null })
+      : goto(current, "provider", { drillProvider: null, drillModel: null });
+  }
+  if (current.screen === "thinking") {
+    // The level is the last step of one atomic write, so esc aborts the whole
+    // commit rather than stepping back: clearing `drillModel` drops the model
+    // chosen without a level, and no partial edit is ever written.
+    return goto(current, "slots", { drillSlot: null, drillProvider: null, drillModel: null });
+  }
+  if (current.screen === "provider") {
+    return goto(current, "slots", { drillSlot: null, drillProvider: null, drillModel: null });
+  }
+
+  // Leaving the slot screen folds what was edited into its profile.
+  return goto(current.screen === "slots" ? flushEdits(current) : current, "main", {
+    drillSlot: null,
+    drillProvider: null,
+    drillModel: null,
+    drillProfile: null,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Typed values
+// ---------------------------------------------------------------------------
+
+/**
+ * Commit a value typed into the inline input opened by a `custom-*` row or a
+ * profile-name prompt. An empty or whitespace value is a no-op: the prompt closes
+ * and the list comes back unchanged, with nothing committed.
+ */
+export function submitText(state: PickerState, typed: string): PickerState {
+  const prompt = state.textPrompt;
+  const value = typed.trim();
+  const current: PickerState = { ...state, notice: null };
+
+  if (prompt === null || value === "") return rebuildEntries({ ...current, textPrompt: null });
+
+  if (prompt.for === "provider") {
+    return rebuildEntries({ ...current, textPrompt: null, screen: "model", cursor: 0, drillProvider: value });
+  }
+  if (prompt.for === "model") {
+    // Like the `model` row: stage it and go to the level screen. The commit is
+    // there, never here.
+    return rebuildEntries({ ...current, textPrompt: null, screen: "thinking", cursor: 0, drillModel: value });
+  }
+
+  return submitProfileName(current, prompt.for, value);
+}
+
+/** Create or duplicate a profile under a typed name. */
+function submitProfileName(
+  state: PickerState,
+  kind: "new-profile" | "duplicate-profile",
+  typed: string,
+): PickerState {
+  const name = typed.toLowerCase();
+  const cleared: PickerState = { ...state, textPrompt: null };
+
+  // An invalid or taken name says so and creates nothing: overwriting a profile
+  // by typing its name would be destructive and silent.
+  if (!isValidProfileName(name)) {
+    return rebuildEntries({ ...cleared, notice: `nombre inválido: «${typed}» (minúsculas, números, - y _)` });
+  }
+  if (name in cleared.edits.profiles) {
+    return rebuildEntries({ ...cleared, notice: `ya existe un perfil «${name}»` });
+  }
+
+  // A duplicate clones the chosen profile; a new one starts from whatever is
+  // being edited, which is what the user has in front of them.
+  const source =
+    kind === "duplicate-profile" && cleared.drillProfile !== null
+      ? cleared.edits.profiles[cleared.drillProfile]
+      : snapshotEdits(cleared.edits);
+
+  const created: PickerState = {
+    ...cleared,
+    edits: {
+      ...cleared.edits,
+      profiles: { ...cleared.edits.profiles, [name]: cloneProfile(source) },
+      profilesChanged: true,
+    },
+  };
+
+  if (kind === "duplicate-profile") {
+    return rebuildEntries({
+      ...created,
+      screen: "main",
+      cursor: 0,
+      drillProfile: null,
+      notice: `perfil «${name}» duplicado`,
+    });
+  }
+
+  // Creating opens it for editing: choosing the models is what you came to do.
+  const loaded = loadProfile(created, name);
+  // The first profile activates itself. Otherwise it would sit saved while the
+  // agents kept reading the loose config — a profile that does nothing.
+  const first = loaded.edits.activeProfile === null;
+  return rebuildEntries({
+    ...loaded,
+    // `loadProfile` already set `editingProfile`, and it stays set: the slots
+    // being opened are this profile's, so the title has to say so. Blanking it
+    // made the first profile read "sin perfil" while editing it.
+    edits: first ? { ...loaded.edits, activeProfile: name } : loaded.edits,
+    screen: "slots",
+    cursor: 0,
+    notice: first
+      ? `perfil «${name}» creado y activo — elegí los modelos`
+      : `perfil «${name}» creado — elegí los modelos (activar es aparte)`,
+  });
 }