quoxcli 0.3.1 → 0.5.0

package/lib/quoxon/onboarding/view.js

@@ -18,6 +18,7 @@ import * as T from './copy.js';
 import { matchIntent, yesNo, parseConnect } from './intent.js';
 import { loadJourney, saveJourney, clearJourney, resumeStep } from './journey.js';
 import { pendingRows, runPreflight, preflightPassed, detectOllama, defaultDeps } from './preflight.js';
+import { probeLocalQuox } from './probe.js';
 import { credentialOptions, KEY_PROVIDERS, normaliseOllamaUrl, nextSelectable } from './credential.js';
 import { needsConsent, providerLabel } from '../consent.js';
 import { HelloIntro, helloIntroMs } from '../qmotion.js';
@@ -101,8 +102,8 @@ const Hint = ({ text, cols }) => h(Box, { paddingLeft: 2 }, h(Text, { color: c('
 
 // ---- the view ---------------------------------------------------------------------------------
 export function GettingStarted({
-  columns, version = '0.3.1', cwd = '', welcome = false, animateIntro, earlyInput = null,
-  journeyPath, dryRun = false, runner = null, preflightDeps, runChecks = runPreflight, findOllama = detectOllama,
+  columns, version = '0.5.0', cwd = '', welcome = false, animateIntro, earlyInput = null,
+  journeyPath, dryRun = false, runner = null, preflightDeps, runChecks = runPreflight, findLocal = probeLocalQuox, findOllama = detectOllama,
   requestCredential, broker = null, finisher = null, onExit = () => {}, now = () => Date.now()
 }) {
   const { stdin, setRawMode, isRawModeSupported } = useStdin();
@@ -179,7 +180,7 @@ export function GettingStarted({
 
   function offerLines() {
     const items = [{ kind: 'guide', text: T.OFFER }];
-    items.push({ kind: 'ask', text: T.OFFER_ASK }, { kind: 'dim', text: T.ALREADY });
+    items.push({ kind: 'ask', text: T.OFFER_ASK }, { kind: 'dim', text: T.CHOICES }, { kind: 'dim', text: T.ALREADY });
     push(...items);
     set({ step: 'offer' });
     persist();
@@ -218,6 +219,10 @@ export function GettingStarted({
     if (text.startsWith('/')) { onSlash(text); return; }
     if (s.step === 'ask') return onRequest(text);
     if (s.step === 'offer' || s.step === 'declined') {
+      const pick = text.toLowerCase();
+      if (pick === 'a') { push({ kind: 'user', text }); startPreflight(); return; } // install here: the same flow as yes
+      if (pick === 'b') { push({ kind: 'user', text }, { kind: 'dim', text: T.LOCAL_CHECKING }); useLocal(); return; }
+      if (pick === 'c') { push({ kind: 'user', text }, { kind: 'guide', text: T.CONNECT_ELSEWHERE }); return; }
       const yn = yesNo(text);
       if (yn === true) { push({ kind: 'user', text: text || 'yes' }); startPreflight(); return; }
       if (yn === false) { push({ kind: 'user', text }, { kind: 'guide', text: T.DECLINED }, { kind: 'dim', text: T.DECLINED_HINT }); set({ step: 'declined' }); persist(); return; }
@@ -225,6 +230,14 @@ export function GettingStarted({
     }
   }
 
+  async function useLocal() {
+    const f = await findLocal();
+    if (!live.current || S.current.done) return;
+    if (!f.found) { push({ kind: 'guide', tone: 'warn', text: T.LOCAL_NONE }); return; }
+    push({ kind: 'guide', tone: 'ok', text: T.localFound(f.url) }, { kind: 'guide', text: T.connectChecking(f.url) });
+    exit({ action: 'connect', url: f.url });
+  }
+
   async function startPreflight() {
     set({ step: 'preflight', rows: pendingRows(), fixNote: null });
     persist();

package/lib/quoxon/orgSwitch.js

@@ -5,10 +5,32 @@ export const orgRows = (list) => (Array.isArray(list) ? list : []).map((o) => ({
 
 /**
  * Resolve a typed name or id against the user's orgs. Exact id, exact slug/name, then every word of the
- * query found in the name or slug (so "hot tubs hampshire" finds "Hot Tubs Hampshire Ltd"). Never guesses between ties.
+ * query found in the name or slug (so "acme widgets" finds "Acme Widgets Ltd"). Never guesses between ties.
  * -> { org } | { ambiguous: [orgs] } | { none: true }
  */
+const VERBS = new Set(['switch', 'swith', 'swich', 'sw', 'to', 'go', 'use']);
+/** Drop ONE leading verb-ish token ("swith quox dev" -> "quox dev"); a lone verb is kept (it may be the name). */
+export function stripOrgVerb(query) {
+  const m = /^(\S+)\s+(\S[\s\S]*)$/.exec(String(query ?? '').trim());
+  return m && VERBS.has(m[1].toLowerCase()) ? m[2].trim() : String(query ?? '').trim();
+}
+
+/** Orgs for a picker when nothing matched uniquely: those hitting the most query words (verb stripped), at least one. */
+export function orgCandidates(query, list) {
+  const words = norm(stripOrgVerb(query)).split(' ').filter(Boolean);
+  const scored = orgRows(list).map((o) => { const hay = `${norm(o.name)} ${norm(o.slug)}`; return { o, n: words.filter((w) => hay.includes(w)).length }; });
+  const best = Math.max(0, ...scored.map((x) => x.n));
+  return best ? scored.filter((x) => x.n === best).map((x) => x.o) : [];
+}
+
 export function matchOrg(query, list) {
+  const first = matchOrgExact(query, list);
+  if (!first.none) return first;
+  const stripped = stripOrgVerb(query);
+  return stripped !== String(query ?? '').trim() ? matchOrgExact(stripped, list) : first;
+}
+
+function matchOrgExact(query, list) {
   const rows = orgRows(list);
   const q = norm(query);
   if (!q) return { none: true };
@@ -31,3 +53,29 @@ export function orgLines(list, currentId) {
   const w = Math.min(36, Math.max(4, ...rows.map((o) => [...o.name].length)));
   return rows.map((o) => `${o.id === currentId ? '* ' : '  '}${o.name.padEnd(w)}  ${o.slug || o.id}${o.role ? `  (${o.role})` : ''}`);
 }
+
+/** `quox org switch` with no argument: the same list, numbered from 1, current org marked. */
+export function numberedOrgLines(list, currentId) {
+  const rows = orgRows(list);
+  const w = Math.min(36, Math.max(4, ...rows.map((o) => [...o.name].length)));
+  return rows.map((o, i) => `${o.id === currentId ? '*' : ' '} ${String(i + 1).padStart(String(rows.length).length)}) ${o.name.padEnd(w)}  ${o.slug || o.id}${o.role ? `  (${o.role})` : ''}`);
+}
+
+/** A typed answer to the numbered list: an exact slug/name/id first (so a numeric slug is never shadowed), then a 1-based number. */
+export function pickOrgByInput(input, list) {
+  const rows = orgRows(list);
+  const t = String(input ?? '').trim();
+  if (!t) return { none: true };
+  const m = matchOrg(t, rows);
+  const exactly = m.org && (m.org.slug === t || String(m.org.id).toLowerCase() === t.toLowerCase() || norm(m.org.name) === norm(t));
+  if (exactly) return m;
+  if (/^\d+$/.test(t)) { const n = Number(t); return n >= 1 && n <= rows.length ? { org: rows[n - 1] } : { none: true }; }
+  return m;
+}
+
+/** After a profile-wide `quox org switch`: how the other windows on that profile pick the change up. */
+export function sharedSwitchHint({ name, pids }) {
+  const n = pids.length;
+  return `${n} other quox session${n === 1 ? '' : 's'} ${n === 1 ? 'uses' : 'use'} profile "${name}" (pid ${pids.join(', ')}). `
+    + 'They pick this org up on their next token refresh; run /restart in a window to pick it up now. /org <name> moves one window only.';
+}

package/lib/quoxon/planSteps.js

@@ -0,0 +1,51 @@
+// QUOXON plan approval card (owner 2026-10-26 18:05: "i would deny based on the fact it's not even presenting a plan"):
+// an objective's "approve plan" item must list the plan's steps, and show the org the item really lives in.
+// Pure helpers plus one async enrich step; the card renders what this returns and nothing else.
+
+export const PLAN_STEPS_MAX = 8;
+/** Verbs that change things. Anything else reads as read-only (inspect, list, audit, report). */
+const CHANGES = /\b(upgrad\w*|updat\w*|restart\w*|redeploy\w*|deploy\w*|writ\w*|delet\w*|remov\w*|install\w*|migrat\w*|patch\w*|rollback|roll back|reboot\w*|creat\w*|apply|applies|rotat\w*|scal\w*|provision\w*|stop|start|kill|drop|reset|modify|modifies|change\w*|configur\w*)\b/i;
+export const changesThings = (title) => CHANGES.test(String(title || ''));
+
+/** Does this inbox item ask for approval of an objective's plan? */
+export const isPlanApproval = (it) => it?.payload?.source === 'objective_checkpoint'
+  && it?.payload?.checkpoint_type === 'plan_approval' && typeof it?.payload?.objective_id === 'string';
+
+/** Steps from an objective read: [{ n, title, agent, writes }]. Agent display name from `names` (id -> name), else the id. */
+export function stepsOf(objective, names = new Map()) {
+  const tasks = Array.isArray(objective?.tasks) ? objective.tasks : [];
+  return tasks.filter(t => t && t.title).map((t, i) => ({
+    n: i + 1, title: String(t.title), agent: t.agent_id ? String(names.get(t.agent_id) || t.agent_id) : null, writes: changesThings(t.title)
+  }));
+}
+
+/** Rows for the card: numbered lines plus "+N more" past the cap. Each row is a plain string. */
+export function planLines(steps, max = PLAN_STEPS_MAX) {
+  const list = Array.isArray(steps) ? steps : [];
+  const lines = list.slice(0, max).map(s => `${s.n}. ${s.writes ? '[changes]' : '[read-only]'} ${s.title}${s.agent ? ` · ${s.agent}` : ''}`);
+  if (list.length > max) lines.push(`+${list.length - max} more`);
+  return lines;
+}
+
+/**
+ * Attach { steps, orgId, orgName } as item._plan for a plan-approval item. Reads the objective once (cached by objective id
+ * in `cache`). Never throws: when the read fails the item is returned as it came and the card says the plan could not be loaded.
+ */
+export async function enrichPlanItem(item, { objectiveGet, agents = null, orgs = null, cache = new Map() } = {}) {
+  if (!isPlanApproval(item) || typeof objectiveGet !== 'function') return item;
+  const id = item.payload.objective_id;
+  if (!cache.has(id)) {
+    cache.set(id, (async () => {
+      try {
+        const o = await objectiveGet(id);
+        let names = new Map();
+        try { for (const a of (agents ? await agents() : []) || []) if (a?.agent_id && a.name) names.set(a.agent_id, a.name); } catch { /* ids stand in */ }
+        const orgId = item.org_id || o?.org_id || null;
+        let orgName = null;
+        try { orgName = orgId && orgs ? ((await orgs()) || []).find(x => x?.id === orgId)?.name || null : null; } catch { /* the short id stands in */ }
+        return { steps: stepsOf(o, names), orgId, orgName, loaded: true };
+      } catch (e) { cache.delete(id); return { steps: [], orgId: item.org_id || null, orgName: null, loaded: false, error: e?.message || 'failed' }; }
+    })());
+  }
+  return { ...item, _plan: await cache.get(id) };
+}

package/lib/quoxon/print.js

@@ -4,6 +4,7 @@
  * Exit codes: 0 completed, 2 held for approval, 3 interrupted, 4 auth, 5 unconfirmed
  * (stream closed without turn.finished), 1 other.
  */
+import { eventLine } from '../core/announce.js';
 import { textGate } from './events.js';
 import { streamFields, fallbackNote } from './model.js';
 import { connectOfferFor } from './connect.js';
@@ -46,7 +47,7 @@ export async function runPrint({ api, prompt, agent = 'quox', output = 'text', c
   const sum = { tools: 0, approvals: 0, receipts: [] };
   let convo = conversation, doneSession = null, status = null, text = '', sawApproval = false, errorMsg = null, authFail = false;
   const seen = new Set();
-  let offer = null, handoff = null;
+  let offer = null, handoff = null, objective = null;
   let gate = null;
   try {
     for await (const ev of api.stream({ turnId, message: prompt, agent: agent || 'quox', conversationId: conversation, context, ...streamFields(choice), ...(promptProfile ? { promptProfile } : {}), ...(timeoutS > 0 ? { turnBudgetMs: timeoutS * 1000 } : {}) }, ctrl.signal)) {
@@ -60,8 +61,10 @@ export async function runPrint({ api, prompt, agent = 'quox', output = 'text', c
       else if (ev.type === 'done' && !text && ev.full_response) text = ev.full_response;
       else if (ev.type === 'tool.started' && !seen.has(ev.call_id)) { seen.add(ev.call_id); sum.tools++; }
       else if (ev.type === 'tool.finished') { if (!seen.has(ev.call_id)) { seen.add(ev.call_id); sum.tools++; } if (ev.receipt?.ward_seq != null) sum.receipts.push(ev.receipt.ward_seq); }
+      else if (ev.type === 'quox_event') { if (output !== 'json') { const q = eventLine(ev); if (q) err(`${q}\n`); } } // QUOX-ANNOUNCE A2: stdout stays the answer
       else if (ev.type === 'approval.requested') { sawApproval = true; sum.approvals++; }
       else if (ev.type === 'approval.resolved') sawApproval = false;
+      else if (ev.type === 'turn.objective_suggested' && ev.objective_suggested?.goal) objective = ev.objective_suggested; // QUOXON objective offer
       else if (ev.type === 'turn.handoff_suggested' && ev.handoff_suggested?.agent) handoff = ev.handoff_suggested; // QUOXON handoff offer
       else if (ev.type === 'turn.finished') status = ev.status || 'completed';
       else if (ev.type === 'error') errorMsg = isConsentError(ev) ? consentPrintMessage(ev, profile) : (ev.error || 'stream error');
@@ -85,7 +88,7 @@ export async function runPrint({ api, prompt, agent = 'quox', output = 'text', c
   if (!status) status = authFail ? 'auth' : 'failed';
 
   if (output === 'json') {
-    out(JSON.stringify({ type: 'summary', status, turn_id: turnId, conversation_id: convo, duration_ms: Date.now() - t0, server_stopped: serverStopped, ...sum, ...(handoff ? { handoff_suggested: handoff } : {}) }) + '\n');
+    out(JSON.stringify({ type: 'summary', status, turn_id: turnId, conversation_id: convo, duration_ms: Date.now() - t0, server_stopped: serverStopped, ...sum, ...(handoff ? { handoff_suggested: handoff } : {}), ...(objective ? { objective_suggested: objective } : {}) }) + '\n');
   } else if (text) out(text.endsWith('\n') ? text : text + '\n');
   if (authFail) err(`Not signed in for chat. Run: quox login -p <profile>\n`);
   else if (code === EXIT.approval) err('Held for approval: approve it in the dashboard or with `quox` /approvals.\n');
@@ -93,6 +96,8 @@ export async function runPrint({ api, prompt, agent = 'quox', output = 'text', c
   else if (errorMsg) err(`quox: ${errorMsg}\n`);
   if (offer && code !== EXIT.ok) err(`${offer}\n`);
   // QUOXON handoff offer: no y/N here, so name the exact one-turn command (same question, same conversation).
-  if (handoff && output !== 'json' && code === EXIT.ok) err(`quox: ${handoff.reason ? `${String(handoff.reason).replace(/\s+$/, '')} ` : ''}${handoff.name || handoff.agent} can answer it: quox --print --agent ${handoff.agent}${convo ? ` --conversation ${convo}` : ''} ${JSON.stringify(prompt)}\n`);
+  // QUOXON objective offer: no y/N here, so name the exact command that makes it an objective.
+  if (objective && output !== 'json' && code === EXIT.ok) err(`quox: ${objective.reason ? `${String(objective.reason).replace(/\s+$/, '')} ` : ''}Run it until done: quox objective create ${JSON.stringify(objective.goal)} --checkpoint\n`);
+  else if (handoff && output !== 'json' && code === EXIT.ok) err(`quox: ${handoff.reason ? `${String(handoff.reason).replace(/\s+$/, '')} ` : ''}${handoff.name || handoff.agent} can answer it: quox --print --agent ${handoff.agent}${convo ? ` --conversation ${convo}` : ''} ${JSON.stringify(prompt)}\n`);
   return code;
 }

package/lib/quoxon/profileSwitch.js

@@ -23,6 +23,13 @@ export const switchAskLine = (profile, human) => askText('Switch?', {
   action: `switch this window to your login '${human}' (same conversation, attach, slot and groups)`,
 });
 
+/** The startup offer on an agent login (owner 2026-10-28): restart as the human profile; /profile lists the rest. */
+export const startupSwitchAskLine = (profile, human, others = 0) => askText(`Restart as you (${human})?`, {
+  title: `This window would run as the agent '${profile}'.`,
+  action: `restart this window as '${human}' (same directory, nothing else changes)`,
+  reason: others > 0 ? `${others} other signed-in profile${others === 1 ? '' : 's'}: /profile lists them` : '',
+});
+
 /** The ask card for a /slot name that does not exist (the near misses are said on the line above). */
 export const slotCreateAskLine = (nm) => askText('Create it?', { title: `No slot ${nm}.`, action: `create and hold slot ${nm}` });
 

package/lib/quoxon/promptHistory.js

@@ -6,6 +6,7 @@
 import { readFileSync, appendFileSync, writeFileSync, mkdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
+import { redactSecrets } from './secretShape.js';
 
 export const HISTORY_CAP = 500;
 export const defaultHistoryPath = (home = homedir()) => join(home, '.quox', 'history.jsonl');
@@ -22,7 +23,8 @@ export function fileHistory(path = defaultHistoryPath(), { cap = HISTORY_CAP } =
       return out.slice(-cap);
     } catch { return []; }
   };
-  const add = (text) => {
+  const add = (text0) => {
+    const text = redactSecrets(text0); // SECRET-GUARD: a value never reaches the file
     try {
       mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
       appendFileSync(path, JSON.stringify({ t: text }) + '\n', { mode: 0o600 });

package/lib/quoxon/qdragonFly.js

@@ -37,17 +37,18 @@ export function flyPose(ms) {
 /** The frame at `ms` since the pass began. still: the one fixed frame (mid-sky, wings raised). mono: shapes only. */
 /** The sky's size for a terminal `termRows` tall: the mid Q, or the small Q (headroom scaled to match) when the mid sky would
  *  not leave 10 rows for the transcript and composer. Never taller than max(12, termRows - 10). */
-export function flySky(termRows) {
-  const room = Math.max(12, (termRows || 40) - 10);
+export function flySky(termRows, chromeH = null) {
+  const room = chromeH == null ? Math.max(12, (termRows || 40) - 10) : (termRows || 40) - chromeH - 2; // measured chrome (app.js): the sky + margin + chrome must stay under the terminal height or Ink wipes the screen
   const fits = (size, top) => dragonLayout(120, { size, lm: 0, ty: top }).rows <= room;
-  if (fits(SIZE, TOP)) return { size: SIZE, top: TOP, bob: BOB };
+  if (fits(SIZE, TOP)) return { size: SIZE, top: TOP, bob: BOB, fits: true };
   const k = DSIZES.small / DSIZES[SIZE];
-  return { size: 'small', top: Math.round(TOP * k), bob: Math.max(1, Math.round(BOB * k)) };
+  const top = Math.round(TOP * k);
+  return { size: 'small', top, bob: Math.max(1, Math.round(BOB * k)), fits: chromeH == null || dragonLayout(120, { size: 'small', lm: 0, ty: top }).rows <= room };
 }
 
-export function flyFrame(ms, cols, { still = false, mono = false, theme = 'dark', termRows } = {}) {
+export function flyFrame(ms, cols, { still = false, mono = false, theme = 'dark', termRows, chromeH = null } = {}) {
   const t = still ? 0 : Math.max(0, Math.min(ms, FLY_PASS_MS));
-  const { size: SIZE, top: TOP, bob: BOB } = flySky(termRows);
+  const { size: SIZE, top: TOP, bob: BOB } = flySky(termRows, chromeH);
   const probe = dragonLayout(cols, { size: SIZE, lm: 0, ty: TOP });
   const rows = probe.rows;
   const xc = still ? cols / 2 : -SPAN + (cols + 2 * SPAN) * kf(t, [[0, 0], [FLY_PASS_MS, 1]]);

package/lib/quoxon/qmotion.js

@@ -11,6 +11,7 @@ import { helloCells, helloGradient, helloMs } from './qhello.js';
 import { mono, c, clip, isLight } from './theme.js';
 import { CLIPS, clipCells, clipCaption, eggCells, EGG_MS } from './qdragonScenes.js';
 import { reducedMotion } from './motion/clock.js';
+import { flySky } from './qdragonFly.js';
 import { FrameContext, useFrame } from './motion/frame.js';
 const isQuiet = () => reducedMotion(); // motion only (NO_COLOR is colour only; QGlyph falls back to the circled Q itself)
 import { termRows } from './term.js';
@@ -130,3 +131,19 @@ export function DragonLive({ cols, rows }) {
     ...cells.map((row, k) => h(Text, { key: k, wrap: 'truncate' }, ...cellNodes(row, `d${k}-`))),
     h(Text, { color: c('dim') }, clip(caption, Math.max(10, cols - 2))));
 }
+
+/** Rows the 15-row dragon clips need besides the chrome: the clip, its caption and the margin above it. */
+export const CLIP_ROWS = 17;
+/** Does an explicit /dragon <clip> fit? { ok } or { ok:false, note } (one line, never silent). Unknown size (null rows) is ok. */
+export function clipRoom(clipName, rows, chromeH = 10) {
+  if (!rows) return { ok: true };
+  const need = CLIP_ROWS + chromeH + 2;
+  return rows >= need ? { ok: true } : { ok: false, note: `${clipName} needs ${need} rows, you have ${rows}. Make the window taller.` };
+}
+/** Does /dragon-fly fit? Same shape as clipRoom; the smallest sky is 12 rows. */
+export function flyRoom(rows, chromeH = 10) {
+  if (!rows) return { ok: true };
+  if (flySky(rows, chromeH).fits) return { ok: true };
+  const need = 12 + 1 + chromeH + 2;
+  return { ok: false, note: `fly needs ${need} rows, you have ${rows}. Make the window taller.` };
+}