quoxcli 0.2.0 → 0.3.1

package/lib/quoxon/handoffOffer.js

@@ -0,0 +1,78 @@
+/**
+ * QUOXON handoff offer (owner, live 2026-10-17 19:51). Attached to TRIAGE-Q, the owner asked which VMs use the most CPU
+ * and memory; TRIAGE-Q had no fleet tools and told him to detach and ask CommanderQ. Offer, don't instruct: the server
+ * sends turn.handoff_suggested (from the turn's tool selection, never the answer text) and the TUI asks once:
+ *
+ *   ⚠ TRIAGE-Q asks: Hand this question to CommanderQ?
+ *     do     ask CommanderQ "which VMs use the most CPU and memory" once; you stay attached to TRIAGE-Q
+ *     why    TRIAGE-Q can't read VM stats.
+ *   ▶ Hand this question to CommanderQ? y yes · n no
+ *
+ * y sends the SAME question to CommanderQ for that one turn; the window stays attached. n does nothing.
+ */
+import { askText } from './ask.js';
+
+const clipQ = (s, n) => { const t = String(s ?? '').replace(/\s+/g, ' ').trim(); return t.length > n ? `${t.slice(0, n - 1)}…` : t; };
+
+/** The suggestion from a turn event, when it applies to THIS window (attached to the agent it names). Else null. */
+export function handoffFromEvent(ev, attachedAgent) {
+  if (!ev || ev.type !== 'turn.handoff_suggested') return null;
+  const h = ev.handoff_suggested;
+  const at = String(attachedAgent || '').toLowerCase();
+  if (!h || typeof h !== 'object' || !h.agent || !at) return null;
+  if (String(h.agent).toLowerCase() === at) return null; // already talking to the target
+  if (h.from && String(h.from).toLowerCase() !== at) return null; // a suggestion about some other agent
+  return { agent: String(h.agent), name: String(h.name || h.agent), from: at, fromName: String(h.from_name || at.toUpperCase()), reason: String(h.reason || '').trim() };
+}
+
+/** The ask line (drawn as the approval-style card). question: the user's own words being handed over. */
+export function handoffAskText(h, question, cols = 100) {
+  const action = `ask ${h.name} "${clipQ(question, Math.max(20, cols - 60))}" once; you stay attached to ${h.fromName}`;
+  return askText(`Hand this question to ${h.name}?`, { keys: 'y/N', who: h.fromName, reason: h.reason, action });
+}
+
+/** The one line after a yes-path answer: who answered, and that nothing about the attach changed. */
+export const handoffAnsweredNote = (h) => `↪ ${h.name} answered that one. Still attached to ${h.fromName}.`;
+
+/** The agent's own suggested command, dropped because the handoff answers the question (never silently). */
+export const handoffSupersededNote = (h, line) => `↷ ${h.fromName} also suggested ${line || 'a command'}; not offered, because ${h.name} can answer the question itself.`;
+
+/** A handoff that could not be offered because a plan card is open (never silently). */
+export const handoffSkippedNote = (h) => `↷ ${h.name} could answer this, but the plan card is open, so the handoff is not offered.`;
+
+/**
+ * QUOXON handoff streak (owner, live 05:10-05:17): attached to TRIAGE-Q he asked three infra questions and every one ended
+ * in "Hand this question to CommanderQ?". When the SAME attached agent has suggested a handoff on 2 turns in a row, the
+ * card offers the bigger move (back to CommanderQ) instead of the same small one. c ("keep asking") silences the bigger
+ * offer until a new streak starts; a turn with no suggestion, or a different agent, breaks the streak.
+ */
+export function createHandoffStreak() {
+  let agent = null, count = 0, muted = false;
+  return {
+    /** A turn ended with a handoff suggestion from `from`. -> { count, escalate } */
+    offered(from) {
+      const f = String(from || '').toLowerCase();
+      if (f === agent) count += 1; else { agent = f; count = 1; muted = false; }
+      return { count, escalate: count >= 2 && !muted };
+    },
+    /** A turn ended without a suggestion (or the window moved agents): the streak is over. */
+    clear() { agent = null; count = 0; muted = false; },
+    /** n (just this one): the bigger offer needs a fresh run of two before it returns. */
+    restart() { count = 0; },
+    /** c (keep asking): no bigger offer until a new streak starts. */
+    mute() { muted = true; },
+    peek: () => ({ agent, count, muted }),
+  };
+}
+
+export const HANDOFF_BIG_KEYS = (h) => `y switch · n just this one · c keep asking ${h.fromName}`;
+
+/** The bigger card: offer to move the whole window back instead of handing over one more question. */
+export function handoffBiggerAskText(h, count) {
+  return askText(`Switch this window back to ${h.name}?`, {
+    keys: HANDOFF_BIG_KEYS(h),
+    who: h.fromName,
+    reason: `${h.fromName} has handed off your last ${count} questions`,
+    action: `/detach: this window stops being attached to ${h.fromName} and talks to ${h.name}`,
+  });
+}

package/lib/quoxon/hatSwitch.js

