quoxcli 0.3.1 → 0.4.0

package/lib/dragon/select.js

@@ -0,0 +1,72 @@
+/**
+ * Dragon companions (Lucid, Hyperion, Seer, Sentinel, Drago, Cipher): which one, whether to show it, and where its art lives.
+ * Pure. The art, animation and activity reducer stay in quoxai/dragonlab (integration/companions-v1);
+ * Quox only chooses and loads. See docs/dragons/COMPANION-UX.md for the decisions behind each rule.
+ */
+import { resolve, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** The dragonlab art bundled with the CLI (cli/vendor/dragonlab, refreshed by scripts/sync-dragonlab.sh). */
+export const VENDORED_DRAGONLAB = fileURLToPath(new URL('../../vendor/dragonlab', import.meta.url));
+
+/** Registry agent ids (and display names) to approved dragon. Others, including quox/commanderq, get none. */
+export const AGENT_DRAGON = Object.freeze({ lucid: 'lucid', hyperion: 'hyperion', atlas: 'hyperion', seer: 'seer', sentinel: 'sentinel', warden: 'sentinel', security_lead: 'drago', drago: 'drago', cipher: 'cipher' });
+export const COMPANION_MODES = ['on', 'greeting', 'off'];
+/** One-line change: the owner decides this after his Mac check (docs/dragons/COMPANION-UX.md section 4). */
+export const DEFAULT_COMPANION_MODE = 'on';
+
+export function dragonForAgent(agent) {
+  const k = String(agent ?? '').trim().toLowerCase();
+  return Object.hasOwn(AGENT_DRAGON, k) ? AGENT_DRAGON[k] : null;
+}
+
+export function normaliseMode(v) {
+  const s = String(v ?? '').trim().toLowerCase();
+  return COMPANION_MODES.includes(s) ? s : null;
+}
+
+/** env QUOX_DRAGON_COMPANION beats the saved profile setting beats the default. */
+export function companionMode(settings = {}, env = process.env) {
+  return normaliseMode(env.QUOX_DRAGON_COMPANION) || normaliseMode(settings?.dragonCompanion) || DEFAULT_COMPANION_MODE;
+}
+
+/**
+ * Motion policy from the existing Quox switches. lite or a dumb terminal = off; reduced motion = still
+ * (no entrance, every channel frozen, captions still update); NO_COLOR = mono render.
+ */
+export function motionPolicy(env = process.env) {
+  const lite = Boolean(env.QUOX_TUI_LITE) || env.TERM === 'dumb';
+  const quiet = env.QUOX_REDUCED_MOTION === '1' || String(env.QUOX_MOTION || '').trim().toLowerCase() === 'quiet';
+  return { off: lite, still: quiet, mono: 'NO_COLOR' in env };
+}
+
+/**
+ * Where dragonlab lives: QUOX_DRAGONLAB beats the saved quoxon.dragonLab beats `bundled` (hosts pass
+ * VENDORED_DRAGONLAB). With no bundled path and no override, null = art not available.
+ */
+export function dragonLabRoot(settings = {}, env = process.env, bundled = null) {
+  const p = env.QUOX_DRAGONLAB || settings?.dragonLab;
+  if (typeof p === 'string' && p.trim()) return resolve(p.trim());
+  return bundled ? resolve(bundled) : null;
+}
+export const companionModuleFile = (root, id) => join(root, 'integration', 'companions-v1', `${id}.mjs`);
+export const viewModuleFile = (root) => join(root, 'integration', 'companions-v1', 'view.mjs');
+
+/**
+ * Everything a host needs, or { enabled:false, why } (the reason is what `/dragon companion status` prints).
+ * `exists` is injected so this stays pure.
+ */
+export function companionPlan({ agent, settings = {}, env = process.env, isTTY = true, exists = () => true, bundled = null }) {
+  const mode = companionMode(settings, env), policy = motionPolicy(env);
+  const id = dragonForAgent(agent);
+  const no = (why) => ({ enabled: false, why, mode, id });
+  if (mode === 'off') return no('companion is off');
+  if (!isTTY) return no('output is not a terminal');
+  if (policy.off) return no('QUOX_TUI_LITE or a dumb terminal turns decoration off');
+  if (!id) return no(agent ? `${agent} has no approved dragon` : 'no agent attached');
+  const root = dragonLabRoot(settings, env, bundled);
+  if (!root) return no('dragon art not found (the bundled copy is missing; set QUOX_DRAGONLAB or quoxon.dragonLab to a dragonlab checkout)');
+  const file = companionModuleFile(root, id);
+  if (!exists(file) || !exists(viewModuleFile(root))) return no(`dragon art not found at ${root}`);
+  return { enabled: true, mode, id, root, file, viewFile: viewModuleFile(root), still: policy.still, mono: policy.mono, persist: mode === 'on' };
+}

package/lib/evidence/bundleExport.js

@@ -0,0 +1,47 @@
+/**
+ * Fetch one conversation's signed evidence zip, write it, verify what was written. One implementation for
+ * `quox evidence bundle` and the TUI's /evidence. The server scopes by the caller's org and refuses anything else.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveEndpoint } from '../api/endpoints.js';
+import { verifyEvidenceBundle } from './bundleVerify.js';
+
+export function defaultBundlePath(corr, now = new Date()) {
+  const ts = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const safe = String(corr).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 60);
+  return path.join(os.homedir(), 'quox-evidence', `${safe}-${ts}.zip`);
+}
+
+/** -> the id of the caller's newest chat conversation, or null. */
+export async function newestConversationId(client) {
+  const ep = resolveEndpoint('conversations.chat.list');
+  const data = await client.get(ep.path, { service: ep.service, query: { limit: 1 } });
+  const c = (data && data.conversations && data.conversations[0]) || null;
+  return c ? c.id : null;
+}
+
+/**
+ * @returns {Promise<{ path: string, corr: string, bytes: number, envelopes: number, receipts: number, verify: object }>}
+ * @throws Error with the HTTP status named when the server refuses (404 = not your conversation or no evidence).
+ */
+export async function exportConversationBundle({ client, corr, out, now = new Date() }) {
+  const ep = resolveEndpoint('evidence.bundle', { corr });
+  const res = await client.get(ep.path, { service: ep.service, query: { format: 'zip' }, raw: true, timeout: 120000 });
+  if (!res.ok) {
+    let detail = res.statusText;
+    try { const j = await res.json(); detail = j.error || JSON.stringify(j); } catch { /* keep statusText */ }
+    const e = new Error(res.status === 404
+      ? `No evidence for conversation ${corr} in your org (HTTP 404: ${detail}). Tool calls made before this fix are filed under per-command ids and are not part of the conversation.`
+      : `Evidence bundle failed: HTTP ${res.status}: ${detail}`);
+    e.status = res.status;
+    throw e;
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  const file = path.resolve(out || defaultBundlePath(corr, now));
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, buf);
+  const verify = await verifyEvidenceBundle(fs.readFileSync(file)); // what was written, not what was sent
+  return { path: file, corr, bytes: buf.length, envelopes: verify.manifest?.counts?.envelopes ?? 0, receipts: verify.manifest?.counts?.ward_receipts ?? 0, receiptRows: verify.receipts || [], verify };
+}

package/lib/evidence/bundleVerify.js

@@ -0,0 +1,77 @@
+/**
+ * Offline verifier for a conversation evidence bundle (collector lib/conversationEvidenceBundle.js).
+ * Needs nothing but the zip: file hashes against manifest.json, the envelope list hash, the Ed25519 signature
+ * over the canonical manifest, and the counts. Never reaches the network. The collector builds; this only checks.
+ */
+import crypto from 'node:crypto';
+import JSZip from 'jszip';
+
+const sha256 = (buf) => crypto.createHash('sha256').update(buf).digest('hex');
+
+// Same canonical form as services/collector/lib/bundleSigner.js (sorted keys at every level, no whitespace).
+export function canonicalize(val) {
+  if (val === null || val === undefined) return JSON.stringify(val);
+  if (typeof val !== 'object') return JSON.stringify(val);
+  if (Array.isArray(val)) return `[${val.map((v) => canonicalize(v)).join(',')}]`;
+  const keys = Object.keys(val).filter((k) => val[k] !== undefined).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalize(val[k])}`).join(',')}}`;
+}
+
+const SPKI_ED25519_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
+
+export function envelopesHash(envelopes) {
+  return sha256(Buffer.from(JSON.stringify(
+    envelopes.map((e) => ({ id: e.id ?? null, ts: e.ts ?? null, intent: e.intent ?? null, corr: e.corr ?? null, reply_to: e.reply_to ?? null, from: e.from ?? null, to: e.to ?? null })),
+  ), 'utf8'));
+}
+
+/**
+ * @param {Buffer|Uint8Array} zipBytes
+ * @returns {Promise<{ ok: boolean, checks: {name:string, ok:boolean, detail?:string}[], manifest: object|null, signature: object|null }>}
+ */
+export async function verifyEvidenceBundle(zipBytes) {
+  const checks = [];
+  const add = (name, ok, detail) => { checks.push({ name, ok: !!ok, ...(detail ? { detail } : {}) }); return !!ok; };
+  let zip;
+  try { zip = await JSZip.loadAsync(zipBytes); } catch (e) {
+    add('zip readable', false, e.message);
+    return { ok: false, checks, manifest: null, signature: null };
+  }
+  const read = async (name) => { const f = zip.file(name); return f ? Buffer.from(await f.async('nodebuffer')) : null; };
+  const manifestBuf = await read('manifest.json');
+  const sigBuf = await read('signature.json');
+  if (!add('manifest.json present', manifestBuf)) return { ok: false, checks, manifest: null, signature: null };
+  if (!add('signature.json present', sigBuf)) return { ok: false, checks, manifest: null, signature: null };
+  let manifest; let signature;
+  try { manifest = JSON.parse(manifestBuf.toString('utf8')); signature = JSON.parse(sigBuf.toString('utf8')); } catch (e) {
+    add('manifest and signature parse', false, e.message);
+    return { ok: false, checks, manifest: null, signature: null };
+  }
+
+  // 1. signature over the canonical manifest
+  try {
+    const signed = Buffer.from(canonicalize(manifest), 'utf8');
+    const pub = crypto.createPublicKey({ key: Buffer.concat([SPKI_ED25519_PREFIX, Buffer.from(signature.public_key, 'base64')]), format: 'der', type: 'spki' });
+    const sigOk = signature.alg === 'ed25519' && crypto.verify(null, signed, pub, Buffer.from(signature.signature, 'base64'));
+    add('signature (Ed25519 over the manifest)', sigOk, sigOk ? `key ${signature.key_id}` : 'signature does not match the manifest');
+    add('signed manifest hash', signature.manifest_sha256 === sha256(signed), signature.manifest_sha256 === sha256(signed) ? undefined : 'manifest_sha256 differs');
+  } catch (e) { add('signature (Ed25519 over the manifest)', false, e.message); }
+
+  // 2. every listed file hashes to what the (signed) manifest says
+  const bufs = {};
+  for (const [name, want] of Object.entries(manifest.files || {})) {
+    const b = await read(name);
+    bufs[name] = b;
+    add(`file ${name}`, b && sha256(b) === want, !b ? 'missing from the zip' : (sha256(b) === want ? undefined : 'hash differs from the manifest'));
+  }
+
+  // 3. envelope list hash + counts
+  let envelopes = [];
+  try { envelopes = JSON.parse((bufs['envelopes.json'] || Buffer.from('[]')).toString('utf8')); } catch { envelopes = []; }
+  add('envelope list hash', envelopesHash(envelopes) === manifest.envelopes_sha256, envelopesHash(envelopes) === manifest.envelopes_sha256 ? undefined : 'recomputed hash differs');
+  add('envelope count', envelopes.length === manifest.counts?.envelopes, `${envelopes.length} in envelopes.json, ${manifest.counts?.envelopes} in the manifest`);
+  let receipts = [];
+  try { receipts = JSON.parse((bufs['ward-receipts.json'] || Buffer.from('[]')).toString('utf8')); } catch { receipts = []; }
+  add('receipt count', receipts.length === manifest.counts?.ward_receipts, `${receipts.length} in ward-receipts.json, ${manifest.counts?.ward_receipts} in the manifest`);
+  return { ok: checks.every((c) => c.ok), checks, manifest, signature, receipts };
+}

