quoxcli 0.2.0 → 0.4.0

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

@@ -13,7 +13,8 @@ export function readUsage(u) {
   const cacheRead = num(o.cache_read_input_tokens);
   const cacheWrite = num(o.cache_creation_input_tokens);
   const cost = num(o.cost_usd);
-  return { input, output, cacheRead, cacheWrite, cost, reported: input != null || output != null };
+  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() {
@@ -23,9 +24,10 @@ export function createLedger() {
   const finalize = (usage, convId) => {
     if (!turn) return;
     const t = turn; turn = null;
-    const u = readUsage(usage ?? t.doneUsage);
+    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 };
+    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++;
@@ -33,14 +35,15 @@ export function createLedger() {
       const id = convId || t.conversationId;
       if (id) convs.set(id, (convs.get(id) || 0) + (u.input || 0) + (u.output || 0));
     }
-    if (u.cost != null) { r.cost += u.cost; r.costTurns++; }
+    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);
+      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). */
@@ -48,7 +51,7 @@ export function createLedger() {
     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 };
+      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;
     }
@@ -65,7 +68,8 @@ function line(r) {
     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`);
-  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.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(' · ');
 }
 
@@ -77,7 +81,8 @@ export function costModel(ledger) {
   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.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.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

@@ -10,7 +10,9 @@ 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 }) {
-  const keyW = Math.min(22, Math.max(8, ...rows.map(r => [...String(r.key || '')].length)) + 1);
+  // 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,

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

@@ -4,7 +4,7 @@
  * 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 } from '../commands.js';
+import { REGISTRY, entryVisible } from '../commands.js';
 
 export const PALETTE_MAX = 8;
 
@@ -25,7 +25,7 @@ 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 'not signed in';
+  if (blocked && entry.server) return '(sign in)';
   return null;
 }
 
@@ -44,11 +44,12 @@ export function capabilityMap(res) {
 
 /** All palette rows for this session, registry order. */
 export function paletteItems(ctx = {}, registry = REGISTRY) {
-  return registry.filter(e => e.kind === 'command').map(e => ({
+  return registry.filter(e => e.kind === 'command' && entryVisible(e)).map(e => ({
     id: e.id,
     name: '/' + e.id,
     usage: e.usage,
-    desc: e.desc,
+    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)
@@ -73,16 +74,29 @@ export function fuzzy(q, s) {
 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;
-    const names = [it.id, ...it.aliases.map(a => a.slice(1))];
+    // 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;
-    for (const n of names) { const sc = fuzzy(q, n); if (sc != null && (best == null || sc < best)) best = sc; }
-    if (best == null && q.length >= 3 && it.desc.toLowerCase().includes(q)) best = 500; // words in the description
+    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
+    if (it.disabled) best += best >= 10 ? 1000 : 0.5; // a non-prefix match on an unavailable command ranks below every working match; a prefix keeps its place 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);

package/lib/quoxon/slash/paletteController.js

@@ -4,27 +4,121 @@
  * which narrows the list because the draft IS the filter.
  */
 import { findEntry } from '../commands.js';
+import { signedOutNotice } from '../sessionDead.js';
 import { paletteQuery, paletteItems, filterPalette, completion, paletteView, PALETTE_MAX } from './palette.js';
+import { argContext, levelFor, staticItems, rankArgs, applyArg } from './args.js';
+import { mentionContext, rankMentions, applyMention } from '../mentions.js';
 
-export function createPalette({ getDraft, setDraft, run, say, ctx = () => ({}) }) {
-  const st = { sel: 0, q: null, dismissed: null };
+const ARG_TTL = 30000;      // a fetched list is reused this long
+const ARG_FAIL_TTL = 8000;  // a failed fetch is quiet (no rows) and retried after this
+
+const startsLike = (q, it) => {
+  const w = String(q || '').toLowerCase().replace(/^\//, '');
+  return [it.name, ...(it.aliases || [])].some(n => String(n).toLowerCase().replace(/^\//, '').startsWith(w));
+};
+
+export function createPalette({
+  getDraft, setDraft, run, say, ctx = () => ({}), source = null, refresh = () => {}, now = Date.now,
+  mentions = null // MENTIONS: { cache (mentions.js createMentionCache), local: () => receipt items }
+}) {
+  const st = { sel: 0, q: null, dismissed: null, picked: false, aq: null, mq: null };
+  const cache = new Map(); // 'src:param' -> { at, ttl, items, pending }
+  /** Cached items for an async source; fetches when missing or stale. Never throws or blocks. */
+  const fetchItems = (src, param) => {
+    if (!source) return [];
+    const key = `${src}:${param ?? ''}`;
+    const hit = cache.get(key);
+    if (hit && (hit.pending || now() - hit.at < hit.ttl)) return hit.items;
+    const ent = { at: now(), ttl: ARG_TTL, items: hit?.items ?? [], pending: true };
+    cache.set(key, ent);
+    Promise.resolve().then(() => source(src, param)).then(
+      (items) => {
+        ent.items = Array.isArray(items) ? items : [];
+        ent.at = now(); ent.pending = false;
+      },
+      () => { ent.items = []; ent.ttl = ARG_FAIL_TTL; ent.at = now(); ent.pending = false; }
+    ).then(() => refresh());
+    return ent.items;
+  };
+  /** The argument suggestions for the current draft, or null when it is not at an argument. */
+  const argState = () => {
+    const d = getDraft();
+    const cx = argContext(d);
+    if (!cx) return null;
+    const lv = levelFor(cx.entry, cx.words);
+    if (!lv) return null;
+    const param = lv.of === 'partial' ? cx.partial.slice(0, cx.partial.lastIndexOf('/') + 1) : lv.of != null ? cx.words[lv.of] : undefined; // 'partial': the directory typed so far (QUOXON-MESH /send paths)
+    const items = [...staticItems(lv), ...(lv.src ? fetchItems(lv.src, param) : [])];
+    const rows = rankArgs(items, cx.partial);
+    const key = d.slice(0, cx.start) + '\u0000' + cx.partial;
+    if (key !== st.aq) { st.aq = key; st.sel = 0; st.picked = false; }
+    return { cx, rows };
+  };
+  const argOpen = () => {
+    const d = getDraft();
+    if (st.dismissed !== null && st.dismissed !== d) st.dismissed = null;
+    if (st.dismissed === d) return null;
+    const a = argState();
+    return a && a.rows.length ? a : null;
+  };
+  /** MENTIONS: the @word at the end of the draft and its ranked rows from the session cache, or null. */
+  const mentionOpen = () => {
+    if (!mentions) return null;
+    const d = getDraft();
+    const cx = mentionContext(d);
+    if (!cx) return null;
+    if (st.dismissed !== null && st.dismissed !== d) st.dismissed = null;
+    if (st.dismissed === d) return null;
+    const rows = rankMentions([...mentions.cache.items(), ...(mentions.local?.() || [])], cx.partial);
+    const key = d.slice(0, cx.start) + '\u0000' + cx.partial;
+    if (key !== st.mq) { st.mq = key; st.sel = 0; st.picked = false; }
+    return rows.length ? { cx, rows } : null;
+  };
   const rows = () => {
     const q = paletteQuery(getDraft());
-    if (q !== st.q) { st.q = q; st.sel = 0; }
+    if (q !== st.q) { st.q = q; st.sel = 0; st.picked = false; }
     return q === null ? [] : filterPalette(paletteItems(ctx()), q);
   };
   const isOpen = () => {
     const d = getDraft();
     if (st.dismissed !== null && st.dismissed !== d) st.dismissed = null;
-    return paletteQuery(d) !== null && st.dismissed !== d;
+    if (paletteQuery(d) === null) return argOpen() !== null || mentionOpen() !== null;
+    return st.dismissed !== d;
   };
+  /** MENTIONS keys: Up/Down choose, Tab or Enter accept, Esc closes. */
+  function onMentionKey(name, m) {
+    const n = m.rows.length;
+    switch (name) {
+      case 'up': st.sel = (st.sel - 1 + n) % n; st.picked = true; return true;
+      case 'down': st.sel = (st.sel + 1) % n; st.picked = true; return true;
+      case 'escape': st.dismissed = getDraft(); return true;
+      case 'tab': case 'enter': setDraft(applyMention(getDraft(), m.cx, m.rows[Math.min(st.sel, n - 1)].value)); return true;
+      default: return false;
+    }
+  }
   /** -> true when the key was the palette's. */
+  function onArgKey(name, a) {
+    const n = a.rows.length;
+    switch (name) {
+      case 'up': st.sel = (st.sel - 1 + n) % n; st.picked = true; return true;
+      case 'down': st.sel = (st.sel + 1) % n; st.picked = true; return true;
+      case 'escape': st.dismissed = getDraft(); return true;
+      case 'tab': case 'enter': {
+        if (name === 'enter' && !st.picked) return false; // Enter sends what was typed
+        const it = a.rows[Math.min(st.sel, n - 1)];
+        setDraft(applyArg(getDraft(), a.cx, it.value));
+        return true;
+      }
+      default: return false;
+    }
+  }
   function onKey(name) {
     if (!isOpen()) return false;
+    if (paletteQuery(getDraft()) === null) { const a = argOpen(); return a ? onArgKey(name, a) : onMentionKey(name, mentionOpen()); }
     const list = rows();
     switch (name) {
-      case 'up': if (!list.length) return false; st.sel = (st.sel - 1 + list.length) % list.length; return true;
-      case 'down': if (!list.length) return false; st.sel = (st.sel + 1) % list.length; return true;
+      case 'up': if (!list.length) return false; st.sel = (st.sel - 1 + list.length) % list.length; st.picked = true; return true;
+      case 'down': if (!list.length) return false; st.sel = (st.sel + 1) % list.length; st.picked = true; return true;
       case 'escape': st.dismissed = getDraft(); return true;
       case 'tab': {
         const it = list[st.sel];
@@ -37,7 +131,10 @@ export function createPalette({ getDraft, setDraft, run, say, ctx = () => ({}) }
         if (typed && typed.kind === 'command') return false; // an exact command runs as typed (planned ones say so)
         const it = list[st.sel];
         if (!it) return false; // nothing matches: the normal path says "Unknown command"
-        if (it.disabled) { say(`${it.name} is ${it.disabled}.`, 'warn'); return true; }
+        // A loose (subsequence) match only runs when the user chose it with the arrows. Typing an unknown
+        // word and pressing Enter must not run some other command (z2h: "/hat" ran /approvals).
+        if (!st.picked && !startsLike(st.q, it)) return false;
+        if (it.disabled) { say(signedOutNotice(it.name, it.disabled), 'warn'); return true; }
         setDraft('');
         run(it.name);
         return true;
@@ -46,6 +143,19 @@ export function createPalette({ getDraft, setDraft, run, say, ctx = () => ({}) }
     }
   }
   function view() {
+    if (paletteQuery(getDraft()) === null) {
+      const a = argOpen();
+      if (!a) {
+        const mo = mentionOpen();
+        if (!mo) return { rows: [], sel: 0, more: 0, empty: null, hint: null };
+        const mv = paletteView(mo.rows, st.sel, PALETTE_MAX);
+        return { rows: mv.rows.map(it => ({ key: `@${it.value}`, text: `${it.kind}${it.label ? ` · ${it.label}` : ''}` })), sel: mv.sel, more: mv.more, empty: null, hint: '↑↓ select · Tab or Enter accept · Esc close' };
+      }
+      const v = paletteView(a.rows, st.sel, PALETTE_MAX);
+      const rows = v.rows.map(it => ({ key: it.value, text: it.desc || '' }));
+      const hint = '↑↓ select · Tab complete · Esc close';
+      return { rows, sel: v.sel, more: v.more, empty: null, hint };
+    }
     const list = rows();
     const v = paletteView(list, st.sel, PALETTE_MAX);
     return {

package/lib/quoxon/slash/panels.js

@@ -3,6 +3,8 @@
  * Every value comes from the caller's real data; anything not known is said plainly, never filled in.
  */
 import { capabilityMap } from './palette.js';
+import { CHOICES } from '../model.js';
+import { providerState, capabilityName } from '../providers.js';
 
 const n = (v) => Number(v || 0).toLocaleString('en-US');
 const row = (key, text) => ({ kind: 'row', key, text: String(text) });
@@ -53,6 +55,11 @@ export function contextModel(d = {}) {
   const mem = d.memory;
   out.push(row('Memory', !mem ? '? not checked (/context checks it live)' : mem.ok ? 'connected (persistent memory answers)' : `not reachable: ${mem.error}`));
   out.push(row('Agent', d.agent || 'CommanderQ (quox)'));
+  if (d.screen) {
+    const l = d.screen.last;
+    out.push(row('Terminal', !d.screen.on ? 'off for this session (/context on)' : l ? `${l.bytes} bytes sent last turn: ${l.sections.join(', ') || 'nothing new'}${l.unchanged?.length ? ` (unchanged: ${l.unchanged.join(', ')})` : ''} · /context off stops it` : 'on, sent with your next message · /context off stops it'));
+    if (d.screen.on && l?.text) for (const t of l.text.split('\n')) out.push({ kind: 'dim', key: '', text: '  ' + t });
+  }
   return out;
 }
 
@@ -83,10 +90,12 @@ export async function chatChecks(api, providerTypes = ['openai', 'anthropic', 'o
     }),
     one('AI provider', async () => {
       if (!api.connections) return { status: 'skip', detail: 'not available in this mode' };
-      const r = await api.connections();
-      if (!r.ok) return { status: 'fail', detail: `could not read the vault: ${r.error}` };
-      const have = providerTypes.filter(t => r.rows.some(x => x.integration_type === t));
-      return have.length ? { status: 'pass', detail: `connected: ${have.join(', ')}` } : { status: 'warn', detail: 'no AI provider in your org vault; /connect openai' };
+      // The same provider status as /model and /connect (providers.js): the server's capabilities first.
+      const [r, caps] = await Promise.all([api.connections(), api.capabilities ? api.capabilities() : null]);
+      const ready = CHOICES.filter(c => providerState({ cap: c.cap || c.id, vault: c.vault }, caps, r).state === 'connected').map(c => c.name);
+      if (ready.length) return { status: 'pass', detail: `ready: ${ready.join(', ')}` };
+      if (!r.ok && !caps?.ok) return { status: 'fail', detail: `could not read the vault: ${r.error}` };
+      return { status: 'warn', detail: 'no AI provider is ready; /connect openai' };
     }),
     one('Capabilities', async () => {
       if (!api.capabilities) return { status: 'skip', detail: 'not available in this mode' };
@@ -94,8 +103,14 @@ export async function chatChecks(api, providerTypes = ['openai', 'anthropic', 'o
       if (res && res.ok === false) return res.missing ? { status: 'warn', detail: 'this server has no capability contract yet (GET /api/v1/capabilities)' } : { status: 'fail', detail: res.error || 'failed' };
       const m = capabilityMap(res);
       if (!m) return { status: 'warn', detail: 'unexpected capability response' };
-      const off = Object.entries(m).filter(([, v]) => v && v.available === false).map(([k]) => k);
-      return { status: off.length ? 'warn' : 'pass', detail: `${Object.keys(m).length} known${off.length ? `, unavailable: ${off.slice(0, 6).join(', ')}` : ', all available'}` };
+      const names = (a) => res.capabilities.filter(c => c?.availability === a).map(capabilityName);
+      const off = names('unavailable'), setup = names('requires_setup');
+      const more = (l) => `${l.slice(0, 4).join(', ')}${l.length > 4 ? ` +${l.length - 4} more` : ''}`;
+      const parts = [`${Object.keys(m).length} known`];
+      if (off.length) parts.push(`unavailable here: ${more(off)}`);
+      if (setup.length) parts.push(`needs setup: ${more(setup)}`);
+      if (!off.length && !setup.length) parts.push('all available');
+      return { status: off.length ? 'warn' : 'pass', detail: parts.join(', ') };
     })
   ]);
 }