@@ -0,0 +1,37 @@
+/**
+ * /hat helpers (pure), quox#1183. Match a hat the way a person names it (key, display name, "the DevOps hat", a unique
+ * prefix) and the lines /hat prints. Never guesses between ties; an unknown name is { none: true }.
+ */
+const norm = (s) => String(s ?? '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().replace(/^the /, '').replace(/ hat$/, '').trim();
+
+export const isPrivileged = (hat) => hat?.definition?.transitions?.privileged === true || hat?.privileged === true;
+
+/** -> { hat } | { ambiguous: [hats] } | { none: true } */
+export function matchHat(query, hats) {
+  const rows = Array.isArray(hats) ? hats.filter(Boolean) : [];
+  const raw = String(query ?? '').trim();
+  const q = norm(raw);
+  if (!q) return { none: true };
+  const byId = rows.filter((h) => h.id && h.id === raw);
+  if (byId.length === 1) return { hat: byId[0] };
+  const exact = rows.filter((h) => norm(h.key) === q || norm(h.name) === q);
+  if (exact.length === 1) return { hat: exact[0] };
+  if (exact.length > 1) return { ambiguous: exact };
+  const pre = rows.filter((h) => norm(h.key).startsWith(q) || norm(h.name).startsWith(q));
+  if (pre.length === 1) return { hat: pre[0] };
+  if (pre.length > 1) return { ambiguous: pre };
+  return { none: true };
+}
+
+/** "key (Name)" for each hat, for an error that tells you what to type. */
+export const hatChoices = (hats) => (Array.isArray(hats) ? hats : []).map((h) => (h.name && h.name !== h.key ? `${h.key} (${h.name})` : h.key)).join(', ');
+
+/** One line per hat; the active one is marked with *. */
+export function hatLines(hats, activeKey) {
+  const rows = Array.isArray(hats) ? hats : [];
+  const w = Math.min(28, Math.max(4, ...rows.map((h) => [...String(h.name || h.key)].length)));
+  return rows.map((h) => `${h.key === activeKey ? '* ' : '  '}${String(h.name || h.key).padEnd(w)}  ${h.key}${isPrivileged(h) ? '  (privileged: asks you first)' : ''}`);
+}
+
+/** A conversation id in the collector's own shape (turnStream ensureConversationId), for a window with none yet. */
+export const mintConversationId = (uuid) => `QXC_${uuid}`;

package/lib/quoxon/headless.js

@@ -0,0 +1,161 @@
+/**
+ * QUOXON-LATENCY: the headless half of the conversation client (`quox --print`), with no
+ * React / Ink / App import. bin/quox.js routes --print here directly, so a headless turn
+ * no longer pays ~2 s of renderer load before its request is sent. main.js re-exports
+ * every name below, so the interactive client and its importers are unchanged.
+ */
+import { parseModelArg } from './model.js';
+import { loadRules, rulesContext } from './rules.js';
+
+const FLAGS = new Set(['-p', '--profile', '--verbose', '--demo', '--print', '--output', '--conversation', '--turn-id', '--timeout', '--color', '--no-clear', '-n', '--name', '--service-key', '--demo-onboarding', '--autoplay', '--autoplay-exit', '--provider', '--model', '--agent', '--prompt-profile', '--resume', '-h', '--help', '--']);
+const isFlag = (a) => FLAGS.has(a) || /^--(profile|verbose|print|output|conversation|turn-id|timeout|provider|model|agent|prompt-profile|resume)=/.test(a);
+
+export function parseArgs(argv) {
+  const o = { profile: null, verbose: 'on', demo: false, help: false, print: false, prompt: null, output: 'text', conversation: null, turnId: null, timeout: 0, color: false, noClear: false, name: null, serviceKey: false, demoOnboarding: false, autoplay: false, autoplayExit: null, provider: null, agent: null, resume: null, verboseSet: false, errors: [] };
+  let rawProvider = null, rawModel = null;
+  const value = (flag, i) => { const v = argv[i + 1]; if (v === undefined || (v.startsWith('-') && isFlag(v))) { o.errors.push(`${flag} needs a value`); return undefined; } return v; };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--') { const rest = argv.slice(i + 1).join(' '); if (rest) o.prompt = rest; break; }
+    if (a === '-p' || a === '--profile') { const v = value(a, i); if (v !== undefined) { o.profile = v; i++; } }
+    else if (a.startsWith('--profile=')) o.profile = a.slice(10);
+    else if (a === '--verbose') { o.verboseSet = true; const v = argv[i + 1]; if (['off', 'on', 'full'].includes(v)) { o.verbose = v; i++; } else o.verbose = 'on'; } // no value means on
+    else if (a.startsWith('--verbose=')) { o.verboseSet = true; o.verbose = a.slice(10); }
+    else if (a === '--resume') { const v = argv[i + 1]; if (v !== undefined && !v.startsWith('-')) { o.resume = v; i++; } else o.resume = true; } // alone: the picker
+    else if (a.startsWith('--resume=')) o.resume = a.slice(9) || true;
+    else if (a === '-n' || a === '--name') { const v = value(a, i); if (v !== undefined) { o.name = v; i++; } }
+    else if (a.startsWith('--name=')) o.name = a.slice(7);
+    else if (a === '--demo') o.demo = true;
+    else if (a === '--autoplay') o.autoplay = true;
+    else if (a === '--autoplay-exit') { o.autoplay = true; const v = argv[i + 1]; if (v !== undefined && /^\d+(\.\d+)?$/.test(v)) { o.autoplayExit = Number(v); i++; } else o.autoplayExit = 5; } // seconds to hold the final frame
+    else if (a === '--demo-onboarding') o.demoOnboarding = true;
+    else if (a === '--print') { o.print = true; const n = argv[i + 1]; if (n !== undefined && !isFlag(n)) { o.prompt = n; i++; } }
+    else if (a.startsWith('--print=')) { o.print = true; o.prompt = a.slice(8); }
+    else if (a === '--output') { const v = value(a, i); if (v !== undefined) { o.output = v; i++; } }
+    else if (a.startsWith('--output=')) o.output = a.slice(9);
+    else if (a === '--conversation') { const v = value(a, i); if (v !== undefined) { o.conversation = v; i++; } }
+    else if (a === '--agent') { const v = value(a, i); if (v !== undefined) { o.agent = v; i++; } }
+    else if (a.startsWith('--agent=')) o.agent = a.slice(8) || null;
+    else if (a === '--turn-id') { const v = value(a, i); if (v !== undefined) { o.turnId = v; i++; } }
+    else if (a === '--timeout') { const v = value(a, i); if (v !== undefined) { o.timeout = Number(v) || 0; i++; } }
+    else if (a === '--color') o.color = true;
+    else if (a === '--no-clear') o.noClear = true;
+    else if (a === '--service-key') o.serviceKey = true;
+    else if (a === '--provider' || a === '--model') { const v = value(a, i); if (v !== undefined) { if (a === '--provider') rawProvider = v; else rawModel = v; i++; } }
+    else if (a.startsWith('--provider=')) rawProvider = a.slice(11);
+    else if (a.startsWith('--model=')) rawModel = a.slice(8);
+    else if (a === '--prompt-profile') { const v = value(a, i); if (v !== undefined) { o.promptProfile = v; i++; } }
+    else if (a.startsWith('--prompt-profile=')) o.promptProfile = a.slice(17);
+    else if (a === '-h' || a === '--help') o.help = true;
+    else if (!a.startsWith('-') && o.prompt === null && argv.includes('--print')) o.prompt = a; // `--print` given earlier or later; this is its prompt
+    else o.errors.push(a.startsWith('-') ? `unknown option ${a}` : `unexpected argument ${a}`);
+  }
+  if (rawModel && !rawProvider) o.errors.push('--model needs --provider (e.g. --provider openai --model gpt-5.4)');
+  else if (rawProvider) {
+    const m = parseModelArg(rawModel ? `${rawProvider} ${rawModel}` : rawProvider);
+    if (!m.ok) o.errors.push(m.error); else o.provider = m.choice || 'auto'; // 'auto' = this run ignores the saved /model choice
+  }
+  if (o.promptProfile !== undefined && !['compact', 'full'].includes(o.promptProfile)) { o.errors.push(`invalid --prompt-profile "${o.promptProfile}" (use compact or full)`); delete o.promptProfile; }
+  if (!['off', 'on', 'full'].includes(o.verbose)) o.verbose = 'on';
+  if (!['text', 'json'].includes(o.output)) { o.errors.push(`invalid --output "${o.output}" (use text or json)`); o.output = 'text'; }
+  return o;
+}
+
+export const USAGE = 'quox [-p|--profile <name>] [-n|--name <session name>] [--conversation <id>] [--resume [id|name]] [--verbose off|on|full] [--demo [--autoplay [--autoplay-exit [s]]]] [--no-clear] [--service-key] [--provider openai|anthropic|ollama|openrouter|huggingface|groq|together|lmstudio|vllm|custom|auto [--model <id>]]   (quoxon is an alias; the old menu is `quox tui`)\n  quox --conversation <id>   resume that conversation interactively (its saved turns load into the window)\n  quox --resume [id|name]   pick up a recent conversation; alone it opens a picker\n  quox --print "<prompt>" [--output text|json] [--conversation <id>] [--turn-id <id>] [--timeout <s>] [--agent <id>] [--provider <p> [--model <id>]] [--prompt-profile compact|full]   (prompt from stdin if absent or -; use -- before a prompt that starts with -)\n  exit: 0 completed, 1 other, 2 held for approval, 3 interrupted or abandoned, 4 not signed in, 5 ended without server confirmation\n  --provider asks the server for that provider this run (default: your /model choice for this profile, else auto); turn.started from the server says what ran\n  --service-key lets chat use an ambient QUOX_SERVICE_KEY when the profile has no login (never used silently)\n  --demo plays a simulated journey on its own (no server, nothing real runs)\n  --autoplay (with --demo, or QUOX_DEMO_AUTOPLAY=1) plays the whole journey with no input on a fixed script; --autoplay-exit [s] quits s seconds (default 5) after the last frame\n  --demo-onboarding walks Getting started with a dry-run install (nothing is downloaded, built or started)';
+
+/** Default profile: a resident (agent) login cannot chat, so use the single logged-in human profile. */
+export function pickProfile(explicit, cfgMod, env = process.env) {
+  if (explicit) return { name: explicit, note: null };
+  if (env.QUOX_PROFILE) return { name: env.QUOX_PROFILE, note: null }; // an explicit one-shot choice (same as -p), never "the default profile"
+
+  const probe = cfgMod.loadConfig();
+  const active = probe.getActiveProfileName?.();
+  const residents = new Set((probe.listResidentProfiles?.() || []).map(r => r.name));
+  return choosePick(active, residents, probe.listProfiles?.() || []);
+}
+export function choosePick(active, residents, profiles) {
+  if (!residents.has(active)) return { name: undefined, note: null };
+  const humans = profiles.filter(p => !residents.has(p.name) && p.loggedIn);
+  if (humans.length === 1) return { name: humans[0].name, note: null }; // the status line shows the profile; no transcript noise
+  const names = profiles.filter(p => !residents.has(p.name) && p.loggedIn).map(p => p.name);
+  const hint = names.length ? ` Pass -p <your profile>. Human profiles found: ${names.join(', ')} (start with: quox -p ${names[0]}).` : ' Pass -p <your profile>.';
+  return { name: undefined, note: `The default profile "${active}" is an agent login, so this chat runs as the agent, not as a person.${hint}` };
+}
+
+/**
+ * Chat identity gate. A named profile that does not exist is an error (never created on the fly), and an
+ * ambient QUOX_SERVICE_KEY is only a credential when the user asked for it (--service-key or FORCE).
+ * -> null when chat may proceed, else { message }.
+ */
+export function chatCredentialProblem({ profileArg, profiles, hasStoredLogin, profileName, env = process.env, serviceKeyFlag = false }) {
+  if (profileArg && !profiles.some(p => p.name === profileArg)) return { message: `profile ${profileArg} does not exist; create it with: quox login -p ${profileArg}` };
+  if (hasStoredLogin) return null;
+  if ((serviceKeyFlag || env.QUOX_FORCE_SERVICE_KEY) && env.QUOX_SERVICE_KEY) return null;
+  return { message: `Not signed in for chat on profile ${profileName}. Run: quox login -p ${profileName}${env.QUOX_SERVICE_KEY ? ' (an ambient QUOX_SERVICE_KEY is ignored unless you pass --service-key)' : ''}` };
+}
+
+/**
+ * Is this a machine with no Quox server configured at all? Then bare `quox` is Getting started, and --print
+ * says how to get there. Reads profiles only (no network).
+ */
+export async function noServerConfigured(opts, cfgMod, env = process.env) {
+  const { needsGettingStarted } = await import('./onboarding/detect.js');
+  const { loadJourney } = await import('./onboarding/journey.js');
+  const probe = cfgMod.loadConfig();
+  return needsGettingStarted({ profiles: probe.listProfiles?.() || [], residents: probe.listResidentProfiles?.() || [], profileArg: opts.profile, env, serviceKeyFlag: opts.serviceKey, journey: loadJourney() });
+}
+
+/** --print without a usable login: today's message, plus the way in when no server exists yet. */
+export function printAuthMessage(problem, gettingStarted, hint) {
+  return `quox: ${problem.message}\n${gettingStarted ? `quox: ${hint}\n` : ''}`;
+}
+
+export async function mainPrint(opts) {
+  const { runPrint, resolvePrompt, EXIT } = await import('./print.js');
+  const out = (s) => process.stdout.write(s);
+  const err = (s) => process.stderr.write(s);
+  const prompt = await resolvePrompt(opts.prompt, process.stdin);
+  let api;
+  if (opts.demo) api = (await import('./demo.js')).createDemoApi({ speed: 20 });
+  else {
+    const cfgMod = await import('../core/config.js');
+    const { createAuth } = await import('../core/auth.js');
+    const { createClient } = await import('../core/client.js');
+    const { createApi } = await import('./api.js');
+    const probe = cfgMod.loadConfig();
+    const profiles = probe.listProfiles?.() || [];
+    const missing = opts.profile && !profiles.some(p => p.name === opts.profile);
+    const pick = pickProfile(opts.profile, cfgMod);
+    if (pick.note) err(pick.note + '\n');
+    const config = missing ? probe : cfgMod.loadConfig(pick.name);
+    const auth = createAuth(config);
+    const pname = missing ? opts.profile : (config.getActiveProfileName?.() || 'default');
+    const problem = chatCredentialProblem({ profileArg: opts.profile, profiles, hasStoredLogin: missing ? false : Boolean(config.getAuth?.()?.access_token), profileName: pname, serviceKeyFlag: opts.serviceKey });
+    if (problem) {
+      const { NO_SERVER_PRINT } = await import('./onboarding/copy.js');
+      err(printAuthMessage(problem, await noServerConfigured(opts, cfgMod), NO_SERVER_PRINT));
+      process.exitCode = EXIT.auth; return;
+    }
+    const { createWindowClient } = await import('./windowOrg.js');
+    api = createApi({ ...createWindowClient({ config, auth, createClient }), config }); // #1034: /org stays in this process
+    if (opts.conversation && api.conversationExists) {
+      const c = await api.conversationExists(opts.conversation);
+      if (c.exists === false) { err(`quox: conversation not found: ${opts.conversation}\n`); process.exitCode = EXIT.error; return; }
+      if (c.exists === null) err(`quox: could not verify conversation ${opts.conversation} (${c.reason}); continuing\n`);
+    }
+  }
+  const rules = opts.demo ? null : loadRules();
+  for (const s of rules?.skipped || []) err(`quox: ignoring ${s.path}: ${s.reason}\n`);
+  const choice = opts.provider === 'auto' ? null : opts.provider || api.modelChoice?.() || null;
+  process.exitCode = await runPrint({ api, choice, agent: opts.agent || undefined, promptProfile: opts.promptProfile, context: rulesContext(rules), prompt, output: opts.output, conversation: opts.conversation, turnId: opts.turnId || undefined, timeoutS: opts.timeout, color: opts.color, profile: opts.profile || null, out, err });
+}
+
+/** bin/quox.js entry for --print: the same arg checks main() makes, then the headless turn. */
+export async function runHeadless(argv) {
+  const opts = parseArgs(argv);
+  if (!opts.print) return false; // not a headless run after all (e.g. `-- --print` is a prompt): main() owns it
+  if (opts.help) { console.log(USAGE); return true; }
+  if (opts.errors.length) { process.stderr.write(`quox: ${opts.errors.join('; ')}\n${USAGE}\n`); process.exitCode = 1; return true; }
+  await mainPrint(opts);
+  return true;
+}

