quoxcli 0.0.0-stage → 0.3.1

package/lib/quoxon/slash/inverses.js

@@ -0,0 +1,77 @@
+/**
+ * /undo: which tool calls count as state changes, and the small registry of KNOWN inverses.
+ *
+ * Receipts are content-free on purpose (the AEE envelope commits to the action by digest, never plaintext
+ * args) and the stream summary only echoes a few safe keys. So an inverse is never built from "what the
+ * receipt said the args were". Each entry binds its target from something that is really there: a safe key
+ * in the call's own summary (slot name), or the server's own record of what the call produced, matched by
+ * time window and accepted only when EXACTLY ONE record fits. Zero or several = not bound = nothing runs,
+ * and the user gets the by-hand route. Nothing here guesses an inverse.
+ */
+
+const READ_ONLY = /(^|_)(list|get|read|search|status|view|history|health|query|check|show|stats|find|lookup|related|suggest|research|describe|info|accounts|folders|pending|proposals|blocked|report|transcript|doctor|ping|whoami|verify)(_|$)/;
+
+/** A settled, successful, receipt-backed call that is not a read. */
+export function isStateChanging(b) {
+  return Boolean(b) && b.kind === 'tool' && b.status === 'ok' && Boolean(b.envelopeId) && Boolean(b.tool) && !READ_ONLY.test(String(b.tool));
+}
+
+export function lastStateChange(items) {
+  const all = (items || []).filter(isStateChanging);
+  return all.length ? all[all.length - 1] : null;
+}
+
+const WIN_BEFORE = 10_000;
+const WIN_AFTER = 20_000;
+const toMs = (v) => (typeof v === 'number' ? v : Number.isFinite(Date.parse(v)) ? Date.parse(v) : null);
+function inWindow(call, ts) {
+  const t = toMs(ts);
+  if (t == null || !Number.isFinite(call.startedAt)) return false;
+  return t >= call.startedAt - WIN_BEFORE && t <= call.startedAt + (call.durationMs || 0) + WIN_AFTER;
+}
+const summaryKey = (call, key) => new RegExp(`(?:^|\\s)${key}=(\\S+)`).exec(String(call.summary || ''))?.[1] || null;
+
+/** Each bind -> { ok: true, label, run(ops) -> { receipt } } | { ok: false, why, byHand } */
+export const INVERSES = {
+  slot_checkout: {
+    did: 'checked a slot out for this conversation',
+    async bind(call) {
+      const name = summaryKey(call, 'name');
+      if (!name) return { ok: false, why: 'the call summary does not name the slot', byHand: 'quox slot list, then quox slot release <name>' };
+      return { ok: true, reverse: `release slot ${name} (the hold ends; the slot itself stays)`, run: (ops) => ops.releaseSlot(name) };
+    }
+  },
+  inbox_move: {
+    did: 'moved mail between folders',
+    async bind(call, ops) {
+      const moves = (await ops.recentMoves()).filter(m => inWindow(call, m.movedAt ?? m.moved_at));
+      if (moves.length === 1) {
+        const m = moves[0];
+        return { ok: true, reverse: `move the message back from ${m.toFolder || m.to_folder || 'its new folder'} to ${m.fromFolder || m.from_folder || 'its source folder'} (move ${m.id})`, run: (o) => o.undoMove(m.id) };
+      }
+      return { ok: false, why: moves.length ? `more than one move fits that call (${moves.map(m => m.id).join(', ')}), so Quox can't tell which one it made` : 'no recorded move fits that call', byHand: 'quox mail moves, then quox mail undo <moveId>' };
+    }
+  },
+  notesq_create: {
+    did: 'created a note',
+    async bind(call, ops) {
+      const notes = (await ops.listNotes()).filter(n => inWindow(call, n.createdAt ?? n.created_at));
+      if (notes.length === 1) {
+        const n = notes[0];
+        return { ok: true, reverse: `delete the note "${n.title || n.id}" (${n.id})`, run: (o) => o.deleteNote(n.id) };
+      }
+      return { ok: false, why: notes.length ? `more than one note fits that call (${notes.map(n => n.id).join(', ')})` : 'no recorded note fits that call', byHand: 'quox notes list, then delete the one you mean from NotesQ' };
+    }
+  }
+};
+
+/** Tools that change state but have no automatic inverse here: the by-hand route, stated plainly. */
+export const BY_HAND = {
+  activate_workflow: 'quox workflow list, then deactivate it from the dashboard or ask Quox to deactivate_workflow with the id',
+  deactivate_workflow: 'reactivate it with activate_workflow, or from the dashboard',
+  skill_manage: 'a created skill sits in the review queue: reject it there, or leave it unapproved',
+  notesq_delete: 'ask Quox to notesq_restore the note, or use quox notes restore <id>',
+  email_send: 'a sent email cannot be recalled',
+  email: 'a sent email cannot be recalled',
+  slot_say: 'a message already posted in a slot room stays there'
+};

