quoxcli 0.2.0 → 0.3.1

package/lib/quoxon/mind.js

@@ -0,0 +1,103 @@
+/**
+ * /mind: QuoxMind cognitive implants, read from the collector (same data as `quox mind`).
+ * Pure: takes api.mind() output, returns [[text, tone]]. Implants with nothing recorded
+ * say "no activity recorded"; nothing is invented. Lines are not clipped: notes wrap to the
+ * terminal width, so a long description reads in full (owner drive 2026-10-15).
+ */
+
+const MARK = { healthy: '✔', degraded: '⚠', weak: '⚠', collecting: '◐', 'not-reported': '·', unreachable: '✖', 'license-required': '⛔' };
+
+/** The 14 implant short ids (the collector's registry, in order). Used for help and for "did you mean". */
+export const MIND_IMPLANTS = ['sense', 'repobrain', 'memory', 'temporal', 'focus', 'value', 'guard', 'qortex', 'insight', 'executive', 'predict', 'reflect', 'dream', 'learn'];
+const SHORT_OF = { 'quox-nucleus': 'repobrain', 'quox-brain2': 'qortex' };
+const shortOf = (id) => SHORT_OF[id] || String(id).replace(/^quox-/, '');
+
+export const MIND_HELP_ARGS = new Set(['help', '-h', '--help', '?']);
+
+/** /mind help: the forms and the implant ids. No server call. */
+export function mindHelpLines() {
+  return [
+    ['/mind lists every QuoxMind implant with its status and last activity. Read-only, no model call.'],
+    ['/mind <implant> shows one implant in full: what it does, how it grows, its metrics.'],
+    [`Implants: ${MIND_IMPLANTS.join(', ')}.`],
+  ];
+}
+
+/**
+ * A failed /mind call as plain lines. A 404 "unknown implant" names the implant that does not exist,
+ * lists the real ones, and points at a TUI command of the same name when there is one (/mind doctor -> /doctor).
+ * Any other failure reports the server's own reason, not just "Request failed with status N".
+ */
+export function mindErrorLines(e, arg, { isCommand = () => false } = {}) {
+  const body = e?.body && typeof e.body === 'object' ? e.body : {};
+  const reason = body.error || body.message || (typeof e?.code === 'string' && !/^E[A-Z]/.test(e.code) ? e.code : '') || e?.message || 'failed';
+  if (arg && (e?.status === 404 || /unknown implant/i.test(reason))) {
+    const ids = Array.isArray(body.valid) && body.valid.length ? body.valid.map(shortOf) : MIND_IMPLANTS;
+    const out = [[`No implant called "${arg}". /mind <implant> shows one implant's status (read-only).`, 'warn'],
+      [`Implants: ${ids.join(', ')}.`]];
+    const cmd = String(arg).split(/\s+/)[0].toLowerCase();
+    if (isCommand(cmd)) out.push([`For the ${cmd} command, use /${cmd}.`]);
+    else out.push(['/mind on its own lists them all.']);
+    return out;
+  }
+  return [[`mind: ${e?.status ? `HTTP ${e.status}: ` : ''}${reason}`, 'error']];
+}
+
+/** Relative "fired" time for an ISO timestamp; 'never' when null. `now` is injectable for tests. */
+export function fmtFired(iso, now = Date.now()) {
+  if (!iso) return 'never';
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return String(iso);
+  const s = Math.max(0, Math.round((now - t) / 1000));
+  if (s < 60) return 'just now';
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  return `${Math.floor(s / 86400)}d ago`;
+}
+
+/**
+ * The firing evidence for one implant (QUOXMIND-PROOF): last fired + 7-day count from the server.
+ * Returns null when the server predates the evidence fields, so the old line is kept.
+ */
+function firingText(i, now) {
+  if (!('fired_7d' in i)) return null;
+  if (i.activity_error) return `firing unknown: ${i.activity_error}`;
+  if (typeof i.fired_7d !== 'number') return 'firing not tracked';
+  const idle = typeof i.idle_runs_7d === 'number' && i.idle_runs_7d > 0 ? ` (${i.idle_runs_7d} idle runs)` : '';
+  return `${i.last_fired ? `fired ${fmtFired(i.last_fired, now)}` : 'never fired'} · 7d ${i.fired_7d}${idle}`;
+}
+
+export function mindLines(d, { now = Date.now() } = {}) {
+  const out = [];
+  const add = (t, tone) => out.push([t, tone]);
+  if (d.implant) {
+    const i = d.implant;
+    add(`${MARK[i.status] || '·'} ${i.name} (${i.short}) · ${i.status}${i.tier ? ` · ${i.tier}` : ''}`);
+    add(`  ${i.description || i.purpose}`);
+    if (i.inspired_by) add(`  inspired by: ${i.inspired_by}`);
+    if (i.summary) add(`  now: ${i.summary}`);
+    add(`  ${i.activity}`);
+    const fired = firingText(i, now);
+    if (fired && typeof i.fired_7d === 'number') add(`  fired: ${fmtFired(i.last_fired, now)}${i.last_fired ? ` (${i.last_fired})` : ''} · 7d ${i.fired_7d}${i.activity_source ? ` · from ${i.activity_source}` : ''}`);
+    else if (fired) add(`  ${fired}`);
+    if (i.how_to_grow) add(`  how it grows: ${i.how_to_grow}`);
+    if (Array.isArray(i.connected_to) && i.connected_to.length) add(`  connected to: ${i.connected_to.map(shortOf).join(', ')}`);
+    for (const [k, v] of Object.entries(i.metrics || {})) if (v !== null && typeof v !== 'object') add(`  ${k}: ${typeof v === 'number' && !Number.isInteger(v) ? Math.round(v * 100) / 100 : v}`);
+    const others = MIND_IMPLANTS.filter(s => s !== i.short);
+    add(`This is ${i.name}'s status, read-only: nothing runs. /mind for all; others: ${others.map(s => `/mind ${s}`).join(', ')}.`, 'dim');
+    return out;
+  }
+  const list = d.implants || [];
+  add(`QuoxMind: ${list.length} cognitive implants`);
+  for (const i of list) {
+    const fired = firingText(i, now);
+    const tail = fired !== null
+      ? `${fired}${typeof i.fired_7d === 'number' && !i.activity_error && i.summary && i.activity !== 'no activity recorded' ? ` · ${i.summary}` : ''}`
+      : (i.activity === 'no activity recorded' ? 'no activity recorded' : i.summary || i.activity);
+    add(`${MARK[i.status] || '·'} ${i.short.padEnd(10)} ${i.status.padEnd(13)} ${tail}`, i.status === 'unreachable' ? 'warn' : undefined);
+  }
+  const h = d.health;
+  if (h && typeof h.fired_7d_total === 'number') add(`${h.fired_7d_implants} of ${list.length} fired in the last 7 days (${h.fired_7d_total} firings), ${h.silent_7d} silent, ${h.activity_unknown} not tracked. /mind <id> for one.`);
+  else if (h) add(`${h.with_activity} with activity, ${h.no_activity} with none recorded${h.average_health !== null ? `, average health ${h.average_health}` : ''}. /mind <id> for one.`);
+  return out;
+}