package/lib/quoxon/EXTENSIONS.md

@@ -0,0 +1,23 @@
+# quoxon extensions
+
+Optional npm packages that add a surface to quoxon (a MIDI pad deck, a status bar). Core ships none and knows none by name.
+
+**Loading.** Nothing loads unless the package is installed AND listed in `~/.quox/extensions.json`
+(`quox ext add|remove|list <pkg>`; `/ext list|on|off <name>` inside quoxon). Install with `npm i -g <pkg>`.
+Resolution order: env `QUOX_EXT_<NAME>_MODULE` (name upper-cased, non-alphanumerics to `_`), a local `import(name)`,
+then the global npm root (`dirname(execPath)/../lib/node_modules` first, then `npm root -g` once, cached).
+`/ext list` names where each was found; a miss lists where it looked.
+
+**Module.** Default export (or the module itself):
+`{ name, version, commands?: [{ name: '/deck', help, run(args, ctx) }], create({ emit, log, settings }) -> { update(state), close() } }`.
+Its slash commands exist only while it is loaded. `run` may return a string or `{ text, tone }`.
+
+**State** (`update(state)`, deduped, at most 1/s):
+`{ org:{id,name}, approvals:{count, items:[{n,id,risk:'low'|'high',title,agent,options?:[{key,label}]}]}, health:{<name>:'ok'|'warn'|'down'},
+loops:[{id,title,turn,max,status}], fleet:{total,online,offline,warn,hosts:[{name,state:'ok'|'warn'|'down'}] (max 16)},
+evidence:{chain:'ok'|'broken'|'unknown', checked_at}, sessions:{active}, event?:{kind,text,level} }`.
+`fleet` comes from a 30 s poll of the host list while an extension is loaded. `evidence.chain` is `unknown` until quoxon holds a chain status.
+
+**emit.** `{type:'open_approval', n}` opens approval n; `{type:'pick', n, option}` only fills the composer with the
+answer command (the user presses Enter, high risk still needs the step-up PIN); `{type:'alert_ack'}` clears the event.
+An extension can never resolve an approval. emit is ignored once the extension is unloaded.