package/lib/quoxon/slash/killer.js

@@ -0,0 +1,24 @@
+/**
+ * /watch, /automate, /crystallize: the shared factory app.js wires (switch cases + one answer hook).
+ * Each command makes ONE preview card; the next line y/n creates through an existing backend path.
+ */
+import { createConfirm } from './confirm.js';
+import { createWatchCmd } from './watch.js';
+import { createAutomateCmd } from './automate.js';
+import { createCrystallizeCmd } from './crystallize.js';
+
+export function createKillerCmds({ api, say, getState, getFields }) {
+  const confirm = createConfirm({ say });
+  const watch = createWatchCmd({ api, say, confirm });
+  const automate = createAutomateCmd({ api, say, confirm, getState, getFields });
+  const crystallize = createCrystallizeCmd({ api, say, confirm, getState, getFields });
+  return {
+    crystallize: (arg) => crystallize.handle(arg),
+    automate: (arg) => automate.handle(arg),
+    watch: (arg) => watch.handle(arg),
+    /** The composer line after a preview card: true when consumed as the y/n answer. */
+    answer: (text) => confirm.answer(text),
+    pending: () => confirm.pending(),
+    touch: () => confirm.touch()
+  };
+}

package/lib/quoxon/slash/killerApi.js

@@ -0,0 +1,16 @@
+/** Backend calls behind /watch, /automate and /crystallize, kept out of api.js (one spread there). */
+import { resolveEndpoint } from '../../api/endpoints.js';
+
+export function createKillerApi({ client }) {
+  return {
+    async watchCreate(body) { const ep = resolveEndpoint('agent-schedules.create'); return client.post(ep.path, { service: ep.service, body }); },
+    async watchList() { const ep = resolveEndpoint('agent-schedules.list'); return client.get(ep.path, { service: ep.service, retries: 0 }); },
+    async watchStop(id) { const ep = resolveEndpoint('agent-schedules.delete', { id }); return client.delete(ep.path, { service: ep.service }); },
+    /** quoxflow-direct, as `quox workflow apply`: -> the stored workflow (has .id). */
+    async workflowCreate(def) { const ep = resolveEndpoint('workflows.applyCreate'); const d = await client.post(ep.path, { service: ep.service, body: def }); return d?.data || d; },
+    /** As `quox trigger workflow-activate`: registers the workflow's triggers. */
+    async workflowActivate(workflowId) { const ep = resolveEndpoint('workflows.activate', { workflowId }); return client.post(ep.path, { service: ep.service, body: {} }); },
+    /** QSKL store create. { dryRun: true } asks only for the skill firewall verdict (throws 422 when blocked). */
+    async skillCreate(body, { dryRun = false } = {}) { const ep = resolveEndpoint('skills.create'); const d = await client.post(ep.path, { service: ep.service, body, query: dryRun ? { dry_run: 'true' } : undefined }); return d?.data || d; }
+  };
+}

package/lib/quoxon/slash/ledger.js

