@neosh/model 0.1.0

package/main.ts

@@ -0,0 +1,796 @@
+/**
+ * The model switcher, and the reasoning-effort switcher next to it.
+ *
+ * Both are the same thing twice: a picker over what the *driver* said it supports. The effort
+ * levels are not hard-coded here — they arrive as `ProviderOptionDescriptor`s attached to the
+ * chosen model, so a provider plugin that invents a new knob gets a working picker for it with no
+ * change to this file. That is the whole reason that descriptor type exists.
+ */
+
+import type {
+  AccountKind,
+  CredentialInfo,
+  Disposable,
+  ModelInfo,
+  CredentialSource,
+  ModelEntry,
+  ModelSelection,
+  ModelTier,
+  Neosh,
+  OptionSelection,
+  PluginContext,
+  ProviderOptionDescriptor,
+} from "@neosh/api";
+import type { PaneItem, RailItem } from "@neosh/api/ui";
+import { confirmDestructive, defineHighlights, picker, prompt, railPicker } from "@neosh/api/ui";
+import { installOptions, openOptions } from "./options.ts";
+
+export async function activate({ neosh, subscriptions }: PluginContext) {
+  await defineHighlights(neosh);
+
+  await neosh.opt.declare({
+    name: "model.picker.show_pricing",
+    type: { type: "bool" },
+    default: true,
+    description: "Show cost per million tokens beside each model, where the provider reports it.",
+  });
+
+  await neosh.cmd.register("model.pick", () => pickModel(neosh), {
+    desc: "Choose the model for this conversation",
+  });
+  await neosh.cmd.register("model.options", () => openOptions(neosh), {
+    desc: "Reasoning effort, and everything else this model can be told",
+  });
+  await neosh.cmd.register("provider.auth", () => pickProvider(neosh), {
+    desc: "Sign in to a provider, or forget a key",
+  });
+  await neosh.cmd.register("model.upgrade", () => step(neosh, 1), {
+    desc: "Move up one rung — to the more capable model this provider serves",
+  });
+  await neosh.cmd.register("model.downgrade", () => step(neosh, -1), {
+    desc: "Move down one rung — cheaper and quicker",
+  });
+  await neosh.cmd.register("model.line", (args) => useLine(neosh, args[0]), {
+    desc: "Switch to the current model in a line — `model.line opus`",
+  });
+
+  await neosh.keymap.set("chat", "<C-p>", "model.pick", { desc: "Pick a model" });
+  await neosh.keymap.set("chat", "<C-e>", "model.options", { desc: "Pick reasoning effort" });
+  // The rungs have no default key. They had `⌥↑` and `⌥↓`, which read well and are not keys a
+  // terminal can be relied on to send: a Mac terminal turns Option-arrow into a word motion or an
+  // escape sequence depending on a setting its owner has probably never opened, and a keyboard
+  // whose arrows live on a layer cannot hold Alt and reach them at all. Chat mode has no chord
+  // left to move them to, and inventing a two-key prefix for two rungs is a worse trade than the
+  // one row of `^P` they are already on.
+  //
+  // They stay ordinary commands, which is the part that matters: `^K` runs them by name, and one
+  // line in `init.ts` puts them on whichever key your keyboard actually has.
+  //
+  //     await neosh.keymap.set("chat", "<A-Up>", "model.upgrade");
+
+  // Deliberately *not* on the shortcut row. The key lives beside the model name in the footer,
+  // where the thing it changes is already being read — saying it twice costs a row and teaches
+  // nothing the first place did not.
+
+  // The footer. The model and its options belong beside the composer rather than on a settings
+  // page: they are the two things you change mid-conversation — and each carries its own key,
+  // because a key is only memorable next to the thing it changes.
+  /**
+   * `flash` lights the options segment for a moment before settling.
+   *
+   * The "it moved there" flash the palette reserves reverse for, and it is here rather than in the
+   * panel that was just dismissed for two reasons: it is where the setting now lives, which is the
+   * thing worth teaching, and a panel held open to be looked at after the key that closed it is a
+   * panel still swallowing the next key.
+   */
+  const footer = async (flash = false) => {
+    const selection = await neosh.agent.selection().catch(() => null);
+    if (!selection) {
+      await neosh.status.set("model", {
+        text: "no model",
+        keys: "^P",
+        hl: "Diagnostic.Warn",
+        align: "right",
+        priority: 10,
+      });
+      await neosh.status.clear("effort");
+      return;
+    }
+    // Whether the next turn can authenticate belongs beside the model name, not in the error it
+    // would otherwise become. "opus · no key" is something you fix before you have typed the
+    // question; a failure on send is something you fix after losing your train of thought.
+    //
+    // Together with the catalogue, because both are wanted before the strip is written and
+    // neither depends on the other — asked one after the other, the model name appeared a round
+    // trip later than it had to for the sake of a shorter spelling of itself.
+    const [creds, entries] = await Promise.all([
+      neosh.agent.credentials().catch(() => []),
+      neosh.agent.listModels(selection.instance).catch(() => [] as ModelEntry[]),
+    ]);
+    const cred = creds.find((c) => c.instance === selection.instance);
+    const unusable = cred?.source.kind === "missing";
+    const info = entries.find((e) => e.model.id === selection.model)?.model;
+    // Right-hand end, where pi puts it: the left of the strip is what the conversation is
+    // spending, which changes constantly, and the right is what it is spending it on, which does
+    // not. Two things that move at different rates should not be interleaved.
+    //
+    // `short` is the id with the vendor's half of it off — `claude-opus-4-5` is `opus-4-5`, and
+    // `anthropic/claude-opus-5` is `opus-5`. This is the widest thing on the strip and it used to
+    // cost its full width or nothing, which on a narrow terminal meant the segments after it went
+    // instead. Which vendor you are on is the part of that string you already knew.
+    const brief = withoutVendor(selection.model, info?.family ?? undefined);
+    await neosh.status.set("model", {
+      text: `${selection.model}${unusable ? "  no key" : ""}`,
+      short: brief ? `${brief}${unusable ? "  no key" : ""}` : undefined,
+      keys: "^P",
+      hl: unusable ? "Diagnostic.Warn" : "Accent",
+      align: "right",
+      priority: 10,
+    });
+
+    // Its own segment, with its own key. Glued onto the model name they read as one word, and the
+    // one you want to change is whichever you are not looking at.
+    const descriptors = info?.capabilities?.option_descriptors ?? [];
+    const options = summarise(selection.options ?? [], descriptors);
+    if (options) {
+      await neosh.status.set("effort", {
+        text: options,
+        keys: "^E",
+        // A setting that is not a level — one bought by saying a word rather than by sending a
+        // parameter — wears the group that animates, so the strip itself says the next turn is not
+        // an ordinary one. It is the only place that *can* say it: the word never appears in the
+        // transcript, and the picker it was chosen in has been shut for an hour.
+        hl: flash
+          ? "Option.Chosen"
+          : beyond(selection.options ?? [], descriptors)
+          ? "Option.Beyond"
+          : undefined,
+        align: "right",
+        priority: 11,
+      });
+      // Long enough to be seen, short enough that nobody waits for it. Settling is an ordinary
+      // redraw, so whatever the strip should say — including a rainbow, if what you chose is a word
+      // rather than a level — is said by the same code that would have said it anyway.
+      if (flash) flashOff?.dispose();
+      if (flash) flashOff = neosh.timer.after(320, () => void footer());
+    } else {
+      await neosh.status.clear("effort");
+    }
+  };
+  await footer();
+  // The sheet's own keys, bound to this plugin's buffer kind rather than handled privately — so
+  // `^Z` lists them and `init.ts` can move any of them. See `options.ts`.
+  await installOptions({ neosh, subscriptions }, (flash) => footer(flash));
+  subscriptions.push(neosh.session.onChange(() => void footer()));
+  subscriptions.push(neosh.agent.onTurnEnd(() => void footer()));
+  // Whoever changed it — this plugin, a stored model that would not authenticate, or a provider
+  // registering late and finally serving the model somebody asked for in their config.
+  subscriptions.push(neosh.agent.onSelectionChange(() => void footer()));
+  refreshFooter = footer;
+}
+
+/** Set by `activate`, so the pickers can update the footer the moment a choice lands. */
+let refreshFooter: () => Promise<void> = async () => {};
+
+/** The pending "settle back to normal" after a flash, so two in a row do not fight. */
+let flashOff: Disposable | null = null;
+
+/**
+ * The option values, as a line short enough to sit in a footer.
+ *
+ * A boolean that is off is not shown at all — `fast_mode false` says nothing you did not already
+ * assume, and putting the word "false" in a status strip beside a model name reads as an error.
+ * One that is on is shown by name, because that *is* the news. Selects show their value, since a
+ * select always has one and which one it is always matters.
+ */
+function summarise(
+  chosen: readonly OptionSelection[],
+  descriptors: readonly ProviderOptionDescriptor[],
+): string {
+  const out: string[] = [];
+  for (const d of descriptors) {
+    const value = chosen.find((o) => o.id === d.id)?.value;
+    if (d.type === "boolean") {
+      if (value === true) out.push(d.label.toLowerCase());
+    } else if (typeof value === "string") {
+      out.push(d.options.find((o) => o.id === value)?.label ?? value);
+    }
+  }
+  return out.join(" ");
+}
+
+/**
+ * Whether anything in effect is applied by *saying* it rather than by sending it.
+ *
+ * Asked of the descriptors rather than of the value's name, because which words a vendor reads is
+ * the vendor's business: this file has never heard of "ultrathink" and does not need to.
+ */
+function beyond(
+  chosen: readonly OptionSelection[],
+  descriptors: readonly ProviderOptionDescriptor[],
+): boolean {
+  return descriptors.some((d) => {
+    const value = chosen.find((o) => o.id === d.id)?.value;
+    return d.type === "boolean"
+      ? value === true && typeof d.prompt_injected_word === "string"
+      : typeof value === "string" && (d.prompt_injected_values ?? []).includes(value);
+  });
+}
+
+/**
+ * The model id with the vendor's half of it taken off — `claude-opus-4-5` becomes `opus-4-5`.
+ *
+ * The strip's short form for the model segment. Cut at the *family*, which the catalogue already
+ * says (`"opus"`, `"sonnet"`, `"gpt-5"`), rather than at a prefix this file guesses at: a list of
+ * vendor spellings to strip is a list that is wrong about the next provider somebody registers,
+ * and the whole point of the catalogue is that a plugin's models arrive described.
+ *
+ * Nothing when there is no shorter honest version of the name — no family, a family that is not in
+ * the id, or an id that is already only its family. The segment is then dropped whole if it comes
+ * to that, which is the right answer: half a model id names a different model.
+ */
+function withoutVendor(id: string, family?: string): string | undefined {
+  // A namespaced id is a vendor and a name, and the vendor is the part being dropped either way.
+  const bare = id.slice(id.lastIndexOf("/") + 1);
+  if (!family) return bare === id ? undefined : bare;
+  const at = bare.indexOf(family);
+  if (at <= 0) return bare === id ? undefined : bare;
+  const cut = bare.slice(at);
+  return cut === id ? undefined : cut;
+}
+
+/**
+ * How an instance's key situation reads in a list.
+ *
+ * Said in words rather than shown as a state icon, because the useful distinction is not
+ * "authenticated or not" — it is *which* of four things is true, and each one implies a different
+ * next action.
+ */
+function describe(source: CredentialSource): string {
+  switch (source.kind) {
+    // A plan. There is no key, which is the answer to "why does it say I have no API key".
+    case "plan":
+      return `your ${source.via} login`;
+    case "plan_missing":
+      return source.hint
+        ? `${source.program} is not installed — then \`${source.hint}\``
+        : `${source.program} is not installed`;
+    case "inherited":
+      return "signs in on its own";
+    // A key, and which of the four places it is coming from.
+    case "env":
+      return `$${source.var}`;
+    case "keychain":
+      return "keychain";
+    case "session":
+      return "this session only";
+    case "command":
+      return "credential helper";
+    case "not_needed":
+      return "no key needed";
+    case "missing":
+      return "needs a key";
+  }
+}
+
+async function pickModel(neosh: Neosh): Promise<void> {
+  const [creds, current, ascii, nerd] = await Promise.all([
+    neosh.agent.credentials().catch(() => [] as CredentialInfo[]),
+    neosh.agent.selection().catch(() => null),
+    // Defensively: a display setting that cannot be read must not stop the picker opening. It is
+    // decoration, and failing closed here would mean no way to change models at all.
+    neosh.opt.get<boolean>("ui.ascii_only").catch(() => false),
+    neosh.opt.get<boolean>("ui.nerd_font").catch(() => false),
+  ]);
+  if (creds.length === 0) {
+    neosh.notify("no providers are configured", "warn");
+    return;
+  }
+  const showPricing =
+    (await neosh.opt.get<boolean>("model.picker.show_pricing").catch(() => true)) ?? true;
+  const glyphs = { ascii: ascii ?? false, nerd: nerd ?? false };
+
+  // Grouped by what a turn spends. A plan you already pay for and a key billed per token are
+  // different decisions, and a flat list makes you read every row to tell which is which.
+  const order: AccountKind[] = ["plan", "api_key", "local"];
+  const rail: RailItem<CredentialInfo>[] = [];
+  for (const account of order) {
+    for (const c of creds.filter((x) => x.account === account)) {
+      rail.push({
+        mark: { text: markFor(c, glyphs), hl: c.brand?.hl ?? "Comment" },
+        label: c.display_name,
+        badge: badgeFor(c, glyphs),
+        group: headingFor(account),
+        // Selectable even when its driver is missing. Looking at what a provider offers is how you
+        // decide whether to install it, and a row you cannot land on is a question with nowhere to
+        // ask it. What cannot be chosen is a *model* on it, which is where the refusal belongs.
+        value: c,
+      });
+    }
+  }
+
+  const startAt = Math.max(0, rail.findIndex((r) => r.value.instance === current?.instance));
+
+  const chosen = await railPicker<CredentialInfo, ModelEntry>(neosh, {
+    title: "Model",
+    width: 88,
+    railWidth: 24,
+    height: 14,
+    rail,
+    railAt: startAt,
+    railLabel: "providers",
+    paneLabel: "models",
+    // Chords, not bare letters. Bare letters were nicer to read and made it impossible to type
+    // "sonnet" into the filter: the `s` signed you in instead. Anything the picker takes for
+    // itself is a letter the filter can never contain.
+    ownKeys: ["<C-s>", "<C-r>", "<C-a>", "<C-d>"],
+    hints: "↵ use   ^S sign in   ^R refresh   ^A add   ^D remove   esc close",
+    placeholder: "nothing here yet — `s` to sign in, or `n` to name a model yourself",
+    async items(c) {
+      // Listed even when the driver is missing. What a provider offers is how you decide whether
+      // installing its CLI is worth the afternoon, and an empty pane answers that with silence.
+      const entries = await neosh.agent.listModels(c.instance).catch(() => [] as ModelEntry[]);
+      // Why nothing here can be chosen, at the top, where it will be read before the list it is
+      // about. `⨯` on the rail says *that* it is unavailable; this says what to do.
+      const blocked: PaneItem<ModelEntry>[] = c.driver_available
+        ? []
+        : [{
+            label: "unavailable",
+            detail: describe(c.source),
+            disabled: true,
+            value: undefined as unknown as ModelEntry,
+          }];
+      // Anything the user named themselves goes next: they typed it because the list did not have
+      // it, and burying it under the list that did not have it would be a poor joke.
+      const named: PaneItem<ModelEntry>[] = (await custom(neosh, c.instance)).map((m) => ({
+        label: m.display_name,
+        badge: { text: "yours", hl: "Comment" },
+        disabled: !c.driver_available,
+        detail: m.id,
+        keywords: m.id,
+        value: { instance: c.instance, model: m } as ModelEntry,
+      }));
+      return blocked.concat(named).concat(entries.map((e) => ({
+        label: e.model.display_name,
+        badge: e.model.tier ? { text: tierLabel(e.model.tier), hl: tierHl(e.model.tier) } : undefined,
+        detail: describeModel(e, showPricing),
+        disabled: !c.driver_available,
+        keywords: `${e.model.id} ${e.model.family ?? ""}`,
+        // Last year's models are reachable and out of the way. You go looking for one to
+        // reproduce something, which is exactly when hiding it outright would be worst.
+        section: e.model.legacy ? "superseded" : undefined,
+        value: e,
+      })));
+    },
+    // Guarded, because not every row carries a model: the "why this is unavailable" row has no
+    // value at all, and reaching through it is how a picker crashes on open.
+    itemAt: (items) =>
+      Math.max(0, items.findIndex((i) => i.value?.model?.id === current?.model)),
+    async onKey(key, ctx) {
+      if (key.key.code.kind !== "char" || !key.key.mods.ctrl || key.key.mods.alt) return;
+      const c = ctx.rail;
+      const pressed = key.key.code.c.toLowerCase();
+      if (pressed === "s") {
+        if (!c) return "handled";
+        if (!c.accepts_key) {
+          neosh.notify(`${c.display_name}: ${describe(c.source)}`, "info");
+          return "handled";
+        }
+        return (await signIn(neosh, c.instance, c)) ? "reload" : "handled";
+      }
+      // Ask the endpoint again. Discovery is cached for the session, which is right — it is a
+      // network round trip per provider — and wrong the moment you add a key, get given access to
+      // a new model, or start the local server the list was empty because of.
+      if (pressed === "r") {
+        if (!c) return "handled";
+        neosh.notify(`${c.display_name}: asking again…`);
+        await neosh.agent.listModels(c.instance, { refresh: true }).catch(() => []);
+        return "reload";
+      }
+      // A model the catalogue has not heard of. Vendors ship faster than any list is updated, and
+      // "I know the id, let me type it" is the difference between waiting for a release and not.
+      if (pressed === "a") {
+        if (!c) return "handled";
+        return (await addModel(neosh, c)) ? "reload" : "handled";
+      }
+      // And out again. Anything you can add you must be able to take back — a typo in an id is the
+      // most likely thing to be in this list, and a wrong entry that cannot be removed is a row
+      // you have to read past forever.
+      if (pressed === "d") {
+        const id = ctx.item?.model?.id;
+        if (!c || !id) return "handled";
+        if (!(await custom(neosh, c.instance)).some((m) => m.id === id)) {
+          neosh.notify(
+            `${id} is in ${c.display_name}'s own catalogue — there is nothing of yours to remove`,
+            "info",
+          );
+          return "handled";
+        }
+        return (await removeModel(neosh, c.instance, id)) ? "reload" : "handled";
+      }
+      return undefined;
+    },
+  });
+  if (!chosen) return;
+
+  if (!creds.find((c) => c.instance === chosen.instance)?.source.kind.startsWith("plan")) {
+    const cred = creds.find((c) => c.instance === chosen.instance);
+    if (cred && cred.source.kind === "missing" && cred.accepts_key) {
+      if (!(await signIn(neosh, chosen.instance, cred))) return;
+    }
+  }
+  await use(neosh, chosen, current);
+}
+
+/**
+ * Move one rung along the capability ladder, within the provider you are already using.
+ *
+ * The provider is held fixed on purpose. "Give me something cheaper" is a question about the model;
+ * answering it by also moving you to a different endpoint — with different billing, possibly a
+ * different key — would be answering a question nobody asked.
+ *
+ * No wrapping. At the top, `upgrade` says so rather than dropping you to the cheapest thing in the
+ * catalogue, which is the kind of surprise that stops people using a key at all.
+ */
+async function step(neosh: Neosh, delta: number): Promise<void> {
+  const current = await neosh.agent.selection().catch(() => null);
+  if (!current) {
+    neosh.notify("no model is selected", "warn");
+    return;
+  }
+  const entries = await neosh.agent.listModels(current.instance).catch(() => [] as ModelEntry[]);
+  const here = entries.find((e) => e.model.id === current.model);
+  const from = here?.model.tier;
+  if (!from) {
+    neosh.notify(`${current.model} is not on the ladder — nothing to step to`, "warn");
+    return;
+  }
+  const rungs: ModelTier[] = ["fast", "balanced", "frontier"];
+  const at = rungs.indexOf(from) + delta;
+  const want = rungs[at];
+  if (!want) {
+    neosh.notify(delta > 0 ? "already the most capable one here" : "already the quickest one here");
+    return;
+  }
+  const next = best(entries.filter((e) => e.model.tier === want));
+  if (!next) {
+    neosh.notify(`${current.instance} has nothing on the ${tierLabel(want)} rung`, "warn");
+    return;
+  }
+  await use(neosh, next, current);
+}
+
+/**
+ * Switch to the current model in a named line — `model.line opus`.
+ *
+ * A *line* is a product across versions; the best one in it is the newest that has not been
+ * superseded. That is the thing people mean by "use Opus": not a pinned id that goes stale, and not
+ * a picker they have to read.
+ *
+ * Looks in the provider you are on first, then anywhere reachable, so this works whether your Opus
+ * comes from a plan or a key.
+ */
+async function useLine(neosh: Neosh, line: string | undefined): Promise<void> {
+  if (!line) {
+    neosh.notify("model.line needs a line — try `model.line opus`", "warn");
+    return;
+  }
+  const current = await neosh.agent.selection().catch(() => null);
+  const wanted = line.trim().toLowerCase();
+  const matching = (entries: ModelEntry[]) =>
+    entries.filter((e) => (e.model.family ?? "").toLowerCase() === wanted);
+
+  let found = current
+    ? best(matching(await neosh.agent.listModels(current.instance).catch(() => [])))
+    : undefined;
+  if (!found) found = best(matching(await neosh.agent.listModels().catch(() => [])));
+  if (!found) {
+    neosh.notify(`nothing reachable is in the "${line}" line`, "warn");
+    return;
+  }
+  await use(neosh, found, current);
+}
+
+/**
+ * The one to use out of a set: current before superseded, then the most capable.
+ *
+ * Order within a rung is the catalogue's, which lists newest first — so "current" needs no version
+ * parsing, which is the thing that goes wrong the moment a vendor renames something.
+ */
+function best(entries: ModelEntry[]): ModelEntry | undefined {
+  const live = entries.filter((e) => !e.model.legacy);
+  const pool = live.length > 0 ? live : entries;
+  const rank = (e: ModelEntry) =>
+    e.model.tier === "frontier" ? 2 : e.model.tier === "balanced" ? 1 : 0;
+  return pool.reduce<ModelEntry | undefined>(
+    (win, e) => (win === undefined || rank(e) > rank(win) ? e : win),
+    undefined,
+  );
+}
+
+/** Put a selection into effect, carrying over the option values the new model also has. */
+async function use(
+  neosh: Neosh,
+  chosen: ModelEntry,
+  current: ModelSelection | null,
+): Promise<void> {
+  // Switching between two thinking models should keep your effort level; switching to one without
+  // the knob must drop it rather than send a value the driver will reject.
+  const descriptors = chosen.model.capabilities?.option_descriptors ?? [];
+  const keep = (current?.options ?? []).filter((o) => descriptors.some((d) => d.id === o.id));
+  await neosh.agent.setSelection({
+    instance: chosen.instance,
+    model: chosen.model.id,
+    options: keep,
+  });
+  await refreshFooter();
+  neosh.notify(`model: ${chosen.instance}/${chosen.model.display_name}`);
+}
+
+function headingFor(account: AccountKind): string {
+  if (account === "plan") return "PLANS";
+  return account === "api_key" ? "API KEYS" : "LOCAL";
+}
+
+/**
+ * The mark for a provider, at whatever fidelity this terminal has.
+ *
+ * Three levels rather than one, because a terminal is not one thing: a Nerd Font has a real brand
+ * glyph, a bare Unicode terminal has geometry, `ui.ascii_only` has a letter. Choosing badly is
+ * worse than choosing plainly — a box glyph where a logo should be reads as a broken program.
+ */
+function markFor(c: CredentialInfo, glyphs: { ascii: boolean; nerd: boolean }): string {
+  const b = c.brand;
+  if (!b) return glyphs.ascii ? "?" : "·";
+  if (glyphs.ascii) return b.ascii;
+  return (glyphs.nerd && b.nerd) || b.mark;
+}
+
+/** The state marker at the right edge of the rail. One column, four meanings. */
+function badgeFor(
+  c: CredentialInfo,
+  glyphs: { ascii: boolean },
+): { text: string; hl: string } | undefined {
+  // A plan whose CLI is not installed is not broken — it is one `brew install` away, and the
+  // detail line says which. `⨯` is for a provider nothing can serve at all.
+  if (!c.driver_available) {
+    const fixable = c.source.kind === "plan_missing";
+    return { text: fixable ? "!" : glyphs.ascii ? "-" : "⨯", hl: fixable ? "Account.Missing" : "Comment" };
+  }
+  switch (c.source.kind) {
+    case "missing":
+    case "plan_missing":
+      return { text: "!", hl: "Account.Missing" };
+    case "not_needed":
+      return undefined;
+    case "plan":
+      return { text: glyphs.ascii ? "*" : "✓", hl: "Account.Plan" };
+    default:
+      return { text: glyphs.ascii ? "+" : "✓", hl: "Account.Key" };
+  }
+}
+
+/** The rung, as a word. Read down this column and you see the shape of what a provider offers. */
+function tierLabel(tier: ModelTier): string {
+  if (tier === "frontier") return "Frontier";
+  return tier === "balanced" ? "Balanced" : "Fast";
+}
+
+function tierHl(tier: ModelTier): string {
+  if (tier === "frontier") return "Accent";
+  return tier === "balanced" ? "Status.Working" : "Status.Done";
+}
+
+/** What a model row says about itself, beyond its name and rung. */
+function describeModel(e: ModelEntry, showPricing: boolean): string {
+  const bits: string[] = [];
+  if (e.model.tagline) bits.push(e.model.tagline);
+  if (showPricing && e.model.pricing) {
+    bits.push(`$${e.model.pricing.input_per_mtok}/$${e.model.pricing.output_per_mtok}`);
+  }
+  if (bits.length === 0) bits.push(String(e.model.id));
+  return bits.join("  ·  ");
+}
+
+/**
+ * Models the user named themselves, for one provider.
+ *
+ * Kept in plugin state rather than in configuration, because it is a note about *this machine's*
+ * access — "my org has early access to this id" — not a decision worth committing to a repository.
+ * Stored per instance so the same id can mean different things on two endpoints.
+ */
+async function custom(neosh: Neosh, instance: string): Promise<ModelInfo[]> {
+  const all = await neosh.state.get<Record<string, ModelInfo[]>>("custom").catch(() => null);
+  return all?.[instance] ?? [];
+}
+
+/**
+ * Add a model the catalogue has never heard of.
+ *
+ * Two questions, because the id and the name are different things: the id is what goes on the wire
+ * and has to be exact, and the name is what you will read in a list forever afterwards. Defaulting
+ * the name to the id means answering the second one is optional.
+ *
+ * Nothing validates the id — nothing here *can*. Whether an endpoint serves it is a question only
+ * the endpoint can answer, and it answers it on the first turn.
+ */
+async function addModel(neosh: Neosh, c: CredentialInfo): Promise<boolean> {
+  const id = await prompt(neosh, `Model id on ${c.display_name}`, { width: 60 });
+  if (!id || !id.trim()) return false;
+  const name = await prompt(neosh, "Show it as", { initial: id.trim(), width: 60 });
+
+  const all =
+    (await neosh.state.get<Record<string, ModelInfo[]>>("custom").catch(() => null)) ?? {};
+  const mine = (all[c.instance] ?? []).filter((m) => m.id !== id.trim());
+  mine.unshift({
+    id: id.trim(),
+    display_name: (name ?? id).trim() || id.trim(),
+    capabilities: {
+      tools: true,
+      vision: false,
+      streaming: true,
+      thinking: false,
+      prompt_caching: false,
+      option_descriptors: [],
+    },
+    legacy: false,
+  } as ModelInfo);
+  all[c.instance] = mine;
+  await neosh.state.set("custom", all);
+  neosh.notify(`added ${c.instance}/${id.trim()}`);
+  return true;
+}
+
+/**
+ * Take back a model you named yourself.
+ *
+ * Only ever removes from your own list. A model the provider serves is not yours to delete, and
+ * the refusal says which of the two this row is rather than silently doing nothing.
+ */
+async function removeModel(neosh: Neosh, instance: string, id: string): Promise<boolean> {
+  const current = await neosh.agent.selection().catch(() => null);
+  const inUse = current?.instance === instance && current.model === id;
+  const ok = await confirmDestructive(neosh, `Remove ${id} from ${instance}?`, {
+    yes: "Remove",
+    no: "Keep",
+    detail: [
+      "You added this one by hand, so nothing else will offer it back.",
+      ...(inUse ? ["It is the model in use — you will have to pick another before sending."] : []),
+    ],
+  });
+  if (!ok) return false;
+
+  const all =
+    (await neosh.state.get<Record<string, ModelInfo[]>>("custom").catch(() => null)) ?? {};
+  const mine = (all[instance] ?? []).filter((m) => m.id !== id);
+  if (mine.length === 0) delete all[instance];
+  else all[instance] = mine;
+  await neosh.state.set("custom", all);
+  neosh.notify(`removed ${instance}/${id}`);
+
+  // If it was the one in use, the conversation is now pointed at a model nothing lists. Said again
+  // here rather than only in the dialog: the dialog is gone by the time it matters.
+  if (inUse) {
+    neosh.notify(`${id} was the model in use — pick another before sending`, "warn");
+  }
+  return true;
+}
+
+/**
+ * Collect a key for one instance.
+ *
+ * The typing happens in the host — this call does not settle until the prompt closes, and what
+ * comes back is whether a key was stored, never the key. Afterwards the endpoint is re-queried,
+ * because the reason it listed nothing a moment ago was that it could not authenticate.
+ */
+async function signIn(
+  neosh: Neosh,
+  instance: string,
+  cred: CredentialInfo | undefined,
+): Promise<boolean> {
+  if (cred && !cred.accepts_key) {
+    neosh.notify(`${cred.display_name} signs in on its own — there is nowhere to put a key`, "warn");
+    return false;
+  }
+  const stored = await neosh.agent
+    .setCredential(instance, { replace: true })
+    .catch((e: unknown) => {
+      neosh.notify(String(e), "warn");
+      return false;
+    });
+  if (!stored) return false;
+  await neosh.agent.listModels(instance, { refresh: true }).catch(() => []);
+  return true;
+}
+
+/**
+ * Every configured provider and the state of its account.
+ *
+ * The same information the model picker's rail carries, as a page you can go to directly — for
+ * replacing a key, forgetting one, or finding out why a provider you expected is not offering
+ * anything.
+ */
+async function pickProvider(neosh: Neosh): Promise<void> {
+  const rows = await neosh.agent.credentials();
+  if (rows.length === 0) {
+    neosh.notify("no providers are configured", "warn");
+    return;
+  }
+  // Unavailable drivers are listed rather than hidden. The `claude` CLI not being installed is the
+  // single most likely reason a subscription does not show up, and a provider that has silently
+  // vanished from the list is a question with nowhere to ask it.
+  const order = ["plan", "api_key", "local"] as const;
+  const sorted = order.flatMap((account) =>
+    rows
+      .filter((c) => c.account === account)
+      .sort((a, b) => Number(b.driver_available) - Number(a.driver_available)),
+  );
+  const chosen = await picker(
+    neosh,
+    sorted.map((c) => ({
+      label: c.display_name,
+      detail: c.driver_available
+        ? `${headingFor(c.account).toLowerCase()}  ·  ${describe(c.source)}`
+        : `${c.instance}  ·  its driver is not available here`,
+      keywords: c.instance,
+      value: c,
+    })),
+    { title: "Providers", width: 76 },
+  );
+  if (!chosen) return;
+
+  if (!chosen.driver_available) {
+    neosh.notify(
+      chosen.driver === "claude-cli"
+        ? "the `claude` CLI is not on your PATH — install it to use your Claude subscription"
+        : `${chosen.display_name}: no plugin provides the "${chosen.driver}" driver`,
+      "warn",
+    );
+    return;
+  }
+  if (chosen.source.kind === "plan_missing") {
+    const { program, hint } = chosen.source;
+    neosh.notify(
+      hint
+        ? `${program} is not installed. Install it, then run \`${hint}\`.`
+        : `${program} is not installed.`,
+      "warn",
+    );
+    return;
+  }
+  if (!chosen.accepts_key) {
+    neosh.notify(`${chosen.display_name}: ${describe(chosen.source)}`, "info");
+    return;
+  }
+  if (chosen.source.kind === "missing") {
+    await signIn(neosh, chosen.instance, chosen);
+    return;
+  }
+
+  // It already has one, so the two things you could mean are "replace it" and "get rid of it".
+  const action = await picker<"replace" | "forget">(
+    neosh,
+    [
+      { label: "Enter a new key", detail: `replaces ${describe(chosen.source)}`, value: "replace" },
+      { label: "Forget the stored key", detail: "removes it from the keychain too", value: "forget" },
+    ],
+    { title: chosen.display_name, width: 64, height: 2 },
+  );
+  if (action === null) return;
+  if (action === "replace") {
+    await signIn(neosh, chosen.instance, chosen);
+    return;
+  }
+  const ok = await confirmDestructive(neosh, `Forget the key for ${chosen.display_name}?`, {
+    yes: "Forget",
+    no: "Keep",
+    detail: [
+      "It goes from the keychain too, so this machine will not have it again until you paste it.",
+      `${chosen.display_name} will stop offering models until you sign in.`,
+    ],
+  });
+  if (!ok) return;
+  await neosh.agent.forgetCredential(chosen.instance);
+  await refreshFooter();
+}
+