package/lib/quoxon/hostUrls.js

@@ -0,0 +1,41 @@
+/**
+ * Z2H-R3: which address to PRINT for the dashboard and for the host installer. Over SSH to a fresh
+ * install the profile is https://localhost:3000, which only works on the Quox box, so a printed
+ * localhost is wrong for anyone reading it elsewhere. Order: the server's app URL (app_base_url),
+ * else the address this CLI reached the server on, else the address the install finale showed,
+ * else this machine's detected LAN address. Loopback is the last resort, never the first answer.
+ */
+import { networkInterfaces } from 'node:os';
+
+export const isLoopbackUrl = (u) => {
+  try { return /^(localhost|127\.\d+\.\d+\.\d+|\[::1\]|::1|0\.0\.0\.0)$/i.test(new URL(u).hostname); } catch { return true; }
+};
+const ok = (u) => typeof u === 'string' && /^https?:\/\/[^\s/]+/.test(u) && !isLoopbackUrl(u);
+const origin = (u) => new URL(u).origin;
+
+/** First non-internal IPv4 address (private ranges preferred), or null. */
+export function detectLanIp(ifaces = networkInterfaces()) {
+  const all = Object.entries(ifaces || {}).filter(([n]) => !/^(docker|br-|veth|virbr|cni|flannel|cali|tun|tap)/i.test(n)).flatMap(([, v]) => v || [])
+    .filter(a => a && a.family === 'IPv4' && !a.internal && a.address);
+  const priv = all.find(a => /^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.)/.test(a.address));
+  return (priv || all[0])?.address || null;
+}
+
+/** Dashboard base: { url, source } . source: server | profile | install | lan | local. */
+export function resolveDashboardBase({ serverApp, profileUrl, journeyUrl, lanIp } = {}) {
+  if (ok(serverApp)) return { url: origin(serverApp), source: 'server' };
+  if (ok(profileUrl)) return { url: origin(profileUrl), source: 'profile' };
+  if (ok(journeyUrl)) return { url: origin(journeyUrl), source: 'install' };
+  if (lanIp) return { url: `https://${lanIp}:3000`, source: 'lan' };
+  return { url: profileUrl || 'https://localhost:3000', source: 'local' };
+}
+
+/** Base that serves GET /install (the collector, :9848): { url, source }. */
+export function resolveCollectorBase({ collectorUrl, serverApp, journeyUrl, lanIp } = {}) {
+  if (ok(collectorUrl)) return { url: origin(collectorUrl), source: 'profile' };
+  for (const [u, source] of [[serverApp, 'server'], [journeyUrl, 'install']]) {
+    if (ok(u)) return { url: `http://${new URL(u).hostname}:9848`, source };
+  }
+  if (lanIp) return { url: `http://${lanIp}:9848`, source: 'lan' };
+  return { url: collectorUrl || null, source: 'local' };
+}