@@ -0,0 +1,88 @@
+/**
+ * Session usage ledger for /cost, /usage and /context. Fed the raw stream events of each turn; counts only
+ * what the server reported (turn.finished.usage, or done.usage on a server that never sends turn.finished).
+ * Nothing is estimated: a turn without usage is counted as "not reported", and cost stays blank unless the
+ * server sent cost_usd.
+ */
+const num = (v) => (v == null || v === '' || !Number.isFinite(Number(v)) ? null : Number(v));
+
+export function readUsage(u) {
+  const o = u && typeof u === 'object' ? u : {};
+  const input = num(o.input_tokens ?? o.prompt_tokens);
+  const output = num(o.output_tokens ?? o.completion_tokens);
+  const cacheRead = num(o.cache_read_input_tokens);
+  const cacheWrite = num(o.cache_creation_input_tokens);
+  const cost = num(o.cost_usd);
+  const costSource = typeof o.cost_source === 'string' ? o.cost_source : null; // 'claude-cli' = that CLI's own estimate
+  return { input, output, cacheRead, cacheWrite, cost, costSource, reported: input != null || output != null };
+}
+
+export function createLedger() {
+  const models = new Map(); // key -> row
+  const convs = new Map(); // conversation id -> tokens
+  let turn = null;
+  const finalize = (usage, convId) => {
+    if (!turn) return;
+    const t = turn; turn = null;
+    const raw = usage ?? t.doneUsage;
+    const u = readUsage(t.viaCli && raw && !raw.cost_source ? { ...raw, cost_source: 'claude-cli' } : raw); // the claude CLI path, from a server that does not label it yet
+    const key = `${t.provider || '?'}|${t.model || '?'}`;
+    const r = models.get(key) || { provider: t.provider, model: t.model, turns: 0, reported: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, costTurns: 0, estimate: 0, estimateTurns: 0 };
+    r.turns++;
+    if (u.reported) {
+      r.reported++;
+      r.input += u.input || 0; r.output += u.output || 0; r.cacheRead += u.cacheRead || 0; r.cacheWrite += u.cacheWrite || 0;
+      const id = convId || t.conversationId;
+      if (id) convs.set(id, (convs.get(id) || 0) + (u.input || 0) + (u.output || 0));
+    }
+    if (u.cost != null && u.costSource) { r.estimate += u.cost; r.estimateTurns++; } // reported by a tool, not a price
+    else if (u.cost != null) { r.cost += u.cost; r.costTurns++; }
+    models.set(key, r);
+  };
+  return {
+    observe(ev) {
+      if (!ev || typeof ev !== 'object') return;
+      if (ev.type === 'turn.started') turn = { provider: ev.provider || null, model: ev.model || null, conversationId: ev.conversation_id || null, doneUsage: null };
+      else if (ev.type === 'done' && turn) { turn.doneUsage = ev.usage || (ev.cost_usd != null ? { cost_usd: ev.cost_usd } : null); turn.viaCli = Boolean(ev.cli_session_id); }
+      else if (ev.type === 'turn.finished') finalize(ev.usage, ev.conversation_id);
+    },
+    /** The stream closed: settle a turn whose turn.finished never came (legacy servers send only done). */
+    end() { if (turn) finalize(null, null); },
+    rows: () => [...models.values()],
+    conversationTokens: (id) => (id ? convs.get(id) ?? 0 : 0),
+    totals() {
+      const t = { turns: 0, reported: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, costTurns: 0, estimate: 0, estimateTurns: 0 };
+      for (const r of models.values()) for (const k of Object.keys(t)) t[k] += r[k];
+      return t;
+    }
+  };
+}
+
+const n = (v) => Number(v || 0).toLocaleString('en-US');
+const usd = (v) => `$${v < 0.01 ? v.toFixed(4) : v.toFixed(2)}`;
+
+function line(r) {
+  const parts = [`${r.turns} turn${r.turns === 1 ? '' : 's'}`];
+  if (r.reported) {
+    parts.push(`in ${n(r.input)}`, `out ${n(r.output)}`);
+    if (r.cacheRead || r.cacheWrite) parts.push(`cache ${n(r.cacheRead)} read / ${n(r.cacheWrite)} written`);
+  }
+  if (r.reported < r.turns) parts.push(`${r.turns - r.reported} without usage from the server`);
+  if (r.costTurns || !r.estimateTurns) parts.push(r.costTurns === r.turns && r.turns ? usd(r.cost) : r.costTurns ? `${usd(r.cost)} for ${r.costTurns} of ${r.turns} turns` : 'cost not reported');
+  if (r.estimateTurns) parts.push(`${usd(r.estimate)} claude CLI's own estimate${r.estimateTurns < r.turns ? ` for ${r.estimateTurns} of ${r.turns} turns` : ''}`);
+  return parts.join(' · ');
+}
+
+/** -> help model rows for /cost. */
+export function costModel(ledger) {
+  const rows = ledger.rows();
+  const out = [{ kind: 'head', text: 'Cost and usage, this session' }];
+  if (!rows.length) return [...out, { kind: 'plain', text: 'No turns yet in this session.' }];
+  for (const r of rows) out.push({ kind: 'row', key: `${r.provider || '?'} ${r.model || ''}`.trim(), text: line(r) });
+  const t = ledger.totals();
+  if (rows.length > 1) out.push({ kind: 'row', key: 'Total', text: line(t) });
+  if (t.costTurns + t.estimateTurns < t.turns) out.push({ kind: 'dim', text: 'Cost is blank where the server sent tokens but no cost_usd for that provider; Quox does not guess prices.' });
+  if (t.estimateTurns) out.push({ kind: 'dim', text: "The Claude subscription path shows what the claude CLI reports: its own API-equivalent estimate, passed through as is. It is not a bill." });
+  if (t.reported < t.turns) out.push({ kind: 'dim', text: 'Some turns ended without usage (an older server, or a turn that failed or was interrupted).' });
+  return out;
+}