package/lib/quoxon/api.js

@@ -16,6 +16,7 @@ import { normChoice } from './model.js';
 import { normPrefs as normModelPrefs } from './modelPrefs.js';
 import { createRowsStore } from './rowsStore.js';
 import { createObjectsApi } from './objects/fetch.js';
+import { createDragonReads } from './dragonReads.js';
 import { createKillerApi } from './slash/killerApi.js';
 import { createUndoOps } from './slash/undoApi.js';
 import { resolveDashboardBase, resolveCollectorBase, detectLanIp } from './hostUrls.js';
@@ -26,6 +27,8 @@ import { runVmCommand } from '../core/vmTui.js';
 import { fetchActivity, heldLines } from '../core/hyperion.js';
 import { createPeekFetchers, peekId } from '../core/peek.js';
 import { askAside } from '../core/aside.js';
+import { exportConversationBundle } from '../evidence/bundleExport.js';
+import { addActionItem, listBoard, moveActionItem } from '../core/actionItems.js';
 
 const missing = (e) => e?.status === 404 || e?.status === 405 || e?.status === 501;
 /** Server steer refusal label -> client reason. Unknown labels are 'ambiguous', never "finished". */
@@ -71,11 +74,35 @@ const vaultFailure = (e) => ({ ok: false, status: e?.status, message: e?.message
 const slotsUnlicensed = (e) => e?.status === 403 && /not licen[cs]ed/i.test(`${e?.code || ''} ${e?.body?.error || ''} ${e?.message || ''}`);
 
 /** PRESENCE: only a person at a real terminal is "back". --print, pipes, proof runs and agents are not. */
+const NOTES_OFF = 'NotesQ is not available for this org. Ask an org admin to enable the NotesQ plugin (dashboard, Plugins), or check `quox notes ls` in a terminal.';
+export function noteParts(text) {
+  const t = String(text || '').trim();
+  const first = t.split('\n')[0].trim();
+  const title = first.length > 60 ? `${first.slice(0, 60).trimEnd()}…` : first;
+  return { title, markdown: `# ${title}\n\n${t}\n` };
+}
+async function createNoteFrom(client, text) {
+  const { title, markdown } = noteParts(text);
+  try {
+    const ep = resolveEndpoint('notesq.notes.create');
+    const d = await client.post(ep.path, { service: ep.service, retries: 0, body: { scope: 'org', markdown, properties: {} } });
+    const n = d?.note || {};
+    if (!n.id) return { ok: false, message: 'NotesQ answered without a note id, so nothing is confirmed saved. Check quox notes ls.' };
+    return { ok: true, id: n.id, title: n.title || title };
+  } catch (e) {
+    if (e?.status === 402) return { ok: false, message: 'NotesQ is not licensed for this org. ' + NOTES_OFF };
+    if (e?.status === 403 || e?.status === 404 || e?.status === 503) return { ok: false, message: NOTES_OFF };
+    return { ok: false, message: `Could not save the note: ${e?.message || 'request failed'}${e?.status ? ` (HTTP ${e.status})` : ''}.` };
+  }
+}
 export function isInteractiveHuman({ stdin = process.stdin, stdout = process.stdout, env = process.env } = {}) {
   return Boolean(stdin?.isTTY && stdout?.isTTY) && !env.CI;
 }
 
-export function createApi({ client, config, auth, windowOrg = null, reattachBackoff = REATTACH_BACKOFF_MS }) {
+/** A one-line title within the tasks service's 200 character cap. */
+const clipTitle = (g) => { const t = String(g ?? '').replace(/\s+/g, ' ').trim(); return t.length > 200 ? `${t.slice(0, 199)}…` : t; };
+
+export function createApi({ client, config, auth, windowOrg = null, clientForOrg = null, reattachBackoff = REATTACH_BACKOFF_MS }) {
   let holderSessionFn = null;
   const orgId = () => { try { return auth.getOrgId(); } catch { return null; } };
   const rowsStore = createRowsStore({ client, config, orgId });
@@ -147,9 +174,13 @@ export function createApi({ client, config, auth, windowOrg = null, reattachBack
     ...createKillerApi({ client }),
     orgId,
     undoOps: createUndoOps({ client, orgId }), // /undo
+    /** /note: same call as `quox notes new` (org scope). -> { ok, id, title } | { ok:false, message } */
+    createNote: (text) => createNoteFrom(client, text),
     userId,
     /** /peek <id>: the same lookup as `quox peek`, in this window's org. -> peekId result */
     peek: (id) => peekId(id, createPeekFetchers({ client, orgId })),
+    /** /evidence, /ward: the signed bundle of one conversation, written to ~/quox-evidence (same export as `quox evidence bundle`). */
+    evidenceExport: (corr) => exportConversationBundle({ client, corr }),
     /** /aside: a no-tools, no-conversation question (core/aside.js). turns = recent exchanges, read-only context. */
     aside: (question, turns = []) => askAside(client, { question, turns }),
     /** @mention hosts: the Bastion inventory (same read as `quox fleet hosts`). -> [{ id, group, health }] */
@@ -158,6 +189,25 @@ export function createApi({ client, config, auth, windowOrg = null, reattachBack
       const d = await client.get(ep.path, { service: ep.service, retries: 0, timeout: 8000 });
       return (listOf(d, 'hosts') || []).map(h => ({ id: h.id, group: h.group || '', health: h.status?.health || '' }));
     },
+    /** QUOXON objective offer: `quox objective create <goal> --checkpoint` + `start` (same endpoints). -> { id, status } */
+    async startObjective(goal, loop = null) {
+      const c = resolveEndpoint('objectives.create');
+      // QLOOP: a loop offer creates a LOOP (server-derived scope + goal), never a plan under the loop's name.
+      const body = loop ? { title: String(goal).slice(0, 200), description: String(goal), execution_mode: 'loop', capability_scope: loop.capability_scope, goal_condition: loop.goal_condition,
+        ...(loop.until ? { until: loop.until } : {}), ...(loop.every_seconds ? { every_seconds: loop.every_seconds } : {}), ...(loop.max_iterations ? { max_iterations: loop.max_iterations } : {}), ...(loop.max_duration_seconds ? { max_duration_ms: loop.max_duration_seconds * 1000 } : {}), ...(Array.isArray(loop.done_check) && loop.done_check.length ? { done_check: loop.done_check } : {}) }
+        : { title: clipTitle(goal), description: String(goal), checkpoint_after_each_task: true }; // the tasks service caps a title at 200; the whole ask rides in the description
+      const made = await client.post(c.path, { service: c.service, body });
+      if (!made?.id) throw new Error('the server answered without an objective id');
+      const st = resolveEndpoint('objectives.start', { id: made.id });
+      const started = await client.post(st.path, { service: st.service, body: {} });
+      return { id: made.id, status: started?.status || 'started' };
+    },
+    /** An objective with its tasks (the same read as `quox objective get`), for the chat's report-back. */
+    async objectiveGet(id) {
+      const ep = resolveEndpoint('objectives.get', { id: encodeURIComponent(id) });
+      const d = await client.get(ep.path, { service: ep.service, retries: 0, timeout: 8000 });
+      return d?.objective || d;
+    },
     /** @mention tasks: the newest objectives (one read, cached by the composer for the session). -> [{ id, title, status }] */
     async mentionTasks() {
       const ep = resolveEndpoint('objectives.list');
@@ -203,6 +253,7 @@ export function createApi({ client, config, auth, windowOrg = null, reattachBack
     },
     /** Inline object views (objects/): skill, workflow, crystal, agent, memory, rules, proof, reconcile. */
     objects: createObjectsApi({ client, orgId, profile: config?._effectiveProfile || null }),
+    dragonReads: createDragonReads({ client }), // the companion dragons' jobs: bounded read-only reads (dragonReads.js)
     /** /model choice persisted on the active profile ({ provider, model? } only, never a key); null = auto. */
     modelChoice() { try { return normChoice(config.getActiveProfile?.()?.chat_model); } catch { return null; } },
     setModelChoice(choice) {
@@ -455,6 +506,27 @@ export function createApi({ client, config, auth, windowOrg = null, reattachBack
       try { const r = await fetch(`${String(base).replace(/\/+$/, '')}/install`, { method: 'GET', signal: ctl.signal }); try { await r.body?.cancel?.(); } catch { /* drained */ } return { ok: r.ok, status: r.status }; }
       catch { return null; } finally { clearTimeout(t); }
     },
+    /** TUI-STATUS: the registered server this quox runs on -> { name, role, remote } | null (unregistered or any failure). */
+    async serverChip() {
+      const { resolveServerChip } = await import('./serverChip.js');
+      const { loadRegistry } = await import('../server/devServers.js');
+      let registry = { servers: {} };
+      try { registry = { servers: (await loadRegistry({ client })).servers }; } catch { /* unreadable registry: no purpose shown */ }
+      return resolveServerChip({
+        registry,
+        url: config.getActiveProfile?.()?.url || config.getBaseUrl?.() || null,
+        listHosts: async () => { const ep = resolveEndpoint('v1.fleet.hosts.list'); const d = await client.get(ep.path, { service: ep.service, retries: 0, timeout: 5000 }); return d?.hosts || d; }
+      });
+    },
+    /** DEVFLEET: the registered dev servers (same rows as `quox server list`) -> rows[]; throws on a Bastion read failure. */
+    async devServers() {
+      const [{ loadRegistry, buildRows, hereIdentity }] = [await import('../server/devServers.js')];
+      const ep = resolveEndpoint('v1.fleet.hosts.list');
+      const d = await client.get(ep.path, { service: ep.service, retries: 0, timeout: 5000 });
+      const hosts = d?.hosts || d;
+      if (!Array.isArray(hosts)) throw new Error('unexpected response');
+      { const reg = await loadRegistry({ client }); return buildRows(hosts, { servers: reg.servers, defaults: reg.defaults }, hereIdentity()); }
+    },
     serverUrl() { try { return new URL(config.getServiceUrl('collector')).origin; } catch { return null; } },
     /** /config settings on the active profile. */
     settings() { try { const q = config.getActiveProfile?.()?.quoxon; return q && typeof q === 'object' ? { ...q } : {}; } catch { return {}; } },
@@ -503,6 +575,29 @@ export function createApi({ client, config, auth, windowOrg = null, reattachBack
       if (!rows) throw new Error('unexpected response');
       return rows.filter(r => r.is_enabled !== false && r.is_enabled !== 0).map(r => r.plugin_id).filter(Boolean);
     },
+    /** /todo: add an Action Tracker item as the logged-in user (the same core as `quox actions add`). Throws on failure. -> the item. */
+    async todoAdd(text) { return addActionItem(client, { title: text }); },
+    /** /todos: the whole board { backlog, doing, done }, every page. Throws on failure so it never reads as "none". */
+    async todoList() { return listBoard(client); },
+    /** /todo move: move one item (real id) to todo, doing or done. -> the item. */
+    async todoMove(id, status) { return moveActionItem(client, id, status); },
+    /** -> [{ plugin_id, version, is_enabled, ... }] every plugin installed for the org (GET plugins.list, as `quox plugin list`). Throws on failure. */
+    async pluginList() {
+      const id = orgId();
+      if (!id) throw new Error('no org');
+      const ep = resolveEndpoint('plugins.list', { orgId: id });
+      const rows = listOf(await client.get(ep.path, { service: ep.service, retries: 0 }), 'plugins', 'data', 'items');
+      if (!rows) throw new Error('unexpected response');
+      return rows;
+    },
+    /** One installed plugin's record (GET plugins.get, as `quox plugin get`), or null when unknown (404). */
+    async pluginGet(pluginId) {
+      const id = orgId();
+      if (!id) throw new Error('no org');
+      const ep = resolveEndpoint('plugins.get', { orgId: id, pluginId });
+      try { const d = await client.get(ep.path, { service: ep.service, retries: 0 }); return d?.plugin || d; }
+      catch (e) { if (e?.status === 404) return null; throw e; }
+    },
     /** Fleet hosts already connected (tips skip the QuoxAgent tip when > 0). GET agents list; throws on failure so a failure never reads as "no hosts". */
     async hostCount() {
       const ep = resolveEndpoint('v1.agents.list');
@@ -524,16 +619,38 @@ export function createApi({ client, config, auth, windowOrg = null, reattachBack
      */
     /** SLOTS-REPLY2: the window registers how to name its checkout session; slotSay then sends it as holder_session. */
     bindHolderSession(fn) { holderSessionFn = typeof fn === 'function' ? fn : null; },
-    async slotSay(name, text, { from = null, fast = false, roomSession = null, fromSlot = null, holderSession = holderSessionFn ? holderSessionFn() : null } = {}) {
-      const ep = resolveEndpoint('v1.slots.say', { name });
-      try {
+    async slotSay(name, text, { from = null, fast = false, roomSession = null, fromSlot = null, holderSession = holderSessionFn ? holderSessionFn() : null, anyOrg = true } = {}) {
+      const send = async (cl, oid) => {
+        const ep = resolveEndpoint('v1.slots.say', { name });
         // SLOTS-REPLY: fromSlot is this window's held slot, its reply address (the server verifies the hold).
-        const d = await client.post(ep.path, { service: ep.service, retries: 0, body: { text, org_id: orgId(), ...(roomSession ? { room_session: roomSession } : from ? { from } : {}), ...(!roomSession && fromSlot ? { from_slot: fromSlot } : {}), ...(!roomSession && holderSession ? { holder_session: holderSession } : {}), ...(fast ? { bridge_report: false } : {}) } });
+        const d = await cl.post(ep.path, { service: ep.service, retries: 0, body: { text, org_id: oid, ...(roomSession ? { room_session: roomSession } : from ? { from } : {}), ...(!roomSession && fromSlot ? { from_slot: fromSlot } : {}), ...(!roomSession && holderSession ? { holder_session: holderSession } : {}), ...(fast ? { bridge_report: false } : {}) } });
         return { ok: true, message: d?.message || null, roomPending: d?.room_pending === true, presence: d?.presence || null, humanPresence: d?.human_presence || null };
-      } catch (e) {
+      };
+      const fail = (e) => {
         if (slotsUnlicensed(e)) return { ok: false, unlicensed: true, status: 403, message: SLOTS_UNLICENSED };
         return { ok: false, message: e?.status === 404 ? `no slot named ${name}` : (e?.message || 'failed'), status: e?.status || null };
+      };
+      let first;
+      try { return await send(client, orgId()); } catch (e) { first = fail(e); }
+      // HITL-INBOX-BAR: a window in another org cannot see a slot that lives in the profile's home org. Same user, same
+      // sessions (not a cross-tenant leak): try the home org, then each of the user's orgs, each on a token for THAT org.
+      if (!anyOrg || first.status !== 404 || !clientForOrg) return first;
+      const tried = new Set([orgId()]);
+      const order = [];
+      try { const home = config.getAuth?.()?.org_id; if (home) order.push(home); } catch { /* no home org known */ }
+      try {
+        const oe = resolveEndpoint('orgs.list'); const d = await client.get(oe.path, { service: oe.service });
+        for (const o of (Array.isArray(d) ? d : (d?.organizations || d?.orgs || d?.data || []))) if (o?.id) order.push(o.id);
+      } catch { /* the home org alone */ }
+      for (const oid of order) {
+        if (tried.has(oid)) continue; tried.add(oid);
+        try {
+          const cl = await clientForOrg(oid);
+          const r = await send(cl, oid);
+          return { ...r, viaOrgId: oid };
+        } catch (e) { const f = fail(e); if (f.status !== 404) return { ...f, viaOrgId: oid }; } // the slot is there but refused: that is the real answer
       }
+      return first;
     },
     /** QUOXON-BROADCAST: fan a message out to the org's held slots. -> { ok:true, data } | { ok:false, message, status }. */
     async slotBroadcast({ text, slots = null, priority = 'normal', ack = false, from = null } = {}) {
@@ -563,6 +680,18 @@ export function createApi({ client, config, auth, windowOrg = null, reattachBack
       const ep = resolveEndpoint('v1.slots.broadcast.ack', { id });
       try { return { ok: true, data: await client.post(ep.path, { service: ep.service, retries: 0, body: { slot, org_id: orgId() } }) }; } catch (e) { return { ok: false, message: e?.message || 'failed', status: e?.status || null }; }
     },
+    /** QLOOP-LIVE: the org's loops, newest first (GET /api/v1/loops) -> { loops:[{ objective_id, title, state, created_at }] }. */
+    async loopList() {
+      return client.get('/api/v1/loops', { service: 'collector', retries: 0, timeout: 8000, query: { limit: 20 } });
+    },
+    /** QLOOP-LIVE: one loop's snapshot (GET /api/v1/loops/:id). Throws on failure (the card decides what a failure means). */
+    async loopSnapshot(id) {
+      return client.get(`/api/v1/loops/${encodeURIComponent(id)}`, { service: 'collector', retries: 0, timeout: 8000 });
+    },
+    /** QLOOP-LIVE: one loop's events (SSE; ?since resumes). Yields { event_seq, type, ... }; ends after loop.finished or a drop. */
+    async *loopEvents(id, { since = null } = {}, signal) {
+      yield* client.stream(`/api/v1/loops/${encodeURIComponent(id)}/events`, { service: 'collector', query: { since }, signal, untilClose: true });
+    },
     /** QUOXON-MESH: the slot's live messages (SSE). Yields { type: 'connected' | 'slot.message' | 'reconnect' }. */
     async *slotStream(name, { since = null, excludeFrom = null, session = null } = {}, signal) {
       const ep = resolveEndpoint('v1.slots.stream', { name });
@@ -678,6 +807,20 @@ export function createApi({ client, config, auth, windowOrg = null, reattachBack
       if (!windowOrg) { const e = new Error('Org switching is not available in this mode.'); e.code = 'no_window_org'; throw e; }
       return windowOrg.switchTo(targetId);
     },
+    /**
+     * "also make default" from the /org picker: the same profile-wide change as `quox org switch <org>` in a shell
+     * (moves the shared session and rewrites the profile's stored org + token). This window's own org is untouched.
+     */
+    async makeOrgDefault(targetId) {
+      const ep = resolveEndpoint('auth.switch-org');
+      const data = await client.post(ep.path, { service: ep.service, body: { org_id: targetId } });
+      if (!data?.org?.id) { const e = new Error('The server did not confirm the switch.'); e.code = 'switch_failed'; throw e; }
+      const a = config.getAuth() || {};
+      a.org_id = data.org.id; a.org_name = data.org.name; a.org_slug = data.org.slug; a.org_role = data.role;
+      if (data.access_token) a.access_token = data.access_token;
+      config.setAuth(a);
+      return { id: data.org.id, name: data.org.name };
+    },
     /** The window's own org id when it differs from the profile's (carried across /restart), else null. */
     windowOrgId: () => windowOrg?.current()?.id || null,
     /** -> [{ id, name, description, edition, version, decayState }] ; the org's QSKL procedural skills (read-only list; Crystals are a separate store). */
@@ -823,6 +966,31 @@ export function createApi({ client, config, auth, windowOrg = null, reattachBack
       }
     },
     /** /connect status: the org vault list (the only source a user can read). -> { ok:true, rows } | { ok:false, error }. */
+    /** LAZY-AI-CLI: which vendor CLIs (claude-code, codex) this server has. Never throws. */
+    async providerCliStatus() {
+      const ep = resolveEndpoint('v1.providers.cli.status');
+      try {
+        const d = await client.get(ep.path, { service: ep.service, retries: 0 });
+        return Array.isArray(d?.tools) ? { ok: true, tools: d.tools } : { ok: false, error: 'unexpected response' };
+      } catch (e) { return { ok: false, status: e?.status, missing: missing(e), error: e?.status ? `HTTP ${e.status} ${e.message || ''}`.trim() : (e?.message || 'failed') }; }
+    },
+    /** The install plan: source, exact package + version, download size. Instance admin only (403 otherwise). Never throws. */
+    async providerCliPlan(tool) {
+      const ep = resolveEndpoint('v1.providers.cli.plan', { tool });
+      try { const d = await client.get(ep.path, { service: ep.service, retries: 0 }); return d?.ok ? d : { ok: false, error: d?.message || 'unexpected response' }; }
+      catch (e) { return { ok: false, status: e?.status, missing: missing(e), error: e?.body?.message || e?.message || 'failed' }; }
+    },
+    /** Start an install job (the server audits it). Never throws. */
+    async providerCliInstall(tool, { approvalId = null } = {}) {
+      const ep = resolveEndpoint('v1.providers.cli.install', { tool });
+      try { return await client.post(ep.path, { service: ep.service, body: approvalId ? { approval_id: approvalId } : {}, retries: 0 }); }
+      catch (e) { return { ok: false, status: e?.status, error: e?.body?.message || e?.message || 'failed' }; }
+    },
+    async providerCliJob(id) {
+      const ep = resolveEndpoint('v1.providers.cli.job', { id });
+      try { return await client.get(ep.path, { service: ep.service, retries: 0 }); }
+      catch (e) { return { state: 'unknown', error: e?.message || 'failed', status: e?.status }; }
+    },
     async connections() {
       try {
         const ep = resolveEndpoint('vault.list', { orgId: orgId() });
@@ -905,6 +1073,24 @@ export function createApi({ client, config, auth, windowOrg = null, reattachBack
     /** /hyperion: held VMs and who holds them, one line each (read only, GET /api/v1/proxmox/activity). */
     async hyperion() { const data = await fetchActivity(client); return { lines: heldLines(data), tone: data.nodes_error || data.pool_error ? 'warn' : undefined }; },
     approvals: listApprovals,
+    /** HITL-INBOX-BAR: the owner's latest inbox items (any kind, active), newest first. Throws on failure, never reads as empty. */
+    async inboxItems({ limit = 30 } = {}) {
+      const ep = resolveEndpoint('inbox.list', { orgId: orgId() });
+      const data = await client.get(ep.path, { service: ep.service, query: { limit } });
+      const items = data?.items || data?.data || data || [];
+      return Array.isArray(items) ? items : [];
+    },
+    /** One inbox item in full (the server marks it read for this user as a side effect). */
+    async inboxItem(itemId) {
+      const ep = resolveEndpoint('inbox.get', { orgId: orgId(), itemId: encodeURIComponent(itemId) });
+      const data = await client.get(ep.path, { service: ep.service });
+      return data?.item || data;
+    },
+    /** Mark one inbox item read (PATCH .../inbox/:id/read). */
+    async inboxMarkRead(itemId, isRead = true) {
+      const ep = resolveEndpoint('inbox.get', { orgId: orgId(), itemId: encodeURIComponent(itemId) });
+      return client.patch(`${ep.path}/read`, { service: ep.service, body: { is_read: Boolean(isRead) } });
+    },
     /** Org-wide approvals awaiting a human (the dashboard header's server-side count, inbox stats awaiting_human). */
     async approvalStats() {
       const ep = resolveEndpoint('inbox.stats.list', { orgId: orgId() });