package/lib/quoxon/indicator.js

@@ -64,8 +64,10 @@ export function normUsage(u, doneCost) {
   const tokens = Number.isFinite(Number(out)) && out != null ? Number(out)
     : Number.isFinite(Number(total)) && total != null ? Number(total)
     : Number.isFinite(Number(inp)) && inp != null ? Number(inp) : null;
+  // cost_source 'claude-cli': the claude CLI's own API-equivalent estimate on the subscription path, not a price.
+  const costSource = typeof o.cost_source === 'string' ? o.cost_source : null;
   const cost = Number(o.cost_usd ?? doneCost);
-  return { tokens, cost: Number.isFinite(cost) && cost > 0 ? cost : null, real: tokens != null };
+  return { tokens, cost: !costSource && Number.isFinite(cost) && cost > 0 ? cost : null, real: tokens != null, costSource };
 }
 
 /** Live token figure: the real number once the server reported it, else an estimate from received text (~chars/4). */
@@ -82,7 +84,9 @@ export function turnTokens(turn) {
  * Sans Mono fallback (ｪｴ like I/E, ｭｮﾕﾖ boxes, ﾆ "=", ﾉ "/", ﾌ "7", ﾍ "^", ﾘ "U", ﾚ "L", ﾛ a box, ｰ a dash)
  * and the voiced marks ﾞ ﾟ.
  */
-export const SCRAMBLE_GLYPHS = 'ｦｧｨｩｫｬｯｱｲｳｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾇﾈﾊﾋﾎﾏﾐﾑﾒﾓﾔﾗﾙﾜﾝ';
+/** Decode glyphs: every half-width katakana (U+FF66-FF9D, one cell each, minus the long-vowel bar ｰ) plus the
+ * code-rain digits. Owner 2026-10-15: the reveal felt like "just a few characters" with 44 look-alike kana. */
+export const SCRAMBLE_GLYPHS = 'ｦｧｨｩｪｫｬｭｮｯｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜﾝ0123456789';
 
 /** Deterministic hash in [0,1). */
 const hsh = (a, b, c = 0) => { let x = (a * 374761393 + b * 668265263 + c * 2147483647) | 0; x = Math.imul(x ^ (x >>> 13), 1274126177); return ((x ^ (x >>> 16)) >>> 0) / 4294967296; };

package/lib/quoxon/intent.js

@@ -13,14 +13,25 @@ const PANELS = [
 function PANEL_RULES() { return PANELS.map(([re, cmd]) => [re, () => cmd]); }
 
 const RULES = [
-  [new RegExp(`^attach(?: me)?(?: to)? ${WORD}$`, 'i'), (m) => `/attach ${m[1]}`],
+  // owner 2026-10-15: "attach to TRIAGE-Q agent" / "reattach to ..." took four turns; the tip must catch them
+  [new RegExp(`^(?:please )?(?:re)?attach(?: me)?(?: to)?(?: the)? ${WORD}(?: agent)?(?: please)?$`, 'i'), (m) => `/attach ${m[1].toLowerCase()}`],
   [/^rename (?:this|the|my) (?:session|conversation|chat) (?:to|as) ([\w.-]+(?: [\w.-]+){0,2})$/i, (m) => m[1].split(' ').some(w => /^(and|then|but|so|please)$/i.test(w)) ? null : `/rename ${m[1]}`],
   [/^(?:what(?:'s| is) running|what is running now)$/i, () => '/roster'],
   [/^(?:show|list|open) (?:my |the )?(?:pending )?approvals$/i, () => '/approvals'],
   [/^(?:what(?:'s| is)|show me what(?:'s| is)) (?:waiting|pending) (?:for )?(?:my )?approval$/i, () => '/approvals'],
+  [/^(?:so )?(?:what (?:did i miss|have i missed)(?: (?:while|when) i was (?:away|out|gone|offline))?|what (?:happened|changed) (?:while|when) i was (?:away|out|gone|offline)|(?:did )?anything happen(?:ed)? while i was (?:away|out|gone|offline)|catch me up)$/i, () => '/away'],
+  [/^(?:(?:give me |show me |can i get )?(?:a |the )?sit ?rep(?: please)?|what(?:'s| is) the situation(?: now)?|situation report(?: please)?)$/i, () => '/sitrep'],
+  [/^(?:how(?:'s| is) (?:the |my |our )?fleet(?: doing)?|(?:show|list) (?:me )?(?:the |my |our )?fleet|fleet (?:status|health)|what(?:'s| is) (?:the )?(?:state|health) of (?:the |my |our )?(?:fleet|computers|servers))$/i, () => '/fleet'],
+  [/^(?:open|show|take me to|go to) (?:me )?(?:to )?(?:the |my )?(?:quox )?(?:web )?dashboard$/i, () => '/dashboard'],
   [/^detach(?: from (?:the )?agent)?$/i, () => '/detach'],
+  [/^(?:clear|cls|clear (?:the )?screen)$/i, () => '/clear'], // owner typed bare "clear" (2026-10-15)
   [/^(?:start )?(?:a )?new conversation$/i, () => '/new'],
   [/^(?:please )?(?:compact|summari[sz]e and compact|compress) (?:this|the|our|my) (?:conversation|chat|session|context)(?: please)?$/i, () => '/compact'],
+  [/^(?:please )?(?:update|upgrade) (?:the |my |this )?(?:quox )?(?:server|install|instance|quox)(?: (?:to (?:the )?latest|please))?$/i, () => 'quox server update --dry-run (in a terminal; shows the plan first)'],
+  [/^(?:please )?roll ?back (?:the |my |this )?(?:quox )?(?:server|install|instance|update)$/i, () => 'quox server rollback --dry-run (in a terminal)'],
+  [/^(?:please )?uninstall (?:the |my |this )?(?:quox )?(?:server|install|instance|quox)$/i, () => 'quox server uninstall --dry-run (in a terminal; lists what goes first)'],
+  [/^(?:what version is (?:the |my )?(?:quox )?server(?: on| running)?|is (?:the |my )?(?:quox )?server (?:up to date|healthy)|server status)$/i, () => '/server'],
+  [/^(?:make|create|write) (?:a )?(?:support|diag(?:nostic)?s?) bundle$/i, () => 'quox server diag (in a terminal; written locally, never uploaded)'],
   ...PANEL_RULES()
 ];
 

package/lib/quoxon/keys.js

@@ -5,8 +5,21 @@
  *
  * parseChunk(chunk, state) -> { events, state }
  * Events: { type: 'text', text } | { type: 'paste', text } | { type: 'key', name, ctrl?, alt? } | { type: 'focus', focused }
+ *   | { type: 'mouse', action: 'press'|'release'|'drag'|'move'|'wheel', button, x, y, shift, alt, ctrl } (SGR 1006, QUOXON-MOUSE)
+ *   | { type: 'cursor', row, col } (a cursor position report, the answer to DSR ESC[6n)
  */
 
+const BUTTONS = ['left', 'middle', 'right', 'none'];
+const WHEEL = ['up', 'down', 'left', 'right'];
+/** One SGR mouse report (ESC [ < b ; x ; y M|m) as an event. */
+function mouseEvent(b, x, y, final) {
+  const low = b & 3;
+  const mods = { shift: Boolean(b & 4), alt: Boolean(b & 8), ctrl: Boolean(b & 16) };
+  if (b & 64) return { type: 'mouse', action: 'wheel', button: WHEEL[low], x, y, ...mods };
+  if (b & 32) return { type: 'mouse', action: low === 3 ? 'move' : 'drag', button: BUTTONS[low], x, y, ...mods };
+  return { type: 'mouse', action: final === 'm' ? 'release' : 'press', button: BUTTONS[low], x, y, ...mods };
+}
+
 export const PASTE_ON = '\x1b[?2004h';
 export const PASTE_OFF = '\x1b[?2004l';
 const PASTE_START = '\x1b[200~';
@@ -42,18 +55,27 @@ const CSI_KEYS = {
   '\x1b[1~': 'home', '\x1b[4~': 'end', '\x1b[7~': 'home', '\x1b[8~': 'end',
   '\x1b[3~': 'delete', '\x1b[Z': 'shift-tab',
   '\x1b[13;2u': 'shift-enter', '\x1b[27;2;13~': 'shift-enter', '\x1b\r': 'shift-enter', '\x1b\n': 'shift-enter',
-  '\x1b[1;5D': 'word-left', '\x1b[1;5C': 'word-right', '\x1b[1;3D': 'word-left', '\x1b[1;3C': 'word-right'
+  '\x1b[1;5D': 'word-left', '\x1b[1;5C': 'word-right', '\x1b[1;3D': 'word-left', '\x1b[1;3C': 'word-right',
+  // COMPOSER-EDIT (owner 2026-10-17: edit like Claude Code's prompt box). Alt+B/F (macOS Option+Left/Right), iTerm2 Alt+arrows,
+  // Alt+Backspace, Alt+D, Ctrl/Alt+Delete, and Shift (+Ctrl/Alt) arrows, Home and End for selection.
+  '\x1bb': 'word-left', '\x1bf': 'word-right', '\x1b\x1b[D': 'word-left', '\x1b\x1b[C': 'word-right',
+  '\x1b\x7f': 'delete-word', '\x1b\x08': 'delete-word', '\x1bd': 'delete-word-forward',
+  '\x1b[3;5~': 'delete-word-forward', '\x1b[3;3~': 'delete-word-forward',
+  '\x1b[1;2D': 'select-left', '\x1b[1;2C': 'select-right', '\x1b[1;2A': 'select-up', '\x1b[1;2B': 'select-down',
+  '\x1b[1;2H': 'select-home', '\x1b[1;2F': 'select-end',
+  '\x1b[1;6D': 'select-word-left', '\x1b[1;6C': 'select-word-right', '\x1b[1;4D': 'select-word-left', '\x1b[1;4C': 'select-word-right'
 };
 const CSI_LIST = Object.keys(CSI_KEYS).sort((a, b) => b.length - a.length);
 
 const CTRL = {
   '\x01': 'home', '\x05': 'end', '\x03': 'ctrl-c', '\x04': 'ctrl-d', '\x07': 'ctrl-g',
-  '\x0f': 'ctrl-o', '\x13': 'ctrl-s', '\x15': 'kill-line', '\x17': 'delete-word',
+  '\x0b': 'kill-line-forward', '\x0f': 'ctrl-o', '\x13': 'ctrl-s', '\x15': 'kill-line', '\x17': 'delete-word',
   '\x1f': 'undo', '\x19': 'redo', '\x0a': 'newline', '\x7f': 'backspace', '\x08': 'backspace',
   '\r': 'enter', '\t': 'tab', '\x02': 'left', '\x06': 'right'
 };
 
-export function parseChunk(chunk, state = initialKeyState()) {
+/** `draft` = the composer text before this chunk (a burst split mid-line continues the line already typed). */
+export function parseChunk(chunk, state = initialKeyState(), draft = '') {
   const events = [];
   let s = String(chunk);
   let st = { partial: '', ...state };
@@ -77,6 +99,12 @@ export function parseChunk(chunk, state = initialKeyState()) {
     if (s[0] === '\x1b') {
       // Focus reporting (CSI ?1004h, enabled by sound/index.js): CSI I = focus in, CSI O = focus out.
       if (s.startsWith('\x1b[I') || s.startsWith('\x1b[O')) { events.push({ type: 'focus', focused: s[2] === 'I' }); s = s.slice(3); continue; }
+      // QUOXON-MOUSE: SGR mouse reports; a report split across chunks is held, never typed into the composer.
+      const mm = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/.exec(s);
+      if (mm) { events.push(mouseEvent(Number(mm[1]), Number(mm[2]), Number(mm[3]), mm[4])); s = s.slice(mm[0].length); continue; }
+      if (/^\x1b\[<[\d;]*$/.test(s)) { st.partial = s; s = ''; break; }
+      const cr = /^\x1b\[(\d+);(\d+)R/.exec(s);
+      if (cr) { events.push({ type: 'cursor', row: Number(cr[1]), col: Number(cr[2]) }); s = s.slice(cr[0].length); continue; }
       const hit = CSI_LIST.find(k => s.startsWith(k));
       if (hit) { events.push({ type: 'key', name: CSI_KEYS[hit] }); s = s.slice(hit.length); continue; }
       // Unknown escape sequence: swallow ESC [ ... final byte, or a bare ESC+char (alt-x).
@@ -93,19 +121,34 @@ export function parseChunk(chunk, state = initialKeyState()) {
     if (CTRL[c]) { events.push({ type: 'key', name: CTRL[c] }); }
     s = s.slice(1);
   }
-  return { events: coalesceBurst(events), state: st };
+  return { events: coalesceBurst(events, draft), state: st };
 }
 
 /**
  * If a chunk produced text and then an Enter/newline FOLLOWED by more text, it is
  * a non-bracketed paste: fold it into one paste event. A trailing single Enter
  * (text then Enter at the end) stays as text + enter so fast typing still submits.
+ *
+ * Except a burst whose every line is a slash command (R3 D3): that is typed input batched by tmux,
+ * SSH/mosh or a script ("/help" Enter "/model x" Enter), never a paste, so each Enter runs its line.
+ * Folding it made a multi-line "/" draft that trapped every later Enter.
  */
-function coalesceBurst(events) {
+const isEnter = (e) => e.type === 'key' && (e.name === 'enter' || e.name === 'newline');
+function commandLines(events, draft = '') {
+  let line = draft.includes('\n') ? '\n' : draft; // a multi-line draft is never a command line
+  for (const e of events) {
+    if (e.type === 'text') line += e.text;
+    else if (e.name === 'enter') { if (!line.startsWith('/')) return false; line = ''; }
+    else return false; // newline (Ctrl+J), tab or any other key: not plain typed commands
+  }
+  return line === '' || line.startsWith('/');
+}
+function coalesceBurst(events, draft = '') {
   const hasInner = events.some((e, i) =>
-    e.type === 'key' && (e.name === 'enter' || e.name === 'newline') && i > 0 && i < events.length - 1 &&
+    isEnter(e) && i > 0 && i < events.length - 1 &&
     events.slice(i + 1).some(x => x.type === 'text'));
   if (!hasInner) return events;
+  if (commandLines(events, draft)) return events;
   let text = '';
   const rest = [];
   for (let i = 0; i < events.length; i++) {

package/lib/quoxon/launcher.js

@@ -0,0 +1,103 @@
+/**
+ * QUOXON-RESTART-LEAK: the conversation client's top-level launcher.
+ *
+ * Before this, /restart (and /update, /restart auto, a profile switch that restarts) ran the successor with
+ * spawnSync from INSIDE the old client and waited for it. The old client froze but stayed resident with its
+ * whole heap, so every restart nested one more TUI under the last: the owner's terminal reached 98 nested
+ * clients and 15 GB RSS (on the dev box, 2026-10-17).
+ *
+ * Now the first interactive `quox` on a terminal becomes this launcher: no React, no Ink, no api, no timers,
+ * never touches stdin. It runs the client as its child and waits. A client that wants a restart writes a
+ * handoff file (what to run, the one-shot env it carries) and exits with RESTART_EXIT_CODE; the launcher
+ * reads it, deletes it, and runs the successor. Any other exit is passed straight through. So after any
+ * number of restarts there is exactly one client process per terminal (plus this launcher).
+ *
+ * Tiny on purpose: it must import nothing heavy (bin/quox.js loads it before React, Ink or any command).
+ */
+import { spawn } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir, constants as osConstants } from 'node:os';
+import { join } from 'node:path';
+
+/** The client asks its launcher for a restart with this exit code AND a handoff file (both, never one alone). */
+export const RESTART_EXIT_CODE = 75;
+/** Env var naming the handoff file. Read and DELETED by the client at startup, so nothing it spawns inherits it. */
+export const LAUNCHER_HANDOFF_ENV = 'QUOX_LAUNCHER_HANDOFF';
+/** QUOX_NO_LAUNCHER=1 turns the launcher off (the client then restarts the old, nested way). */
+export const NO_LAUNCHER_ENV = 'QUOX_NO_LAUNCHER';
+
+const ONE_SHOT = /^QUOX_RESTART_/; // carried into ONE successor only, never re-applied by the launcher
+
+let handoff; // undefined = not read yet; null = not launched; { path, base } = launched
+/**
+ * Client side, once at startup: am I running under a launcher? Reads and deletes the env var (a shell or
+ * `quox` the client spawns must never think it is the launched client). -> { path, base } | null.
+ */
+export function takeLauncherHandoff(env = process.env) {
+  if (env === process.env && handoff !== undefined) return handoff;
+  const path = env[LAUNCHER_HANDOFF_ENV] || null;
+  delete env[LAUNCHER_HANDOFF_ENV];
+  const r = path ? { path, base: { ...env } } : null; // base: the env as launched, to send only what a restart changes
+  if (env === process.env) handoff = r;
+  return r;
+}
+/** Test hook: forget the cached handoff. */
+export function resetLauncherHandoff() { handoff = undefined; }
+
+/** Should this invocation become the launcher? Only an interactive client on a real terminal, never a launched child. */
+export function shouldLaunch({ argv = [], env = process.env, isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY) } = {}) {
+  if (!isTTY || env[LAUNCHER_HANDOFF_ENV] || env[NO_LAUNCHER_ENV] === '1') return false;
+  const head = argv.indexOf('--') === -1 ? argv : argv.slice(0, argv.indexOf('--'));
+  return !head.some(a => a === '--print' || a.startsWith('--print=') || a === '-h' || a === '--help');
+}
+
+/**
+ * Client side: hand a restart to the launcher. `plan` is { cmd, args, env } (restartPlan in slash/restart.js);
+ * only the env entries that differ from the launched env are written (the launcher adds them to its own).
+ * -> true when the handoff file was written (the caller then exits with RESTART_EXIT_CODE).
+ */
+export function writeRestartHandoff(h, plan, { write = writeFileSync } = {}) {
+  if (!h?.path || !plan?.cmd) return false;
+  const env = {};
+  for (const [k, v] of Object.entries(plan.env || {})) if (v !== undefined && (ONE_SHOT.test(k) || h.base[k] !== v)) env[k] = v; // a one-shot always rides: the launcher strips them between runs
+  try { write(h.path, JSON.stringify({ cmd: plan.cmd, args: plan.args || [], env }), { mode: 0o600 }); return true; }
+  catch { return false; }
+}
+
+/**
+ * Launcher side: run the client, and again each time it asks for a restart. Resolves with the exit code to
+ * leave with. `deps` lets tests stand in for spawn and the handoff directory.
+ */
+export async function runLauncher({ argv = [], execPath = process.execPath, script = process.argv[1], env = process.env, deps = {}, onSpawn = null } = {}) {
+  const d = { spawn, mkdtemp: () => mkdtempSync(join(tmpdir(), 'quox-launch-')), read: (p) => readFileSync(p, 'utf8'), rm: (p) => rmSync(p, { force: true, recursive: true }), signals: process, ...deps };
+  let dir;
+  try { dir = d.mkdtemp(); } catch { return null; } // no handoff dir: the caller runs the client in-process (old behaviour)
+  const file = join(dir, 'restart.json');
+  const carry = (e) => Object.fromEntries(Object.entries(e).filter(([k]) => !ONE_SHOT.test(k) && k !== LAUNCHER_HANDOFF_ENV)); // later runs never re-apply a one-shot
+  let child = null;
+  const forward = (sig) => () => { try { child?.kill(sig); } catch { /* gone */ } };
+  const handlers = { SIGINT: () => {}, SIGQUIT: () => {}, SIGTERM: forward('SIGTERM'), SIGHUP: forward('SIGHUP') }; // ^C belongs to the client (same process group)
+  for (const [s, f] of Object.entries(handlers)) d.signals.on(s, f);
+  let next = { cmd: execPath, args: [script, ...argv], env: { ...env } }; // the first run keeps any one-shot it was started with
+  try {
+    for (;;) {
+      d.rm(file);
+      const r = await new Promise((done) => {
+        try { child = d.spawn(next.cmd, next.args, { stdio: 'inherit', env: { ...next.env, [LAUNCHER_HANDOFF_ENV]: file } }); }
+        catch (e) { done({ error: e }); return; }
+        onSpawn?.(child);
+        child.once('error', (e) => done({ error: e }));
+        child.once('exit', (code, signal) => done({ code, signal }));
+      });
+      child = null;
+      if (r.error) { process.stderr.write(`quox: could not start ${next.cmd} (${r.error.code || r.error.message})\n`); return 1; }
+      let ask = null;
+      if (r.code === RESTART_EXIT_CODE) { try { ask = JSON.parse(d.read(file)); } catch { ask = null; } }
+      if (!ask?.cmd) return r.signal ? 128 + (osConstants.signals[r.signal] || 0) : (r.code ?? 1);
+      next = { cmd: ask.cmd, args: Array.isArray(ask.args) ? ask.args : [], env: { ...carry(next.env), ...(ask.env || {}) } }; // the env the client was launched with, plus what its restart changed
+    }
+  } finally {
+    for (const [s, f] of Object.entries(handlers)) d.signals.off(s, f);
+    d.rm(dir);
+  }
+}