package/lib/quoxon/slash/listView.js

@@ -0,0 +1,30 @@
+/**
+ * One small list component for everything slash commands pop up under the composer: the command
+ * palette, the /resume picker and the /config card. Rows: { key, text, note?, dim? }. The selected
+ * row carries a marker; dim rows show their note (the reason) in muted text.
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { c, clip } from '../theme.js';
+
+const h = React.createElement;
+
+export function ListView({ title = null, rows = [], sel = 0, cols = 80, hint = null, empty = null, more = 0 }) {
+  // The key column grows with the window (22 cells minimum, 32 at most) and always leaves a one-cell gap, so a name that fits is shown whole;
+  // one that does not gets the ellipsis from truncate-end, never a silent cut.
+  const keyW = Math.min(Math.max(22, Math.min(32, Math.floor(cols / 3))), Math.max(8, ...rows.map(r => [...String(r.key || '')].length)) + 1);
+  const textW = Math.max(10, cols - keyW - 6);
+  return h(Box, { flexDirection: 'column', paddingLeft: 1 },
+    title ? h(Text, { color: c('muted'), bold: true }, clip(title, cols - 2)) : null,
+    !rows.length && empty ? h(Text, { color: c('muted') }, `  ${clip(empty, cols - 4)}`) : null,
+    ...rows.map((r, i) => {
+      const on = i === sel;
+      const body = r.dim && r.note ? `${r.note} · ${r.text}` : r.note ? `${r.text}  ${r.note}` : r.text;
+      return h(Box, { key: `${i}:${r.key}` },
+        h(Text, { color: on ? c('key') : c('muted') }, on ? '▸ ' : '  '),
+        h(Box, { width: keyW, flexShrink: 0 }, h(Text, { color: r.dim ? c('muted') : on ? c('key') : c('label'), bold: on && !r.dim, wrap: 'truncate-end' }, String(r.key || ''))),
+        h(Text, { color: c(r.dim ? 'muted' : 'text'), wrap: 'truncate-end' }, clip(String(body || ''), textW)));
+    }),
+    more > 0 ? h(Text, { color: c('muted') }, `  … ${more} more, keep typing to narrow`) : null,
+    hint ? h(Text, { color: c('dim') }, `  ${clip(hint, cols - 4)}`) : null);
+}

package/lib/quoxon/slash/modelCmd.js

@@ -0,0 +1,261 @@
+/**
+ * QUOXON-FW6: the /model favourites, default and chooser behaviour, kept out of app.js.
+ *
+ * Favourites and the default live in the user's server-side preferences (api.modelPrefs and
+ * api.setModelPrefs); this module only holds the in-memory copy (`mp.prefs`) and calls the api to
+ * save. Provider parity: nothing here knows one provider from another; the connected list and the
+ * live model lists decide what is shown.
+ */
+import {
+  CHOICES,
+  connectedChoices,
+  providerId,
+  choiceId,
+  modelLabel,
+  normChoice,
+} from '../model.js';
+import {
+  normPrefs,
+  addFav,
+  rmFav,
+  setDefault,
+  clearDefault,
+  toggleFav,
+  favLines,
+  liveModels,
+  checkModelId,
+  chooserItems,
+  chooserRow,
+  currentKey,
+  label,
+} from '../modelPrefs.js';
+import { clip } from '../theme.js';
+
+/**
+ * deps: api, say, command, mc (ref to the stored choice), mp (ref { prefs, touched, warned }),
+ * picker, state (ref), bump, cols.
+ */
+export function createModelCmd({ api, say, command, mc, mp, picker, state, bump, cols }) {
+  const byId = (id) => CHOICES.find((x) => x.id === id) || null;
+  const current = () => currentKey(mc.current, choiceId);
+
+  /** Optimistic: the in-memory copy changes at once; the server (user preferences) is the truth. */
+  async function save(next) {
+    mp.current.prefs = next;
+    bump();
+    if (!api.setModelPrefs) return true;
+    const r = await api.setModelPrefs(next);
+    if (!r.synced) {
+      say(
+        `Saved on this machine only (${r.error || 'the server did not take it'}). It is not on ` +
+          'the server yet, so it will not follow you to other machines. ' +
+          'Making the change again retries.',
+        'warn',
+      );
+    }
+    return Boolean(r.synced);
+  }
+
+  async function addOrDefault(sub) {
+    const pid = providerId(sub.provider);
+    if (!pid) {
+      const ids = CHOICES.map((x) => x.id).join(', ');
+      return say(`No provider called "${sub.provider}". Use ${ids}.`, 'warn');
+    }
+    // New models appear before lists update: an id missing from the live list is kept, with a
+    // warning.
+    const live = await liveModels(api, pid);
+    const chk = checkModelId(live.ids, sub.model, byId(pid).name);
+    const prefs = mp.current.prefs;
+    const r =
+      sub.kind === 'fav-add' ? addFav(prefs, pid, chk.model) : setDefault(prefs, pid, chk.model);
+    if (r.added === false || r.ok === false) return say(r.text, r.tone);
+    await save(r.prefs);
+    say(clip(r.text, cols() - 4), r.tone);
+    if (chk.note) say(clip(chk.note, cols() - 4), 'warn');
+    return undefined;
+  }
+
+  /**
+   * Handles the favourites / default / chooser forms of /model.
+   * -> undefined when `sub` (parseModelSub) is not one of them (the caller carries on), else a
+   * promise.
+   */
+  function handle(sub) {
+    const prefs = mp.current.prefs;
+    switch (sub.kind) {
+      case 'error':
+        return Promise.resolve(say(sub.text, 'warn'));
+      case 'fav-list':
+        for (const [t, tone] of favLines(prefs, current())) say(clip(t, cols() - 4), tone);
+        return Promise.resolve();
+      case 'use': {
+        const f = prefs.favourites[sub.n - 1];
+        if (f) return command(`/model ${f.provider} ${f.model}`);
+        return Promise.resolve(say(`No favourite ${sub.n}. /model fav lists them.`, 'warn'));
+      }
+      case 'default-show':
+        return Promise.resolve(
+          say(
+            prefs.default
+              ? `Default model: ${label(prefs.default)}. New sessions start on it when its ` +
+                  'provider is connected. /model default clear removes it.'
+              : 'No default model. /model default <provider> <model> sets one ' +
+                  '(or press d in the /model chooser).',
+          ),
+        );
+      case 'default-clear': {
+        const c = clearDefault(prefs);
+        return save(c.prefs).then(() => say(c.text, c.tone));
+      }
+      case 'fav-rm': {
+        const r = rmFav(prefs, sub.ref);
+        return (r.removed ? save(r.prefs) : Promise.resolve()).then(() => say(r.text, r.tone));
+      }
+      case 'fav-add':
+      case 'default-set':
+        return addOrDefault(sub);
+      case 'chooser':
+        return openChooser();
+      default:
+        return undefined;
+    }
+  }
+
+  /** The /model chooser: favourites first, then each CONNECTED provider's live models. */
+  async function openChooser() {
+    if (!api.connections) return say('Model choice is not available in this mode.', 'warn');
+    const [res, caps] = await Promise.all([
+      api.connections(),
+      api.capabilities ? api.capabilities() : null,
+    ]);
+    const conn = connectedChoices(res, caps);
+    if (!conn.length) {
+      return say(
+        res?.ok === false
+          ? `Could not read what is connected: ${res.error || 'no answer'}`
+          : 'No AI provider is connected yet. /connect openai, /connect anthropic or ' +
+              '/connect ollama <url>.',
+        'warn',
+      );
+    }
+    const groups = await Promise.all(
+      conn.map(async (c) => {
+        const l = await liveModels(api, c.id);
+        const note = l.ok ? null : 'could not list its models; Enter uses the server default';
+        return { id: c.id, name: c.name, ids: l.ids.slice(0, 200), note };
+      }),
+    );
+    const items = () => chooserItems(mp.current.prefs, groups);
+    const hidden = () =>
+      mp.current.prefs.favourites.filter((f) => !groups.some((g) => g.id === f.provider)).length;
+    const title = () => {
+      const now = modelLabel(state.current.ctx, mc.current) || 'auto';
+      const def = mp.current.prefs.default ? label(mp.current.prefs.default) : 'none';
+      const h = hidden();
+      const note = h ? ` · ${h} favourite${h === 1 ? '' : 's'} hidden, provider not connected` : '';
+      return `Model · current ${now} · default ${def}${note}`;
+    };
+    picker.open({
+      titleFn: title,
+      rowsFn: () => items().map((it) => chooserRow(it, mp.current.prefs, current())),
+      hint: '↑↓ select · Enter use · f favourite · d default · Esc close',
+      onChar: (ch, sel) => {
+        if (ch !== 'f' && ch !== 'd') return undefined;
+        const it = items()[sel];
+        if (!it || !it.model) {
+          say('That row has no model to save. Pick a model row.', 'warn');
+          return true;
+        }
+        const m = { provider: it.provider, model: it.model };
+        if (ch === 'f') {
+          const t = toggleFav(mp.current.prefs, m);
+          save(t.prefs);
+          say(`${t.added ? 'Added to' : 'Removed from'} favourites: ${label(m)}.`, 'ok');
+        } else {
+          save(setDefault(mp.current.prefs, m.provider, m.model).prefs);
+          say(`Default model: ${label(m)}. New sessions start on it.`, 'ok');
+        }
+        const next = items();
+        const same = (x) =>
+          x.kind === it.kind && x.provider === it.provider && x.model === it.model;
+        const j = next.findIndex(same);
+        return j >= 0 ? j : Math.min(sel, Math.max(0, next.length - 1));
+      },
+      onPick: (_, i) => {
+        const it = items()[i];
+        if (it) command(it.model ? `/model ${it.provider} ${it.model}` : `/model ${it.provider}`);
+      },
+    });
+    return undefined;
+  }
+
+  /**
+   * New sessions start on the saved default model when its provider is connected. A --provider
+   * flag, or a /model typed first, wins. A default on a provider that is not connected is said
+   * once and nothing changes. -> a cancel function.
+   */
+  function startOnDefault({ flagged, off, dispatchCtx }) {
+    if (!api.modelPrefs || off) return () => {};
+    let dead = false;
+    (async () => {
+      let got = null;
+      try {
+        got = await api.modelPrefs();
+      } catch {
+        got = null;
+      }
+      if (dead || !got) return;
+      mp.current.prefs = normPrefs(got.prefs);
+      bump();
+      const def = mp.current.prefs.default;
+      if (!def || flagged || mp.current.touched) return;
+      let res = null;
+      let caps = null;
+      try {
+        [res, caps] = await Promise.all([
+          api.connections?.(),
+          api.capabilities ? api.capabilities() : null,
+        ]);
+      } catch {
+        return; // cannot tell what is connected: stay quiet, the model is unchanged
+      }
+      if (dead || mp.current.touched || !res || res.ok === false) return;
+      const row = byId(def.provider);
+      if (!row) return;
+      if (!connectedChoices(res, caps).some((c) => c.id === row.id)) {
+        if (!mp.current.warned) {
+          mp.current.warned = true;
+          say(
+            `Your default model ${label(def)} is on ${row.name}, which is not connected, so ` +
+              `the model is unchanged. /connect ${row.connect} to use it, or ` +
+              '/model default clear.',
+            'warn',
+          );
+        }
+        return;
+      }
+      let host = null;
+      if (row.dynamic) {
+        try {
+          const lst =
+            row.id === 'ollama' ? await api.ollamaModels?.() : await api.compatModels?.(row.id);
+          host = lst?.host || null;
+        } catch {
+          host = null;
+        }
+      }
+      if (dead || mp.current.touched) return;
+      const via = row.via ? { via: row.via } : {};
+      const at = host && !row.hosted ? { host } : {};
+      mc.current = normChoice({ provider: row.provider, model: def.model, ...via, ...at });
+      dispatchCtx();
+      bump();
+    })();
+    return () => {
+      dead = true;
+    };
+  }
+
+  return { handle, openChooser, startOnDefault, save };
+}

