quoxcli 0.2.0 → 0.4.0

package/lib/quoxon/model.js

@@ -7,15 +7,27 @@
  * differs from what was asked, the client says so once (never a silent fallback).
  * null choice = auto (no provider in the body; the server's policy picks).
  *
- * Availability is the same source as /connect: the org's default QuoxVault credential per provider.
+ * Availability is the same source as /connect, /doctor and /capabilities (providers.js): the server's
+ * capabilities, with the org vault for detail.
  * Model ids mirror src/config/modelCatalog.js (openai + anthropic rows); an id not listed is passed
  * through with a note, the server decides whether it exists.
  */
-import { PROVIDERS as CONNECT, pickRow, offerText } from './connect.js';
+import { PROVIDERS as CONNECT, offerText } from './connect.js';
+import { providerState, SUBSCRIPTION_NAME } from './providers.js';
+
+/**
+ * No hardcoded model lists for the hosted providers: OpenAI and the Claude API are listed live by the server
+ * (GET /api/v1/providers/<p>/models, 1 h server cache, refreshed by /model). The Claude SUBSCRIPTION has no
+ * key to list with, so it takes the Claude CLI's family aliases, which the CLI resolves to the newest model.
+ */
+export const CLAUDE_FAMILIES = ['fable', 'opus', 'sonnet', 'haiku'];
 
 export const CHOICES = [
-  { id: 'openai', provider: 'openai', name: 'OpenAI', vault: 'openai', connect: 'openai', models: ['gpt-5.4', 'gpt-5.4-mini', 'gpt-5.4-nano'] },
-  { id: 'anthropic', provider: 'anthropic', name: 'Claude API', vault: 'anthropic', connect: 'anthropic', models: ['claude-sonnet-4-6', 'claude-opus-4-6', 'claude-haiku-4-5-20251001'] },
+  { id: 'openai', provider: 'openai', name: 'OpenAI', vault: 'openai', connect: 'openai', discover: true, models: [] },
+  { id: 'anthropic', provider: 'anthropic', name: 'Claude API', vault: 'anthropic', connect: 'anthropic', discover: true, models: [] },
+  // R3: the server's signed-in Claude subscription (dev only). The stream asks for anthropic; with no Claude API
+  // key the server runs it through the claude CLI on that sign-in. `via` only tells the client which row it is.
+  { id: 'claude-cli', provider: 'anthropic', via: 'subscription', cap: 'claude_subscription', name: SUBSCRIPTION_NAME, aliases: CLAUDE_FAMILIES, models: [] },
   // B3: served by the chat stream; models are whatever that Ollama has installed (listed by the server).
   { id: 'ollama', provider: 'ollama', name: 'Ollama', vault: 'ollama', connect: 'ollama', dynamic: true, hint: 'http://<host>:11434', models: [] },
   // B5: OpenAI-compatible presets. Models come from the provider's own /models (api.compatModels).
@@ -27,13 +39,16 @@ export const CHOICES = [
     ['custom', 'Custom', 'openai_compatible', false, ' https://<host>/v1']
   ].map(([id, name, vault, hosted, hint]) => ({ id, provider: id, name, vault, connect: id, dynamic: true, compat: true, hosted, selfHosted: !hosted, hint: hint.trim(), models: [] }))
 ];
-const ALIASES = { gpt: 'openai', chatgpt: 'openai', claude: 'anthropic', 'claude-api': 'anthropic', 'anthropic-api': 'anthropic', local: 'ollama', hf: 'huggingface', 'lm-studio': 'lmstudio', 'openai-compatible': 'custom', openai_compatible: 'custom', default: 'auto', policy: 'auto' };
+const ALIASES = { 'claude-subscription': 'claude-cli', subscription: 'claude-cli', 'claude-code': 'claude-cli', gpt: 'openai', chatgpt: 'openai', claude: 'anthropic', 'claude-api': 'anthropic', 'anthropic-api': 'anthropic', local: 'ollama', hf: 'huggingface', 'lm-studio': 'lmstudio', 'openai-compatible': 'custom', openai_compatible: 'custom', default: 'auto', policy: 'auto' };
 const byProvider = (p) => CHOICES.find(c => c.provider === p) || null;
+/** The CHOICES row a stored choice is (the subscription row shares provider anthropic). */
+const rowOf = (ch) => (ch?.via === 'subscription' ? CHOICES.find(c => c.via === 'subscription') : byProvider(ch?.provider));
 
 /** Stored or flag value -> { provider, model? } | null. Only the two known fields survive. */
 export function normChoice(v) {
   if (!v || typeof v !== 'object' || typeof v.provider !== 'string' || !byProvider(v.provider)) return null;
   const out = typeof v.model === 'string' && v.model.trim() ? { provider: v.provider, model: v.model.trim() } : { provider: v.provider };
+  if (v.provider === 'anthropic' && v.via === 'subscription') out.via = 'subscription';
   // B3/B5: the Ollama / self-hosted host, for the status line before the first turn (turn.started.endpoint wins after).
   if ((v.provider === 'ollama' || byProvider(v.provider).selfHosted) && typeof v.host === 'string' && v.host.trim()) out.host = v.host.trim().slice(0, 120);
   // D3: prompt profile (compact | full); absent = the server default (compact on ollama / local presets, full elsewhere).
@@ -53,31 +68,46 @@ export function parseModelArg(arg) {
   if (id === 'auto') return { ok: true, choice: null };
   const c = CHOICES.find(x => x.id === id);
   if (!c) return { ok: false, error: `No provider called "${rawName}". Use ${CHOICES.map(x => x.id).join(', ')} or auto (/model lists them).` };
-  const choice = model ? { provider: c.provider, model } : { provider: c.provider };
+  const resolved = model;
+  const choice = resolved ? { provider: c.provider, model: resolved } : { provider: c.provider };
+  if (c.via) choice.via = c.via;
   if (profile) choice.profile = profile;
   return { ok: true, choice };
 }
 
-/** -> 'connected' | 'stored' | 'missing' | 'unknown' (+ the row) for one choice. */
-function availability(res, c) {
-  if (!res || !res.ok || !Array.isArray(res.rows)) return { state: 'unknown' };
-  const { def, any } = pickRow(res.rows, c.vault);
-  if (def) return { state: 'connected', row: def };
-  if (any) return { state: 'stored', row: any };
-  return { state: 'missing' };
-}
+/** -> { state, row?, reason? } for one choice, from the shared provider status (providers.js). */
+const availability = (res, c, caps) => providerState({ cap: c.cap || c.id, vault: c.vault }, caps, res);
+
+/** QUOXON-FW6: a typed provider name or alias -> the CHOICES id, or null. */
+export const providerId = (name) => {
+  const n = String(name || '').trim().toLowerCase();
+  const id = ALIASES[n] || n;
+  return CHOICES.some(c => c.id === id) ? id : null;
+};
+/** The CHOICES id a stored choice is (the subscription row shares provider anthropic). */
+export const choiceId = (ch) => (ch ? rowOf(ch)?.id || null : null);
+/** QUOXON-FW6: the CHOICES rows usable on this server now. Never lists a provider not connected. */
+export const connectedChoices = (res, caps = null) =>
+  CHOICES.filter(c => c.served !== false && availability(res, c, caps).state === 'connected');
 
-const same = (a, b) => (a?.provider || null) === (b?.provider || null);
+const same = (a, b) => (a?.provider || null) === (b?.provider || null) && (a?.via || null) === (b?.via || null);
 
-/** -> [[text, tone?]] lines for /model. */
-export function modelLines(res, current) {
+/** -> [[text, tone?]] lines for /model. `caps` = api.capabilities() (the server's word on each provider). */
+export function modelLines(res, current, caps = null) {
   const out = [['Model for your next turns (the server decides; turn.started shows what ran):']];
   const mark = (on) => (on ? '▸' : ' ');
   out.push([`${mark(!current)} auto  server policy picks the provider and model · /model auto`]);
   for (const c of CHOICES) {
-    const a = availability(res, c);
+    const a = availability(res, c, caps);
     const picked = same(current, c);
     const sel = picked && current.model ? ` · using ${current.model}` : '';
+    if (c.via === 'subscription') {
+      const api = availability(res, byProvider('anthropic'), caps).state === 'connected';
+      if (a.state === 'connected') out.push([`${mark(picked)} ● ${c.name}  ready on this server${sel} · /model claude-cli${api ? ' (the Claude API key is used first while it is connected)' : ''}`, 'ok']);
+      else if (a.state === 'unknown') out.push([`${mark(picked)} ? ${c.name}  unknown (the server did not say)`, 'warn']);
+      else out.push([`${mark(picked)} ○ ${c.name}  ${a.reason || 'not signed in on this server'} · sign in from the dashboard Terminal`]);
+      continue;
+    }
     if (c.served === false) {
       out.push([`${mark(picked)} ${c.name}  ${a.state === 'connected' ? 'connected, but ' : ''}not served by the chat stream yet`]);
       continue;
@@ -85,17 +115,17 @@ export function modelLines(res, current) {
     if (c.dynamic) {
       if (a.state === 'connected') out.push([`${mark(picked)} ● ${c.name}  connected · ${a.row.label || a.row.id}${sel} · /model ${c.id} lists its ${c.compat ? '' : 'installed '}models`, 'ok']);
       else if (a.state === 'stored') out.push([`${mark(picked)} ◐ ${c.name}  stored but not the default · quox vault set-default ${a.row.id}`, 'warn']);
-      else if (a.state === 'missing') out.push([`${mark(picked)} ○ ${c.name}  not connected · /connect ${c.connect}${c.hint ? ` ${c.hint}` : ''}`]);
+      else if (a.state === 'missing' || a.state === 'unavailable') out.push([`${mark(picked)} ○ ${c.name}  not connected · /connect ${c.connect}${c.hint ? ` ${c.hint}` : ''}`]);
       else out.push([`${mark(picked)} ? ${c.name}  unknown (vault not readable)${sel}`, 'warn']);
       continue;
     }
     const models = c.models.join(', ');
-    if (a.state === 'connected') out.push([`${mark(picked)} ● ${c.name}  connected${sel} · /model ${c.id} [${models}]`, 'ok']);
+    if (a.state === 'connected') out.push([`${mark(picked)} ● ${c.name}  connected${sel} · /model ${c.id} [${models || 'live list'}]`, 'ok']);
+    else if (a.state === 'unavailable') out.push([`${mark(picked)} ○ ${c.name}  ${a.reason || 'not available on this server'}`]);
     else if (a.state === 'stored') out.push([`${mark(picked)} ◐ ${c.name}  stored but not the default · quox vault set-default ${a.row.id}`, 'warn']);
     else if (a.state === 'missing') out.push([`${mark(picked)} ○ ${c.name}  not connected · /connect ${c.connect}`]);
     else out.push([`${mark(picked)} ? ${c.name}  unknown (vault not readable)${sel}`, 'warn']);
   }
-  out.push(['  ? Claude (subscription)  dev-only · reached via auto or anthropic when no Claude API key is stored; no status route']);
   if (!res?.ok) out.push([`  could not read the vault: ${res?.error || 'no answer'}`, 'warn']);
   return out;
 }
@@ -104,22 +134,76 @@ export function modelLines(res, current) {
  * The /model <arg> decision. -> { ok, choice?, text, tone? }. A provider the vault says is not usable is
  * refused (with the /connect offer), never quietly swapped for another.
  */
-export function selectModel(res, arg) {
+export function selectModel(res, arg, caps = null) {
   const p = parseModelArg(arg);
   if (!p.ok) return { ok: false, text: p.error, tone: 'warn' };
   if (!p.choice) return { ok: true, choice: null, text: 'Model: auto. The server policy picks the provider and model.', tone: 'ok' };
-  const c = byProvider(p.choice.provider);
+  const c = rowOf(p.choice);
   if (c.served === false) return { ok: false, text: `${c.name} is not served by the chat stream yet, so I can't use it here. /model lists what can.`, tone: 'warn' };
-  const a = availability(res, c);
+  const a = availability(res, c, caps);
+  const label0 = p.choice.model ? `${c.id} ${p.choice.model}` : c.id;
+  if (c.via === 'subscription') {
+    if (a.state === 'unknown') return { ok: true, choice: p.choice, text: `Model: ${label0}. Could not confirm the ${c.name} is signed in; the server will say if it is not.`, tone: 'warn' };
+    if (a.state !== 'connected') return { ok: false, text: `${c.name} is not ready on this server (${a.reason || 'not signed in'}). Sign in from the dashboard Terminal.`, tone: 'warn' };
+    const api = availability(res, byProvider('anthropic'), caps).state === 'connected';
+    return { ok: true, choice: p.choice, text: `Model: ${c.name}${p.choice.model ? ` · ${p.choice.model}` : ''}. ${api ? 'The Claude API key is connected, so the server uses it first.' : 'Your next turns ask for it.'}`, tone: api ? 'warn' : 'ok' };
+  }
+  if (c.id === 'anthropic' && a.state === 'missing' && availability(res, rowOf({ via: 'subscription' }), caps).state === 'connected') {
+    // what --provider anthropic does: no API key, so the server runs Claude on its signed-in subscription
+    return { ok: true, choice: { ...p.choice, via: 'subscription' }, text: `Model: ${label0}. The Claude API isn't connected, so your next turns run on the ${SUBSCRIPTION_NAME}.`, tone: 'warn' };
+  }
   if (c.dynamic && a.state === 'missing') return { ok: false, text: `${c.name} isn't connected, so I can't use it yet. Connect it: /connect ${c.connect}${c.hint ? ` ${c.hint}` : ''}`, tone: 'warn' };
   if (a.state === 'missing') return { ok: false, text: offerText(CONNECT[c.connect]), tone: 'warn' };
+  if (a.state === 'unavailable') return { ok: false, text: `${c.name} isn't available on this server${a.reason ? `: ${a.reason}` : ''}.`, tone: 'warn' };
   if (a.state === 'stored') return { ok: false, text: `${c.name} has a key stored, but not as the org default, so the server will not use it. Fix: quox vault set-default ${a.row.id}`, tone: 'warn' };
   const label = p.choice.model ? `${c.id} ${p.choice.model}` : c.id;
-  const extra = p.choice.model && !c.dynamic && !c.models.includes(p.choice.model) ? ` ${p.choice.model} is not in this client's list; the server decides whether it exists.` : '';
-  if (a.state === 'unknown') return { ok: true, choice: p.choice, text: `Model: ${label}. Could not confirm ${c.name} is connected (vault not readable); the server will say if it is not.${extra}`, tone: 'warn' };
+  const extra = p.choice.model && !c.dynamic && !c.discover && !c.models.includes(p.choice.model) ? ` ${p.choice.model} is not in this client's list; the server decides whether it exists.` : '';
+  if (a.state === 'unknown') return { ok: true, choice: p.choice, text: `Model: ${label}. Could not confirm ${c.name} is connected (the server did not say); the server will say if it is not.${extra}`, tone: 'warn' };
   return { ok: true, choice: p.choice, text: `Model: ${label}. Your next turns ask for it.${extra}`, tone: extra ? 'warn' : 'ok' };
 }
 
+/** Newest-first discovered rows -> ids. */
+const ids = (res) => (res?.ok && Array.isArray(res.models) ? res.models.map(modelId).filter(Boolean) : []);
+
+/**
+ * /model openai|anthropic [model] against the live list (res from api.providerModels(provider)).
+ * Match order: exact id, "latest" (newest listed), a family (opus, sonnet, mini, ...) or any prefix/substring ->
+ * the NEWEST match. No match -> a clear error with the list. Discovery failed -> any typed id is allowed with a
+ * plain note (the provider validates it on first use). -> { ok, choice?, text, tone, models?, current? }
+ */
+export function selectDiscoveredModel(res, choice, row) {
+  const name = row.name;
+  const model = choice.model || null;
+  const list = ids(res);
+  const rows = res?.ok ? res.models : [];
+  if (!res?.ok || !list.length) {
+    const why = res?.message || res?.error || 'no answer';
+    if (!model) return { ok: true, choice, text: `Model: ${row.id}. Could not list ${name}'s models (${why}); the server uses its default.`, tone: 'warn' };
+    return { ok: true, choice, text: `Model: ${row.id} ${model}. Could not list ${name}'s models (${why}); ${model} is sent as typed and the provider will say if it does not exist.`, tone: 'warn' };
+  }
+  const newest = res.default_model || list[0];
+  if (!model) return { ok: true, choice, text: `Model: ${name} · ${newest} (the newest listed). Models below; pick one with /model ${row.id} <model|family|latest>.`, tone: 'ok', models: rows, current: newest };
+  const q = model.toLowerCase();
+  const hit = q === 'latest' ? list[0]
+    : list.find(i => i.toLowerCase() === q)
+    || rows.find(r => r.family && r.family === q)?.id
+    || list.find(i => i.toLowerCase().startsWith(q))
+    || list.find(i => i.toLowerCase().includes(q));
+  if (!hit) return { ok: false, text: `${model} is not in ${name}'s live list. Pick an id, a family (${[...new Set(rows.map(r => r.family).filter(Boolean))].slice(0, 6).join(', ') || 'see below'}) or latest.`, tone: 'warn', models: rows };
+  return { ok: true, choice: { ...choice, model: hit }, text: `Model: ${name} · ${hit}${hit !== model ? ` (from "${model}")` : ''}. Your next turns ask for it.`, tone: 'ok' };
+}
+
+/** Subscription path: a Claude family alias (the CLI resolves the newest) or a full claude-* id; anything else is an error with the aliases. */
+export function selectSubscriptionModel(choice) {
+  const m = choice.model;
+  if (!m) return { ok: true, choice, text: 'Model: claude-cli. The server default applies (the newest Sonnet unless your org set CLAUDE_CLI_DEFAULT_MODEL).', tone: 'ok' };
+  const q = m.toLowerCase();
+  if (CLAUDE_FAMILIES.includes(q)) return { ok: true, choice: { ...choice, model: q }, text: `Model: claude-cli ${q} (the Claude CLI resolves the newest ${q}; turn.started shows what ran).`, tone: 'ok' };
+  if (q === 'latest') return { ok: true, choice: { provider: choice.provider, via: choice.via }, text: 'Model: claude-cli, the server default.', tone: 'ok' };
+  if (/^claude-[a-z0-9.\-]+$/i.test(m)) return { ok: true, choice, text: `Model: claude-cli ${m}. The CLI will say if it does not exist.`, tone: 'ok' };
+  return { ok: false, text: `Unknown Claude model "${m}". Use ${CLAUDE_FAMILIES.join(', ')} (the CLI picks the newest) or a full claude-* id.`, tone: 'warn' };
+}
+
 /**
  * B3: /model ollama [model] against the server's installed-model list (res from api.ollamaModels()).
  * -> { ok, choice?, text, tone, rows? } ; rows = the installed list to show.
@@ -179,13 +263,35 @@ export function selectCompatModel(res, presetId, model) {
   return { ok: true, choice: withHost({ provider: c.provider, model }), text: `Model: ${c.name}${host ? ` · ${host}` : ''} · ${model}. Your next turns ask for it.`, tone: 'ok' };
 }
 
+/**
+ * Z2H-3B: after a successful /connect, should the new provider become the active choice? Yes when the current
+ * selection is not a working connected provider (nothing connected, or a saved/phantom choice that is not connected),
+ * or when auto has no OTHER connected provider to pick. No provider is a silent default: with another working one
+ * active, nothing changes and the caller keeps its "Use it: /model <id>" hint.
+ * -> { adopt:true, choice, line } | { adopt:false }. `vault`/`caps` are re-read AFTER the connect.
+ */
+export function adoptAfterConnect({ vault, caps, current, id, host = null, model = null }) {
+  const row = CHOICES.find(c => c.id === id);
+  if (!row) return { adopt: false };
+  const connected = (c) => availability(vault, c, caps).state === 'connected';
+  const cur = current ? rowOf(current) : null;
+  const curWorks = cur && cur.id !== row.id && connected(cur);
+  const othersConnected = CHOICES.some(c => c.id !== row.id && connected(c));
+  if (curWorks) return { adopt: false };
+  if (!current && othersConnected) return { adopt: false };
+  const choice = normChoice({ provider: row.provider, ...(model ? { model } : {}), ...(host ? { host } : {}) });
+  return { adopt: true, choice, line: `Using ${row.name}${model ? ` ${model}` : ''} now. /model to change.` };
+}
+
 /** Status-line text: what the server said it ran, else what is selected; null for auto before any turn (keeps the line short). */
 export function modelLabel(ctx, choice) {
+  if (ctx?.model && ctx.provider === 'anthropic' && ctx.auth === 'subscription') return `claude-cli ${ctx.model}`;
   if (ctx?.model && ctx.provider === 'ollama') return `Ollama · ${ctx.endpoint || choice?.host || '?'} · ${ctx.model}`;
   const cc = ctx?.provider ? byProvider(ctx.provider) : null;
   if (ctx?.model && cc?.compat) return cc.hosted ? `${cc.name} · ${ctx.model}` : `${cc.name} · ${ctx.endpoint || choice?.host || '?'} · ${ctx.model}`;
   if (ctx?.model) return ctx.provider ? `${ctx.provider} ${ctx.model}` : ctx.model;
   if (!choice) return null;
+  if (choice.via === 'subscription') return choice.model ? `claude-cli ${choice.model}` : 'claude-cli';
   if (choice.provider === 'ollama') return `Ollama · ${choice.host || '?'} · ${choice.model || 'default model'}`;
   const ch = byProvider(choice.provider);
   if (ch?.compat) return ch.hosted ? `${ch.name} · ${choice.model || 'pick a model'}` : `${ch.name} · ${choice.host || '?'} · ${choice.model || 'default model'}`;

package/lib/quoxon/modelPrefs.js

@@ -0,0 +1,345 @@
+/**
+ * QUOXON-FW6: model favourites and the default model. Pure helpers plus one quiet live-list reader.
+ *
+ * The preference is { favourites: [{ provider, model }], default: { provider, model } | null }.
+ * `provider` is a /model provider id (openai, anthropic, claude-cli, ollama, a compat preset).
+ * Persistence is the caller's (api.modelPrefs / api.setModelPrefs: the user's server-side
+ * preferences, with the profile as a cache). There is no model list in this file: ids come from
+ * the provider's own live list (liveModels) or from what the user typed. A typed id that is not on
+ * the live list is kept with a warning, never refused.
+ */
+import { CHOICES, CLAUDE_FAMILIES, providerId } from './model.js';
+
+export const MAX_FAVS = 20;
+const nameOf = (id) => CHOICES.find((c) => c.id === id)?.name || id;
+
+const cleanOne = (v) => {
+  const provider = providerId(v?.provider);
+  const model = typeof v?.model === 'string' ? v.model.trim().slice(0, 200) : '';
+  return provider && model && !/\s/.test(model) ? { provider, model } : null;
+};
+export const sameModel = (a, b) =>
+  Boolean(a && b) && a.provider === b.provider && a.model === b.model;
+
+/** Anything stored or received -> a clean prefs object (bad rows dropped, duplicates removed). */
+export function normPrefs(v) {
+  const favs = [];
+  for (const f of Array.isArray(v?.favourites) ? v.favourites : []) {
+    const c = cleanOne(f);
+    if (c && !favs.some((x) => sameModel(x, c)) && favs.length < MAX_FAVS) favs.push(c);
+  }
+  return { favourites: favs, default: cleanOne(v?.default) };
+}
+
+export const label = (m) => `${m.provider} ${m.model}`;
+
+/** -> { prefs, added, text, tone }. */
+export function addFav(prefs, provider, model) {
+  const c = cleanOne({ provider, model });
+  if (!c)
+    return { prefs, added: false, text: 'Usage: /model fav add <provider> <model>', tone: 'warn' };
+  const at = prefs.favourites.findIndex((f) => sameModel(f, c));
+  if (at >= 0)
+    return {
+      prefs,
+      added: false,
+      text: `${label(c)} is already favourite ${at + 1}.`,
+      tone: 'plain',
+    };
+  if (prefs.favourites.length >= MAX_FAVS)
+    return {
+      prefs,
+      added: false,
+      text: `You have ${MAX_FAVS} favourites already. /model fav rm <n> makes room.`,
+      tone: 'warn',
+    };
+  const next = { ...prefs, favourites: [...prefs.favourites, c] };
+  const n = next.favourites.length;
+  return {
+    prefs: next,
+    added: true,
+    text: `Added ${label(c)} as favourite ${n}. /model ${n} switches to it.`,
+    tone: 'ok',
+  };
+}
+
+/**
+ * ref = a 1-based number, or a model id (exact, "provider model", "provider/model", or a
+ * unique substring).
+ */
+export function rmFav(prefs, ref) {
+  const q = String(ref ?? '')
+    .trim()
+    .toLowerCase();
+  const favs = prefs.favourites;
+  if (!q) return { prefs, removed: null, text: 'Usage: /model fav rm <n|model>', tone: 'warn' };
+  let idx = -1;
+  if (/^\d+$/.test(q)) idx = Number(q) - 1;
+  else {
+    const exact = favs
+      .map((f, i) => i)
+      .filter(
+        (i) =>
+          favs[i].model.toLowerCase() === q ||
+          label(favs[i]).toLowerCase() === q ||
+          `${favs[i].provider}/${favs[i].model}`.toLowerCase() === q,
+      );
+    const part = favs.map((f, i) => i).filter((i) => favs[i].model.toLowerCase().includes(q));
+    const hits = exact.length ? exact : part;
+    if (hits.length > 1)
+      return {
+        prefs,
+        removed: null,
+        text:
+          `"${ref}" matches ${hits.map((i) => `${i + 1} ${label(favs[i])}`).join(', ')}. ` +
+          'Use the number.',
+        tone: 'warn',
+      };
+    idx = hits.length ? hits[0] : -1;
+  }
+  if (idx < 0 || idx >= favs.length)
+    return {
+      prefs,
+      removed: null,
+      text: favs.length
+        ? `No favourite "${ref}". /model fav lists them.`
+        : 'You have no favourites yet. /model fav add <provider> <model>',
+      tone: 'warn',
+    };
+  const removed = favs[idx];
+  return {
+    prefs: { ...prefs, favourites: favs.filter((_, i) => i !== idx) },
+    removed,
+    text: `Removed ${label(removed)}. The numbers after it moved up by one.`,
+    tone: 'ok',
+  };
+}
+
+export function setDefault(prefs, provider, model) {
+  const c = cleanOne({ provider, model });
+  if (!c)
+    return { prefs, ok: false, text: 'Usage: /model default <provider> <model>', tone: 'warn' };
+  return {
+    prefs: { ...prefs, default: c },
+    ok: true,
+    text:
+      `Default model: ${label(c)}. New sessions start on it when ${nameOf(c.provider)} is ` +
+      `connected. /model ${label(c)} uses it now.`,
+    tone: 'ok',
+  };
+}
+export const clearDefault = (prefs) => ({
+  prefs: { ...prefs, default: null },
+  text: 'Default model cleared. New sessions use the last choice, else the server policy.',
+  tone: 'ok',
+});
+
+/** Toggle one model in the favourites -> { prefs, added }. */
+export function toggleFav(prefs, m) {
+  const i = prefs.favourites.findIndex((f) => sameModel(f, m));
+  if (i >= 0)
+    return {
+      prefs: { ...prefs, favourites: prefs.favourites.filter((_, k) => k !== i) },
+      added: false,
+    };
+  return {
+    prefs: {
+      ...prefs,
+      favourites: [...prefs.favourites, { provider: m.provider, model: m.model }].slice(
+        0,
+        MAX_FAVS,
+      ),
+    },
+    added: true,
+  };
+}
+
+/** /model fav lines. `current` = the stored choice ({ provider, model?, via? }) or null. */
+export function favLines(prefs, currentKey = null) {
+  if (!prefs.favourites.length)
+    return [
+      [
+        'No favourites yet. Add one: /model fav add <provider> <model> ' +
+          '(or open /model and press f)',
+      ],
+    ];
+  const out = [['Favourite models (/model <n> switches):']];
+  prefs.favourites.forEach((f, i) => {
+    const marks = [
+      currentKey && sameModel(f, currentKey) ? 'current' : null,
+      prefs.default && sameModel(f, prefs.default) ? 'default' : null,
+    ].filter(Boolean);
+    out.push([`  ${i + 1}  ${label(f)}${marks.length ? `  (${marks.join(', ')})` : ''}`, 'plain']);
+  });
+  out.push([
+    prefs.default
+      ? `Default: ${label(prefs.default)}`
+      : 'No default model set. /model default <provider> <model>',
+  ]);
+  return out;
+}
+
+const FAV_WORDS = new Set(['fav', 'favs', 'favourite', 'favourites', 'favorite', 'favorites']);
+const SUBS_ONE = { list: 'list', status: 'list' };
+
+/**
+ * The words after /model -> what to do. kinds: chooser list use fav-list fav-add fav-rm
+ * default-show default-set default-clear error pass.
+ */
+export function parseModelSub(arg) {
+  const w = String(arg || '')
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean);
+  if (!w.length) return { kind: 'chooser' };
+  const first = w[0].toLowerCase();
+  if (SUBS_ONE[first] && w.length === 1) return { kind: SUBS_ONE[first] };
+  if (/^\d+$/.test(first) && w.length === 1) return { kind: 'use', n: Number(first) };
+  if (FAV_WORDS.has(first)) {
+    const sub = (w[1] || '').toLowerCase();
+    if (!sub) return { kind: 'fav-list' };
+    if (/^\d+$/.test(sub) && w.length === 2) return { kind: 'use', n: Number(sub) };
+    if (sub === 'add') {
+      if (w.length !== 4)
+        return {
+          kind: 'error',
+          text:
+            'Usage: /model fav add <provider> <model>   ' +
+            'e.g. /model fav add openai gpt-5.6-terra',
+        };
+      return { kind: 'fav-add', provider: w[2], model: w[3] };
+    }
+    if (['rm', 'remove', 'del', 'delete'].includes(sub))
+      return w.length < 3
+        ? { kind: 'error', text: 'Usage: /model fav rm <n|model>' }
+        : { kind: 'fav-rm', ref: w.slice(2).join(' ') };
+    return {
+      kind: 'error',
+      text: 'Usage: /model fav [add <provider> <model> | rm <n|model> | <n>]',
+    };
+  }
+  if (first === 'default') {
+    if (w.length === 1) return { kind: 'default-show' };
+    if (w.length === 2 && ['clear', 'none', 'off', 'unset'].includes(w[1].toLowerCase()))
+      return { kind: 'default-clear' };
+    if (w.length === 3) return { kind: 'default-set', provider: w[1], model: w[2] };
+    return { kind: 'error', text: 'Usage: /model default [<provider> <model> | clear]' };
+  }
+  return { kind: 'pass' };
+}
+
+/**
+ * A provider's list response (the shape differs per provider) -> ids, newest first as the
+ * server gave them.
+ */
+export function idsOf(choiceId, res) {
+  if (choiceId === 'claude-cli') return [...CLAUDE_FAMILIES];
+  if (!res?.ok || !Array.isArray(res.models)) return [];
+  const raw =
+    choiceId === 'ollama'
+      ? res.models.map((m) => (typeof m === 'string' ? m : m?.name))
+      : res.models.map((m) => (typeof m === 'string' ? m : m?.id));
+  return raw.filter((x) => typeof x === 'string' && x);
+}
+
+/**
+ * The live model ids for one provider, never throws. -> { ok, ids, def }. ok=false means
+ * "could not list" (the caller decides how quiet to be); ids is [] then.
+ */
+export async function liveModels(api, id, { refresh = false } = {}) {
+  try {
+    if (id === 'claude-cli') return { ok: true, ids: [...CLAUDE_FAMILIES], def: null };
+    const row = CHOICES.find((c) => c.id === id);
+    if (!row) return { ok: false, ids: [], def: null };
+    let res = null;
+    if (id === 'ollama') res = await api.ollamaModels?.();
+    else if (row.compat) res = await api.compatModels?.(id);
+    else if (row.discover)
+      res = await api.providerModels?.(row.provider, refresh ? { refresh: true } : undefined);
+    if (!res?.ok) return { ok: false, ids: [], def: null };
+    return { ok: true, ids: idsOf(id, res), def: res.default_model || null };
+  } catch {
+    return { ok: false, ids: [], def: null };
+  }
+}
+
+/**
+ * Typed id vs the live list -> { model, known: true|false|null, note? }. null = no list to
+ * check against.
+ */
+export function checkModelId(ids, typed, providerName = '') {
+  if (!ids?.length) return { model: typed, known: null };
+  if (ids.includes(typed)) return { model: typed, known: true };
+  const ci =
+    ids.find((i) => i.toLowerCase() === typed.toLowerCase()) ||
+    ids.find((i) => i === `${typed}:latest`);
+  if (ci) return { model: ci, known: true };
+  return {
+    model: typed,
+    known: false,
+    note:
+      `${typed} is not on ${providerName || 'the provider'}'s live list right now; ` +
+      'kept as typed in case it is new.',
+  };
+}
+
+/* ---- the /model chooser ---------------------------------------------------------- */
+
+/**
+ * Selectable items, in display order: favourites first (numbered by their place in the full
+ * list; ones on a provider that is not connected are left out), then each connected provider's
+ * models.
+ * groups: [{ id, name, ids, note? }] for CONNECTED providers only.
+ */
+export function chooserItems(prefs, groups) {
+  const connected = new Set(groups.map((g) => g.id));
+  const items = [];
+  prefs.favourites.forEach((f, i) => {
+    if (connected.has(f.provider))
+      items.push({ kind: 'fav', n: i + 1, provider: f.provider, model: f.model });
+  });
+  for (const g of groups) {
+    if (!g.ids.length)
+      items.push({
+        kind: 'provider',
+        provider: g.id,
+        model: null,
+        name: g.name,
+        note: g.note || 'no model list; the server picks',
+      });
+    else
+      for (const id of g.ids)
+        items.push({ kind: 'model', provider: g.id, model: id, name: g.name });
+  }
+  return items;
+}
+
+/**
+ * One picker row ({ key, text, note? }) for an item. `current` = { provider, model } of the
+ * stored choice, or null.
+ */
+export function chooserRow(item, prefs, current) {
+  if (item.kind === 'provider')
+    return { key: item.provider, text: item.name, note: item.note, dim: false };
+  const here = current && current.model ? sameModel(current, item) : false;
+  const marks = [
+    here ? 'current' : null,
+    prefs.default && sameModel(prefs.default, item) ? 'default' : null,
+    item.kind === 'model' && prefs.favourites.some((f) => sameModel(f, item)) ? '★' : null,
+  ].filter(Boolean);
+  const body = item.kind === 'fav' ? label(item) : item.model;
+  return {
+    key: item.kind === 'fav' ? `★ ${item.n}` : item.provider,
+    text: body + (marks.length ? `   ${marks.join(' · ')}` : ''),
+  };
+}
+
+/**
+ * The stored choice as { provider: <CHOICES id>, model } for marking; null when it carries no
+ * model.
+ */
+export function currentKey(choice, idOf) {
+  if (!choice?.model) return null;
+  const provider = idOf(choice);
+  return provider ? { provider, model: choice.model } : null;
+}

package/lib/quoxon/motion/clock.js

@@ -6,6 +6,7 @@
  *
  * Demand shapes: { every: ms } (repeat while declared) or { at: epochMs } (one wake at that time).
  */
+import { normaliseLevel } from './level.js';
 export const FRAME_MS = 83; // ~12 fps for anything that moves
 export const SECOND_MS = 1000;
 
@@ -49,8 +50,8 @@ export class Clock {
   get armed() { return this.id != null; }
 }
 
-/** Motion is decoration: off under QUOX_REDUCED_MOTION=1, QUOX_TUI_LITE, or when not on a real terminal. Colour is separate (NO_COLOR). */
-export const reducedMotion = (env = process.env) => env.QUOX_REDUCED_MOTION === '1' || Boolean(env.QUOX_TUI_LITE);
+/** Motion is decoration: off at the quiet level (QUOX_MOTION=quiet, QUOX_REDUCED_MOTION=1, QUOX_TUI_LITE), or when not on a real terminal. Colour is separate (NO_COLOR). */
+export const reducedMotion = (env = process.env) => env.QUOX_REDUCED_MOTION === '1' || Boolean(env.QUOX_TUI_LITE) || normaliseLevel(env.QUOX_MOTION) === 'quiet';
 export const motionAllowed = (isTTY, env = process.env) => Boolean(isTTY) && !reducedMotion(env);
 
 /**