package/options.ts

@@ -0,0 +1,533 @@
+/**
+ * Everything the chosen model can be told, on one surface.
+ *
+ * # Why this is not a picker
+ *
+ * It used to be two: a list of knobs, and then a list of that knob's values. Which meant the answer
+ * to "what can I change about this model" was three keystrokes and a modal you had to back out of
+ * to see the other knob — and, on the common path, no answer at all: with exactly one knob the
+ * outer list was skipped, so `^E` opened a list of effort levels and nothing anywhere said that
+ * fast mode or the context window existed. A setting you cannot see is a setting you do not have.
+ *
+ * So: every knob at once, one row each, values laid out along the row with the current one lit.
+ * `h`/`l` moves along a row and `j`/`k` between them — the arrows do the same — and what you are
+ * looking at *is* the state: there is no "current value" to go and read somewhere else.
+ *
+ * # Why it is a panel and not a private key handler
+ *
+ * Because the surface rule says so, and the sidebar proved why: every key here is an ordinary binding
+ * pointed at a named command, scoped to this buffer's **kind**. `^Z` lists them, `^K` runs them,
+ * and `init.ts` can move any of them. A `switch` on the key inside this file is exactly the thing
+ * that rule replaced.
+ *
+ * # What is drawn, and why it moves
+ *
+ * A value's prominence is its position on its own ladder — `Option.Step1`…`Step5`, which is weight
+ * rather than hue, because a reasoning level is a *scale* and the palette keeps its three hues for
+ * states. The exception is a level that is not on the ladder at all: one bought by putting a word
+ * in the message rather than by sending a parameter. That gets `Option.Beyond`, the one group in
+ * the theme that animates a rainbow — because what it has to say is "this is not one of the normal
+ * settings", and no amount of amber says that.
+ */
+
+import type {
+  Disposable,
+  FloatOptions,
+  ModelEntry,
+  ModelSelection,
+  Neosh,
+  OptionSelection,
+  ProviderOptionDescriptor,
+} from "@neosh/api";
+import { byteLength, clipToWidth, padToWidth, width } from "@neosh/api";
+
+const KIND = "neosh.model.options";
+const NS = "neosh.model.options";
+
+/** One value a knob can take. */
+interface Choice {
+  id: string;
+  label: string;
+  detail: string;
+  /** Applied by saying it in the message rather than by sending it. */
+  spoken: boolean;
+}
+
+/** One knob, flattened so a boolean and a select draw identically. */
+interface Row {
+  id: string;
+  label: string;
+  description: string;
+  choices: Choice[];
+  /** Which choice is in effect. */
+  at: number;
+  /** Booleans come back as flags, selects as strings. */
+  boolean: boolean;
+}
+
+interface Sheet {
+  win: number;
+  buf: number;
+  ns: number;
+  rows: Row[];
+  /** Which row the keys act on. */
+  cursor: number;
+  selection: ModelSelection;
+  title: string;
+  /** Inside the border. What the description line has to fit in. */
+  inner: number;
+  /** What the float was opened with, so `configure` can change one field without losing the rest. */
+  config: FloatOptions;
+  /** Whether anything spoken is in effect, so the border is only redone when the answer changes. */
+  beyond: boolean;
+  close(): Promise<void>;
+}
+
+let sheet: Sheet | null = null;
+
+/**
+ * The keys, in the order they were pressed.
+ *
+ * Every verb here is several round trips — set the lines, clear the marks, set a dozen more, hand
+ * the selection back to the agent — and the host dispatches each key as its own command *without
+ * waiting for the last one to finish*. Three keys in flight at once therefore finish in length
+ * order rather than press order, and the shortest verb is `done`: press `→ → ⏎` quickly and the
+ * panel shuts first, leaving two redraws to fail against a window that is already gone. Chaining
+ * them costs nothing — they were serial in effect anyway, because they all touch one buffer — and
+ * it is the same reason the sidebar serialises its own redraws.
+ */
+let queue: Promise<void> = Promise.resolve();
+
+/**
+ * Turn what a driver said into rows.
+ *
+ * A boolean becomes a two-value row, because "off / on" laid out like every other ladder is one
+ * fewer shape to learn than a checkbox that behaves differently from the row above it — and it
+ * gives the spoken switches somewhere to put their word.
+ */
+function rowsFrom(
+  descriptors: readonly ProviderOptionDescriptor[],
+  chosen: readonly OptionSelection[],
+): Row[] {
+  return descriptors.map((d) => {
+    const value = chosen.find((o) => o.id === d.id)?.value;
+    if (d.type === "boolean") {
+      const on = typeof value === "boolean" ? value : d.current_value;
+      // The word, if this switch is one. A switch that is a word is not a parameter at all — see
+      // `prompt_injected_word` — so it wears the same mark as a spoken level.
+      const spoken = typeof d.prompt_injected_word === "string";
+      return {
+        id: d.id,
+        label: d.label,
+        description: d.description ?? "",
+        choices: [
+          { id: "off", label: "off", detail: "", spoken: false },
+          { id: "on", label: "on", detail: "", spoken },
+        ],
+        at: on ? 1 : 0,
+        boolean: true,
+      };
+    }
+    const injected = d.prompt_injected_values ?? [];
+    const current =
+      (typeof value === "string" ? value : undefined) ??
+      d.current_value ??
+      d.options.find((o) => o.is_default)?.id;
+    const choices = d.options.map((o) => ({
+      id: o.id,
+      label: o.label,
+      // What the *driver* said about this level, and nothing invented. A value with nothing to
+      // say falls through to what the knob says, which is better than a row that reads "the
+      // default" where the sentence explaining the control used to be.
+      detail: o.description ?? "",
+      spoken: injected.includes(o.id),
+    }));
+    return {
+      id: d.id,
+      label: d.label,
+      description: d.description ?? "",
+      choices,
+      at: Math.max(0, choices.findIndex((c) => c.id === current)),
+      boolean: false,
+    };
+  });
+}
+
+/**
+ * Which step of the five-rung ramp a value sits on.
+ *
+ * Computed from where it is in *its own* ladder rather than from its name, because the ladders are
+ * different lengths — five levels on Claude, three on an aggregator, two on Gemini — and a `high`
+ * that is the top rung of one and the middle of another should not be drawn the same weight.
+ */
+function step(at: number, of: number): string {
+  if (of <= 1) return "Option.Step3";
+  const rung = Math.round((at / (of - 1)) * 4) + 1;
+  return `Option.Step${Math.min(5, Math.max(1, rung))}`;
+}
+
+/**
+ * The group a value is drawn in, given whether it is the one in effect.
+ *
+ * The ramp is measured over the levels that are *sendable*, so a ladder with a spoken level bolted
+ * past the top of it does not compress: five rungs stay five rungs, and the word on the end is
+ * drawn as the thing off the scale that it is.
+ */
+function groupFor(row: Row, at: number, live: boolean, focused: boolean): string {
+  if (!live) return "Option.Unset";
+  const choice = row.choices[at]!;
+  if (choice.spoken) return "Option.Beyond";
+  // The row the keys are on says so, and says it where you are looking: at the value they would
+  // move. A ladder with one rung lit reads identically whether or not `←→` do anything to it —
+  // which is how a live control came to look like a summary, and why `↵` on it felt like a key
+  // that does nothing. The ramp is still on every other row, where it is a statement about the
+  // setting rather than about the cursor.
+  if (focused) return "Option.Cursor";
+  // A switch is the ends of the scale and nothing in between, said explicitly rather than left to
+  // the ramp: a spoken switch has one ordinary value and one word, and a ladder of length one puts
+  // its only rung in the middle — so `off` on the switch beside it came out brighter than `off` on
+  // an ordinary one, for no reason a reader could ever recover.
+  if (row.boolean) return at === 0 ? "Option.Step1" : "Option.Step5";
+  const ladder = row.choices.filter((c) => !c.spoken);
+  return step(ladder.findIndex((c) => c.id === choice.id), ladder.length);
+}
+
+/** One row's worth of text, and where every value landed in it. */
+interface Painted {
+  text: string;
+  /** `[start, end]` byte offsets, one per choice. */
+  spans: [number, number][];
+  /** The two chevrons, same shape, so the caller can colour them by whether they can move. */
+  rails: [[number, number], [number, number]];
+}
+
+/**
+ * A row, with the rail that says it is one.
+ *
+ * The chevrons are the whole reason this function changed. Every row here is a horizontal control
+ * and nothing on screen said so: `↵` was the only key that visibly did anything, it means "done",
+ * and a panel whose one working key closes it is a panel that does nothing. `‹` and `›` are on
+ * every row — the shape is learnt once — and they light on the row the keys act on, dimming at
+ * whichever end you have reached, so where you are on the ladder is readable without counting.
+ */
+function paint(row: Row, labelWidth: number, mark: string, glyph: string): Painted {
+  let text = `${mark}${padToWidth(row.label, labelWidth)}  `;
+  const leftStart = byteLength(text);
+  text += "‹";
+  const left: [number, number] = [leftStart, byteLength(text)];
+  const spans: [number, number][] = [];
+  for (const choice of row.choices) {
+    const label = choice.spoken ? `${glyph}${choice.label}` : choice.label;
+    const start = byteLength(text);
+    text += ` ${label} `;
+    spans.push([start, byteLength(text)]);
+  }
+  const rightStart = byteLength(text);
+  text += "›";
+  return { text, spans, rails: [left, [rightStart, byteLength(text)]] };
+}
+
+async function draw(neosh: Neosh, s: Sheet, hints: string): Promise<void> {
+  // The panel this frame is about may have been dismissed while the frame was being computed —
+  // every line of it is a round trip. Drawing into a window that is gone is this widget racing
+  // itself, not something the user did wrong.
+  if (sheet !== s) return;
+  const glyph = (await neosh.opt.get<boolean>("ui.ascii_only").catch(() => false)) ? "*" : "✦ ";
+  const labelWidth = Math.max(...s.rows.map((r) => width(r.label)));
+  const painted = s.rows.map((r, i) => paint(r, labelWidth, i === s.cursor ? "❯ " : "  ", glyph));
+
+  const here = s.rows[s.cursor];
+  // A description line that appeared and disappeared with the cursor would move every row below it
+  // on every keystroke, so it has a permanent home at the foot. What it says is whatever the driver
+  // said about the value under the cursor, falling back to what it said about the knob.
+  // Clipped rather than allowed to size the float: this line changes with every keystroke, and a
+  // panel that got wider when the cursor moved onto the row with the long sentence would be a panel
+  // that never stops moving.
+  const said = clipToWidth(here?.choices[here.at]?.detail || here?.description || "", s.inner - 3);
+  const lines = [...painted.map((p) => p.text), "", `  ${said}`, ` ${hints}`];
+  await neosh.buf.setLines(s.buf, 0, -1, lines);
+
+  // The whole surface says when the next turn is not an ordinary one. A word in the message is
+  // invisible everywhere else — it never reaches the transcript, and the panel it was chosen in
+  // will have been shut for an hour by the time it matters — so while one is in effect the border
+  // carries the same rainbow the value does. Reconfigured only when the answer *changes*: this is
+  // a round trip, and one per keystroke on a control that already makes several is how a panel
+  // starts lagging behind the keys being pressed. Clock-driven rather than a one-shot, so it is
+  // safe against a redraw that mints every mark again.
+  const beyond = s.rows.some((r) => r.choices[r.at]?.spoken);
+  if (beyond !== s.beyond) {
+    s.beyond = beyond;
+    await neosh.float
+      .configure(s.win, { ...s.config, borderHl: beyond ? "Option.Beyond" : undefined })
+      .catch(() => {});
+  }
+
+  // Cleared before anything is drawn, every frame. A mark clamps rather than dies when the line
+  // under it is replaced, so a row rewritten on every keypress otherwise accumulates them and ends
+  // up painted by the narrowest one from three keystrokes ago.
+  await neosh.ns.clear(s.ns, s.buf);
+  for (let i = 0; i < s.rows.length; i++) {
+    const row = s.rows[i]!;
+    const p = painted[i]!;
+    if (i === s.cursor) {
+      await neosh.ns.mark(s.ns, s.buf, i, 0, { hlGroup: "Comment", endCol: byteLength("❯ ") });
+    }
+    await neosh.ns.mark(s.ns, s.buf, i, byteLength(i === s.cursor ? "❯ " : "  "), {
+      hlGroup: i === s.cursor ? "Title" : "Comment",
+      endCol: byteLength(p.text.slice(0, p.spans[0]?.[0] ?? 0)),
+    });
+    for (let c = 0; c < row.choices.length; c++) {
+      const [start, end] = p.spans[c]!;
+      const live = c === row.at;
+      // One mark, not a band under a colour: the renderer takes the highest-priority ranged group
+      // covering a character and stops, so two of them here would draw one and silently drop the
+      // other. `Option.Step*` carries the band as well as the step for exactly that reason.
+      await neosh.ns.mark(s.ns, s.buf, i, start, {
+        hlGroup: groupFor(row, c, live, i === s.cursor),
+        endCol: end,
+      });
+    }
+    // Lit on the row the keys act on, and only at the end there is somewhere to go. A chevron that
+    // stayed bright at `max` would promise a level that is not there.
+    const ends = [row.at > 0, row.at < row.choices.length - 1];
+    for (let r = 0; r < 2; r++) {
+      const [start, end] = p.rails[r]!;
+      await neosh.ns.mark(s.ns, s.buf, i, start, {
+        hlGroup: i === s.cursor && ends[r] ? "Option.RailLive" : "Option.Rail",
+        endCol: end,
+      });
+    }
+  }
+  const detail = s.rows.length + 1;
+  await neosh.ns.mark(s.ns, s.buf, detail, 0, {
+    // What a spoken level says about itself is said in the register it belongs to. The sentence
+    // under a rainbow value is the one explaining why it is not a level, and drawing it in the
+    // same grey as "how much reasoning the model spends" buries the difference.
+    hlGroup: here?.choices[here.at]?.spoken ? "Option.Beyond" : "Picker.Detail",
+    endCol: byteLength(lines[detail] ?? ""),
+  });
+  await neosh.ns.mark(s.ns, s.buf, detail + 1, 0, {
+    hlGroup: "Sidebar.Dim",
+    endCol: byteLength(lines[detail + 1] ?? ""),
+  });
+  await neosh.win.setCursor(s.win, s.cursor, 0);
+}
+
+/**
+ * Put the whole sheet into effect.
+ *
+ * Every keystroke, rather than on the way out. Changing a reasoning level is reversible — you can
+ * see what it is and put it back — and "everything irreversible asks, and nothing reversible does"
+ * cuts both ways: a control that only takes effect when you press the right key to leave is a
+ * control you have to be taught. The footer moves as you move, which is the whole feedback loop.
+ */
+async function apply(
+  neosh: Neosh,
+  s: Sheet,
+  refresh: (flash?: boolean) => Promise<void>,
+): Promise<void> {
+  const options: OptionSelection[] = s.rows.map((row) => {
+    const choice = row.choices[row.at]!;
+    return {
+      id: row.id,
+      value: row.boolean ? row.at === 1 : choice.id,
+    };
+  });
+  s.selection = { ...s.selection, options };
+  await neosh.agent.setSelection(s.selection);
+  await refresh();
+}
+
+/**
+ * The keys, as words.
+ *
+ * The key that *changes something* first: it used to be third, behind `↵`, which closes. Read in
+ * order, the old line taught you that the way to use this panel was to dismiss it.
+ */
+function hintsFor(): string {
+  // Letters rather than arrows, and not because the arrows do not work — they are bound too. The
+  // row is a promise about a keyboard, and `h j k l` is a promise every keyboard keeps.
+  return "h l change   j k knob   ⇥ cycle   ↵ done   esc close";
+}
+
+export async function installOptions(
+  { neosh, subscriptions }: { neosh: Neosh; subscriptions: Disposable[] },
+  refresh: (flash?: boolean) => Promise<void>,
+): Promise<void> {
+  const scope = { kind: "buf_kind", name: KIND } as const;
+
+  /** Register a verb and bind it inside the sheet. See the sidebar's `verb` — same reasoning. */
+  const verb = async (
+    name: string,
+    keys: string[],
+    desc: string,
+    fn: (s: Sheet) => Promise<void> | void,
+  ): Promise<void> => {
+    subscriptions.push(
+      await neosh.cmd.register(name, () => {
+        const mine = queue.then(async () => {
+          if (!sheet) return;
+          await fn(sheet);
+        });
+        // One verb that fails must not stop the ones behind it: the panel would look alive and
+        // ignore every key from then on, which is worse than the failure it is hiding.
+        queue = mine.catch((e: unknown) => neosh.notify(String(e), "warn"));
+        return mine;
+      }, { desc }),
+    );
+    for (const key of keys) {
+      await neosh.keymap.set("chat", key, name, { scope, desc });
+    }
+  };
+
+  const redraw = async (s: Sheet) => draw(neosh, s, hintsFor());
+
+  const move = async (s: Sheet, delta: number) => {
+    s.cursor = Math.min(s.rows.length - 1, Math.max(0, s.cursor + delta));
+    await redraw(s);
+  };
+
+  /**
+   * Along the current row.
+   *
+   * `wrap` is the difference between the arrows and the cycle key, and it is deliberate: an arrow
+   * that teleported from `max` back to `low` would be the same surprise as a downgrade key that
+   * lands on the most expensive model in the catalogue, which `ModelTier::step` refuses to be. A
+   * key whose whole job is "the next one" may wrap, because that is what it says it does.
+   */
+  const shift = async (s: Sheet, delta: number, wrap: boolean) => {
+    const row = s.rows[s.cursor];
+    if (!row) return;
+    const n = row.choices.length;
+    row.at = wrap
+      ? (row.at + delta + n) % n
+      : Math.min(n - 1, Math.max(0, row.at + delta));
+    // Drawn before it is applied. Both are round trips and the panel is where you are looking, so
+    // putting the several calls that update the *strip* first makes every keypress wait on work
+    // whose result is behind the window you are reading — and keys arriving meanwhile queue up
+    // against a panel that has not caught up with the last one.
+    await redraw(s);
+    await apply(neosh, s, refresh);
+  };
+
+  // No `^N`/`^P` here, and none needed: the float is **modal**, so nothing global resolves while
+  // it is up. This used to be a list of keys deliberately left unbound so that `^N` and `^P` kept
+  // working — which was the wrong half of the problem. Shadowing a key is how a panel keeps the
+  // one key it needs; it does nothing about the dozen it does not, and `^T`, `^G`, `^L` and the
+  // rest all fell through and opened something behind this. A control you are in the middle of
+  // using owns the keyboard until you leave it.
+  await verb(`${NS}.next`, ["j", "<Down>"], "Next knob", (s) => move(s, 1));
+  await verb(`${NS}.prev`, ["k", "<Up>"], "Previous knob", (s) => move(s, -1));
+  await verb(`${NS}.higher`, ["l", "<Right>"], "More", (s) => shift(s, 1, false));
+  await verb(`${NS}.lower`, ["h", "<Left>"], "Less", (s) => shift(s, -1, false));
+  await verb(`${NS}.cycle`, ["<Tab>", "<Space>"], "The next value along", (s) => shift(s, 1, true));
+  // `^E` closes it too, the way `^S` leaves reading the transcript. A key that opens a surface and
+  // cannot shut it is one you have to remember a second key for — and with the panel modal, the
+  // global `^E` no longer arrives to do it.
+  await verb(
+    `${NS}.close`,
+    ["<Esc>", "q", "<C-c>", "<C-e>"],
+    "Back to the composer",
+    (s) => s.close(),
+  );
+  // Nothing left to apply — every change is already in effect — so what this adds is where the
+  // acknowledgement *goes*: the panel shuts and the strip it moved to flashes, which is the answer
+  // to "fine, but where does that live now". Deliberately not a flash inside the panel: anything
+  // that holds the window open after the key that dismissed it is a window still eating keys, and
+  // a swallowed `^P` costs more than a lit row is worth.
+  await verb(`${NS}.done`, ["<CR>"], "Done", async (s) => {
+    await s.close();
+    await refresh(true);
+  });
+
+  subscriptions.push({ dispose: () => void sheet?.close() });
+}
+
+/**
+ * Open the sheet for whatever model this conversation is on.
+ *
+ * Reads the descriptors afresh every time rather than caching them: they arrive from the *driver*,
+ * and a driver that learned what it accepts by asking — `codex` does — reports a different set
+ * after a refresh than it did at startup.
+ */
+export async function openOptions(neosh: Neosh): Promise<void> {
+  if (sheet) {
+    await sheet.close();
+    return;
+  }
+  const current = await neosh.agent.selection().catch(() => null);
+  if (!current) {
+    neosh.notify("no model is selected", "warn");
+    return;
+  }
+  const entries = await neosh.agent.listModels(current.instance).catch(() => [] as ModelEntry[]);
+  const model = entries.find((e) => e.model.id === current.model)?.model;
+  const descriptors = model?.capabilities?.option_descriptors ?? [];
+  if (descriptors.length === 0) {
+    // Which model, because the answer to "why not" is almost always "not that one" — a small model
+    // in a lineup whose big one has five levels, or an endpoint that told us only an id.
+    neosh.notify(`${model?.display_name ?? current.model} has nothing to set`, "info");
+    return;
+  }
+
+  const rows = rowsFrom(descriptors, current.options ?? []);
+  const buf = await neosh.buf.create({
+    name: "[model options]",
+    scratch: true,
+    kind: KIND,
+  });
+  const ns = await neosh.ns.create(NS);
+  // Wide enough for the longest ladder plus its labels, and no wider: this is a control panel, not
+  // a page, and a float that spans the terminal reads as something you have to finish reading.
+  const labelWidth = Math.max(...rows.map((r) => width(r.label)));
+  const widest = Math.max(
+    // `+ 2` for the rail: `‹` and `›` are part of the row, and a ladder measured without them is
+    // one whose last chevron falls off the right-hand edge on the widest row.
+    ...rows.map((r) =>
+      r.choices.reduce((n, c) => n + width(c.label) + (c.spoken ? 5 : 2) + 1, 0) + 2
+    ),
+    width(hintsFor()),
+  );
+  const inner = Math.min(96, labelWidth + widest + 8);
+  const config: FloatOptions = {
+    anchor: { kind: "screen" },
+    width: { kind: "max", n: inner },
+    height: { kind: "fixed", n: rows.length + 3 },
+    border: "rounded",
+    title: ` ${model?.display_name ?? current.model} `,
+    focusable: true,
+    closeOnBlur: true,
+    // Nothing else reaches the keyboard while this is up. It is a control sheet you are in the
+    // middle of using: `^N` over it opened a new conversation *behind* it, `^T` opened the project
+    // panel and left focus somewhere neither of them expected, and the panel stayed on screen
+    // through both. `^Q` and `^R` still work — see `ui.modal_escape_keys` — so this can never be
+    // a terminal somebody has to kill.
+    modal: true,
+    z: 200,
+  };
+  const win = await neosh.float.open(buf, config);
+  await neosh.focus.push(win);
+
+  const s: Sheet = {
+    win,
+    buf,
+    ns,
+    rows,
+    cursor: 0,
+    selection: current,
+    title: model?.display_name ?? String(current.model),
+    inner,
+    config,
+    // What the border currently says, not what the rows currently are — so the first `draw` finds
+    // them different and lights it, which is what opening straight onto `ultracode` needs.
+    beyond: false,
+    close: async () => {
+      if (sheet !== s) return;
+      sheet = null;
+      await neosh.focus.pop().catch(() => {});
+      await neosh.win.close(win).catch(() => {});
+    },
+  };
+  sheet = s;
+  await draw(neosh, s, hintsFor());
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@neosh/model",
+  "version": "0.1.0",
+  "description": "Model and reasoning-effort switchers, in the status line and behind a picker.",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "neosh",
+    "neosh-plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/neoswarm/neosh.git",
+    "directory": "plugins/builtin/model"
+  },
+  "files": [
+    "*.ts",
+    "plugin.toml",
+    "!._*"
+  ]
+}

package/plugin.toml

@@ -0,0 +1,4 @@
+name = "model"
+version = "0.1.0"
+entry = "main.ts"
+description = "Model and reasoning-effort switchers, in the status line and behind a picker."