package/lib/quoxon/mode.js

@@ -0,0 +1,46 @@
+/**
+ * /mode (owner 2026-10-16 "/say quoxon a but log b"): this window's mode.
+ *   ask   (default) Quox asks you before it acts; what needs approval is your org's policy.
+ *   plan  Quox investigates (read tools) and proposes the steps and exact commands; it runs nothing that
+ *         changes state. The SERVER enforces it: the turn carries mode 'plan' (lib/planMode.js in the collector).
+ *   auto  not built. Logged as a plan: it needs standing grants first.
+ * Window-scoped: carried across /restart (QUOX_RESTART_MODE), never written to the shared profile.
+ */
+
+export const MODES = ['ask', 'plan'];
+export const AUTO_NOT_YET = 'not available yet: auto mode needs standing grants (planned).';
+export const PLAN_GO = 'go ahead with the plan';
+
+/** -> 'plan' | 'ask' (anything else, including 'auto', is 'ask'). */
+export function normMode(v) {
+  return String(v || '').trim().toLowerCase() === 'plan' ? 'plan' : 'ask';
+}
+
+const DESC = {
+  ask: 'ask first: Quox asks you before it acts. What needs your approval is your org\'s policy on the server (/approvals lists what is waiting).',
+  plan: 'plan only: Quox investigates with read tools and proposes the steps and the exact commands. It runs nothing that changes state; the server enforces it.',
+};
+
+/** One line per mode for the arrow-key chooser (the same one /model uses). Auto is not offered: it is not built. */
+export const MODE_ROWS = [
+  { id: 'ask', text: 'ask first: Quox asks before it acts' },
+  { id: 'plan', text: 'plan only: Quox proposes the steps and runs nothing that changes state' },
+];
+
+/**
+ * Pure: the reply to `/mode [arg]` given the current mode.
+ * -> { text, tone, mode? } where mode is set only when it changes.
+ */
+export function modeReply(arg, current) {
+  const cur = normMode(current);
+  const a = String(arg || '').trim().toLowerCase();
+  if (!a || /^(-h|--help|help|\?)$/.test(a)) {
+    return { tone: null, text: `mode ${DESC[cur]}\nOptions: /mode ask (the default), /mode plan (plan only). Auto mode is ${AUTO_NOT_YET}` };
+  }
+  if (a === 'auto') return { tone: 'warn', text: `/mode auto is ${AUTO_NOT_YET} Options: /mode ask, /mode plan.` };
+  if (!MODES.includes(a)) return { tone: 'warn', text: `Unknown mode '${clipWord(a)}'. Options: /mode ask, /mode plan.` };
+  if (a === cur) return { tone: 'dim', text: `Already in mode ${DESC[cur]}` };
+  return { mode: a, tone: 'ok', text: a === 'plan' ? `mode ${DESC.plan} /mode ask to go back.` : `mode ${DESC.ask}` };
+}
+
+function clipWord(w) { return w.length > 20 ? `${w.slice(0, 19)}…` : w; }

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'}`;