package/lib/quoxon/slash/palette.js

@@ -0,0 +1,118 @@
+/**
+ * L0 command palette: the pure model behind the list that opens under the composer when a draft
+ * starts with `/`. Built from the one REGISTRY (commands.js), so the palette, /help and dispatch can
+ * never disagree. Only commands that can work here are bright; anything this session cannot run is
+ * dim with the reason. Planned commands stay hidden unless typed exactly.
+ */
+import { REGISTRY, entryVisible } from '../commands.js';
+
+export const PALETTE_MAX = 8;
+
+/** The draft as a palette query: '/co' -> 'co'; null when the draft is not a bare command word. */
+export function paletteQuery(draft) {
+  const t = String(draft ?? '');
+  if (!t.startsWith('/') || t.startsWith('//')) return null;
+  if (/[\s]/.test(t)) return null; // args typed (or several lines): the palette steps aside
+  return t.slice(1).toLowerCase();
+}
+
+/**
+ * Why a command cannot run in this session, or null. `api` is the session's server wrapper (a method
+ * missing means this mode has no route for it); `caps` is GET /api/v1/capabilities when the server has
+ * it ({ id: { available, reason } }), else null; `blocked` is the not-signed-in message.
+ */
+export function unavailableReason(entry, { api = {}, caps = null, blocked = null } = {}) {
+  const cap = caps ? caps[entry.cap || entry.id] : null;
+  if (cap && cap.available === false) return cap.reason || 'not available on this server';
+  for (const m of entry.needs || []) if (typeof api[m] !== 'function') return 'not available in this mode';
+  if (blocked && entry.server) return '(sign in)';
+  return null;
+}
+
+/**
+ * GET /api/v1/capabilities as api.capabilities() returns it ({ ok, capabilities:[{ id, availability, reason, setup }] })
+ * -> { id: { available, reason } }, or null when the server has no contract. Only `installed` runs.
+ */
+export function capabilityMap(res) {
+  if (!res || res.ok !== true || !Array.isArray(res.capabilities)) return null;
+  const label = { requires_setup: 'needs setup', unavailable: 'unavailable on this server', planned: 'planned, not built yet' };
+  return Object.fromEntries(res.capabilities.filter(c => c && c.id).map(c => {
+    const available = c.availability === 'installed';
+    return [c.id, { available, reason: available ? null : (c.reason || label[c.availability] || 'not available on this server'), setup: c.setup || null }];
+  }));
+}
+
+/** All palette rows for this session, registry order. */
+export function paletteItems(ctx = {}, registry = REGISTRY) {
+  return registry.filter(e => e.kind === 'command' && entryVisible(e)).map(e => ({
+    id: e.id,
+    name: '/' + e.id,
+    usage: e.usage,
+    desc: e.short || e.desc, // the palette row is short (commandShort.js); the long wording is searched and shown by /help
+    longDesc: e.desc,
+    aliases: (e.aliases || []).map(a => '/' + a),
+    planned: e.status === 'planned',
+    disabled: e.status === 'planned' ? 'planned, not built yet' : unavailableReason(e, ctx)
+  }));
+}
+
+/** Subsequence score of q in s (lower is better), or null when q is not a subsequence. */
+export function fuzzy(q, s) {
+  q = String(q).toLowerCase(); s = String(s).toLowerCase();
+  if (!q) return 0;
+  if (s.startsWith(q)) return 0;
+  const at = s.indexOf(q);
+  if (at >= 0) return 10 + at;
+  let i = 0, gaps = 0, last = -1;
+  for (let j = 0; j < s.length && i < q.length; j++) {
+    if (s[j] === q[i]) { if (last >= 0) gaps += j - last - 1; last = j; i++; }
+  }
+  return i === q.length ? 100 + gaps : null;
+}
+
+/** Filter + rank. Planned rows appear only on an exact name or alias match. */
+export function filterPalette(items, query) {
+  const q = String(query ?? '').toLowerCase();
+  const exact = (it) => it.id === q || it.aliases.includes('/' + q);
+  const wordStart = (text) => q.length >= 2 && new RegExp('(^|[^a-z0-9])' + q.replace(/[^a-z0-9]/g, '\\$&')).test(String(text).toLowerCase());
+  const scored = [];
+  items.forEach((it, idx) => {
+    if (it.planned && !exact(it)) return;
+    // Rank: exact, prefix of the name, prefix of an alias, inside a name, a word in the description at a word start,
+    // then fuzzy subsequence, then any other mention in the description.
+    let best = null;
+    const long = it.longDesc || it.desc;
+    const nameSc = fuzzy(q, it.id);
+    if (nameSc === 0) best = 0;
+    else if (it.aliases.some(a => a.slice(1).toLowerCase().startsWith(q))) best = 1;
+    else if (nameSc != null && nameSc < 100) best = nameSc; // a substring of the name (10 + position)
+    else {
+      for (const a of it.aliases) { const sc = fuzzy(q, a.slice(1)); if (sc != null && sc < 100 && (best == null || sc < best)) best = sc; }
+      if (best == null && wordStart(long)) best = 60;
+      if (best == null) { // fuzzy subsequence of the name or an alias
+        for (const n of [it.id, ...it.aliases.map(a => a.slice(1))]) { const sc = fuzzy(q, n); if (sc != null && (best == null || sc < best)) best = sc; }
+      }
+      if (best == null && q.length >= 3 && long.toLowerCase().includes(q)) best = 500;
+    }
+    if (best == null) return;
+    if (exact(it)) best = -1;
+    if (it.disabled) best += 0.5; // a working command outranks an unavailable one on a tie
+    scored.push({ it, best, idx });
+  });
+  return scored.sort((a, b) => a.best - b.best || a.idx - b.idx).map(x => x.it);
+}
+
+/** What Tab puts in the draft: the name, plus a space when the command takes arguments. */
+export function completion(item) {
+  const takesArgs = /^\S+\s+\S/.test(String(item.usage).trim());
+  return item.name + (takesArgs ? ' ' : '');
+}
+
+/** View rows for the palette: a window of PALETTE_MAX around the selection. */
+export function paletteView(rows, sel, max = PALETTE_MAX) {
+  if (!rows.length) return { rows: [], sel: 0, more: 0, empty: true };
+  const s = Math.max(0, Math.min(sel, rows.length - 1));
+  const start = Math.max(0, Math.min(s - max + 1, rows.length - max));
+  const win = rows.slice(Math.max(0, start), Math.max(0, start) + max);
+  return { rows: win, sel: s - Math.max(0, start), more: rows.length - win.length, empty: false };
+}