quoxcli 0.0.0-stage → 0.3.1

package/lib/quoxon/connectCard.js

@@ -0,0 +1,45 @@
+/**
+ * The secure /connect card. Shown in place of the composer while it is open. It renders only the
+ * mask from the secret box, never the value.
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { c, clip } from './theme.js';
+import { Rule, AskCard } from './render.js';
+
+const h = React.createElement;
+
+/** card: { provider: PROVIDERS entry, phase: 'input'|'saving'|'consent', error?: string, question?: string }, mask: string */
+export function ConnectCard({ card, mask, cols }) {
+  const p = card.provider;
+  const w = Math.max(10, cols - 4);
+  // QUOXON-Z2H lane R: the one consent question after a cloud connect (y records the user's own OK).
+  if (card.phase === 'consent') return h(AskCard, { text: card.question, cols }); // QUOXON-ASK: the same card as an approval
+  // #1288: an org admin's own Ollama on a private address: y/N, then the save with a confirm for that origin.
+  if (card.phase === 'private') return h(AskCard, { text: card.question, cols });
+  if (card.phase === 'saving' && card.privateOffer) {
+    return h(Box, { flexDirection: 'column', width: cols, marginTop: 1 },
+      h(Text, { color: c('dim') }, clip(`  ◐ checking ${card.privateOffer.host} answers as Ollama, then saving…`, cols)));
+  }
+  if (card.phase === 'saving' && card.consentType) {
+    return h(Box, { flexDirection: 'column', width: cols, marginTop: 1 },
+      h(Rule, { cols, color: 'sky' }),
+      h(Text, { color: c('sky'), bold: true }, clip(`Ⓠ ${p.name} is connected · one question`, cols)),
+      h(Text, { color: c('text'), wrap: 'wrap' }, `  Your messages and any tool results go to ${p.name}, a third party, when it answers. Nothing is sent until you say yes. You can withdraw this any time (Settings > Privacy).`),
+      h(Text, { color: c('warn'), bold: true }, clip(`  ${card.question}`, cols)),
+      h(Text, { color: c('text') }, card.phase === 'saving' ? clip('  ◐ recording your OK…', cols) : clip('  y yes · n or Enter no · Esc no', cols)),
+      h(Rule, { cols, color: 'sky' }));
+  }
+  return h(Box, { flexDirection: 'column', width: cols, marginTop: 1 },
+    h(Rule, { cols, color: 'sky' }),
+    h(Text, { color: c('sky'), bold: true }, clip(`Ⓠ Connect ${p.name}${card.subtitle ? ` · ${card.subtitle}` : ''} · goes straight to your org vault, never into chat`, cols)),
+    h(Text, { color: c('text') }, clip(`  ${p.why}`, cols)),
+    p.disclosure ? h(Text, { color: c('warn'), wrap: 'wrap' }, `  ${p.disclosure}`) : null,
+    h(Text, { color: c('text') }, clip(`  Get a key: ${p.keyUrl}`, cols)),
+    h(Text, { color: c('text') }, clip(`  key    ${mask || ''}${card.phase === 'input' ? '▏' : ''}`, cols)),
+    card.error ? h(Text, { color: c('warn') }, clip(`  ${card.error}`, w + 2)) : null,
+    h(Text, { color: c('dim') }, card.phase === 'saving'
+      ? clip(`  ◐ testing with ${p.name}, then saving…`, cols)
+      : clip('  paste your key · Enter test and save · Esc cancel · keys typed here stay in this card', cols)),
+    h(Rule, { cols, color: 'sky' }));
+}

package/lib/quoxon/consent.js

@@ -0,0 +1,86 @@
+/**
+ * QUOXON-CONSENT: AI data sharing consent, in words a stuck user can act on.
+ * Consent is PERSONAL (one record per user, POST /api/consent), so the person typing grants it; no admin is
+ * involved. Cloud providers that receive the conversation need it; a local model (Ollama) never does.
+ * This file only words things and shapes the two API calls. The gate itself is the server's.
+ */
+export const PRIVACY_PATH = '/settings#privacy';
+const LABELS = { openai: 'OpenAI', perplexity: 'Perplexity', gemini: 'Google Gemini', google: 'Google', openrouter: 'OpenRouter', huggingface: 'Hugging Face', groq: 'Groq', together: 'Together AI', openai_compatible: 'your custom hosted endpoint' };
+export const providerLabel = (p) => LABELS[String(p || '').toLowerCase()] || (p ? String(p) : 'your cloud AI provider');
+
+// Keep in step with services/collector/lib/consentVerification.js THIRD_PARTY_PROVIDERS. Anthropic and local models are not in it.
+export const CONSENT_PROVIDERS = ['openai', 'perplexity', 'gemini', 'google', 'openrouter', 'huggingface', 'groq', 'together', 'openai_compatible'];
+export const needsConsent = (type) => CONSENT_PROVIDERS.includes(String(type || '').toLowerCase());
+
+export const isConsentError = (ev) => ev?.type === 'error' && ev?.error === 'ai_consent_required';
+
+/** The one-line headline for the error block (the card's first line). */
+export function consentErrorText(ev) {
+  if (ev?.retryable) return 'Quox could not check your AI data sharing consent just now, so nothing was sent. Try again in a moment.';
+  return `Quox needs your OK before sending this conversation to ${providerLabel(ev?.provider)}.`;
+}
+
+/** The lines under the headline: what is shared, how to grant it, the local alternative, the dashboard link. Short lines, no clipping. */
+export function consentHintLines(ev, dashboardBase) {
+  if (ev?.retryable) return [];
+  const who = providerLabel(ev?.provider);
+  const prov = ev?.provider || '<provider>';
+  const why = ev?.reason === 'consent_expired' ? 'Your earlier OK is out of date and needs renewing.'
+    : ev?.reason === 'provider_blocked' ? `You have blocked ${who} in your privacy settings; granting turns it back on.` : null;
+  const lines = [];
+  if (why) lines.push(why);
+  lines.push(`Shared: your messages and any tool results go to ${who}, a third party. Nothing was sent.`);
+  lines.push('Grant it: /consent grant (records your OK and sends this message again), or quox consent grant --provider ' + prov + ' in a shell.');
+  lines.push('Consent is personal, so you can give it yourself; no admin is needed.');
+  if (dashboardBase) lines.push(`Or in the dashboard: ${String(dashboardBase).replace(/\/$/, '')}${ev?.grant?.dashboard_path || PRIVACY_PATH}`);
+  lines.push('No cloud at all: a local model (Ollama) needs no consent. /connect ollama');
+  return lines;
+}
+
+/** GET /api/consent record -> { granted, providers: { name: bool } }. */
+export function consentState(rec) {
+  const providers = rec?.provider_consent && typeof rec.provider_consent === 'object' ? rec.provider_consent : {};
+  return { granted: Boolean(rec?.ai_data_sharing_consent), providers };
+}
+
+/** Is `provider` allowed to receive data under this record? Mirrors the server: overall consent on, provider not set false. */
+export const consentCovers = (rec, provider) => {
+  const s = consentState(rec);
+  return s.granted && s.providers[String(provider || '').toLowerCase()] !== false;
+};
+
+export function consentStatusLines(rec, { provider = null } = {}) {
+  const s = consentState(rec);
+  const names = Object.entries(s.providers).map(([k, v]) => `${k} ${v ? 'yes' : 'blocked'}`);
+  const lines = [[s.granted ? '✔ AI data sharing: you have given your OK.' : '· AI data sharing: not given yet, so nothing is sent to a cloud AI.', s.granted ? 'ok' : 'warn']];
+  if (names.length) lines.push([`Per provider: ${names.join(', ')}.`]);
+  if (!s.granted) lines.push([`/consent grant${provider ? ` ${provider}` : ''} gives it. Your messages and tool results then go to the cloud AI you chose. A local model (Ollama) never needs it.`]);
+  return lines;
+}
+
+/** The body for POST /api/consent: keeps every other provider's setting (the server replaces the map wholesale). */
+export function grantBody(rec, provider) {
+  const keep = consentState(rec).providers;
+  const p = String(provider || '').toLowerCase();
+  return { ai_data_sharing_consent: true, provider_consent: { ...keep, ...(p ? { [p]: true } : {}) } };
+}
+
+/** What to say after /connect saves a hosted key and consent is not yet in place. */
+export function connectConsentNote(providerId) {
+  return `One more step before it can answer: ${providerLabel(providerId)} receives your messages, so Quox needs your OK. /consent grant ${providerId}`;
+}
+
+/**
+ * QUOXON-Z2H lane R: the plain-text message `quox --print` gives for ai_consent_required, naming the exact
+ * shell command (there is no /consent in a one-shot run). profile = the -p the user named, if any.
+ */
+export function consentPrintMessage(ev, profile = null) {
+  if (ev?.retryable) return consentErrorText(ev);
+  const who = providerLabel(ev?.provider);
+  const prov = ev?.provider || '<provider>';
+  const p = profile ? `-p ${profile} ` : '';
+  return `${consentErrorText(ev)} Nothing was sent.\n`
+    + `  Your messages and any tool results would go to ${who}, a third party. Consent is personal; no admin is needed.\n`
+    + `  Grant it, then send again: quox ${p}consent grant --provider ${prov}\n`
+    + '  Or use a local model (Ollama), which needs no consent.';
+}

package/lib/quoxon/context.js

@@ -0,0 +1,68 @@
+/**
+ * Where am I: the slot this session holds and the agent attached to it, for the
+ * status line. Reads directory names and slot labels only, never token contents.
+ * Layout mirrors lib/core/callerSource.js (~/.quox/attach/sessions/claude-<pid>/<agent>/,
+ * ~/.quox/held-slots.json sessionKey claude-<pid>).
+ */
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const clean = (v, n = 32) => String(v == null ? '' : v).replace(/[^\w .:@+\-/~]/g, '').trim().slice(0, n) || null;
+
+const defaults = {
+  readName: (pid) => { try { return readFileSync(`/proc/${pid}/comm`, 'utf8').trim(); } catch { return null; } },
+  readPpid: (pid) => {
+    try {
+      const s = readFileSync(`/proc/${pid}/stat`, 'utf8');
+      const p = parseInt(s.slice(s.lastIndexOf(')') + 2).trim().split(/\s+/)[1], 10);
+      return Number.isFinite(p) ? p : null;
+    } catch { return null; }
+  },
+  attachRoot: () => join(homedir(), '.quox', 'attach', 'sessions'),
+  heldSlotsPath: () => join(homedir(), '.quox', 'held-slots.json'),
+  readdir: (d) => { try { return readdirSync(d, { withFileTypes: true }); } catch { return []; } },
+  readJson: (p) => { try { return existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : null; } catch { return null; } },
+  exists: existsSync,
+  pid: () => process.pid
+};
+
+function claudeAncestor(d, start) {
+  let pid = start;
+  for (let hop = 0; hop < 24; hop++) {
+    if (d.readName(pid) === 'claude') return pid;
+    const pp = d.readPpid(pid);
+    if (!pp || pp === pid || pid === 1) break;
+    pid = pp;
+  }
+  return null;
+}
+
+/** -> { slot: string|null, agent: string|null } ; env wins, then the attach/slot files of the claude ancestor. */
+export function detectSlotAgent(env = process.env, overrides = {}) {
+  const d = { ...defaults, ...overrides };
+  let slot = clean(env.QUOX_SLOT);
+  let agent = clean(env.QUOX_AGENT);
+  if (slot && agent) return { slot, agent };
+  let pid = null;
+  try { pid = claudeAncestor(d, d.pid()); } catch { pid = null; }
+  if (pid) {
+    if (!agent) {
+      const dir = join(d.attachRoot(), `claude-${pid}`);
+      const found = d.readdir(dir).filter(e => e.isDirectory() && d.exists(join(dir, e.name, 'token')));
+      if (found.length) {
+        const kit = d.readJson(join(dir, found[0].name, 'kit.json'));
+        agent = clean(kit && kit.display_name) || clean(found[0].name);
+      }
+    }
+    if (!slot) {
+      const all = d.readJson(d.heldSlotsPath());
+      if (all && typeof all === 'object') {
+        for (const [name, e] of Object.entries(all)) {
+          if (e && e.sessionKey === `claude-${pid}`) { slot = clean(name); break; }
+        }
+      }
+    }
+  }
+  return { slot, agent };
+}

package/lib/quoxon/copy.js

@@ -0,0 +1,34 @@
+/** /copy helpers: pick the text and build the OSC 52 clipboard escape. */
+import { stripMarks } from './palette.js';
+
+export function osc52(text, env = process.env) {
+  const seq = `\x1b]52;c;${Buffer.from(stripMarks(text), 'utf8').toString('base64')}\x07`;
+  return env.TMUX ? `\x1bPtmux;${seq.replace(/\x1b/g, '\x1b\x1b')}\x1b\\` : seq;
+}
+
+/** Fenced code blocks (``` or ~~~) of a markdown string, in order, without the fence lines. */
+export function codeBlocks(md) {
+  const out = []; let cur = null; let fence = null;
+  for (const line of String(md).split('\n')) {
+    const m = line.match(/^\s*(```+|~~~+)/);
+    if (cur === null) { if (m) { fence = m[1][0]; cur = []; } continue; }
+    if (m && m[1][0] === fence && line.trim() === m[1] ) { out.push(cur.join('\n')); cur = null; continue; }
+    cur.push(line);
+  }
+  if (cur && cur.length) out.push(cur.join('\n'));
+  return out;
+}
+
+/** arg: '' | 'N' | 'code'. -> { text } or { error } */
+export function pickCopy(answers, arg) {
+  const list = (answers || []).filter(a => a.text && a.text.trim());
+  if (!list.length) return { error: 'No answer to copy yet.' };
+  if (arg === 'code') {
+    for (let i = list.length - 1; i >= 0; i--) { const b = codeBlocks(list[i].text); if (b.length) return { text: stripMarks(b[b.length - 1]) }; }
+    return { error: 'No code block in the answers so far.' };
+  }
+  const n = arg ? Number(arg) : 1;
+  if (!Number.isInteger(n) || n < 1) return { error: 'Usage: /copy [N|code]' };
+  if (n > list.length) return { error: `Only ${list.length} answer${list.length === 1 ? '' : 's'} so far.` };
+  return { text: stripMarks(list[list.length - n].text) };
+}

package/lib/quoxon/countdownLine.js

@@ -0,0 +1,11 @@
+/** The restart countdown line, fitted to the width: full text when it fits, shorter forms below, never wrapped. */
+export function countdownLine(secs, cols) {
+  const room = Math.max(20, (cols || 80) - 4); // paddingLeft 2 plus a margin
+  const forms = [
+    `↻ New version ready. Restarting in ${secs}s · Esc to stay on this version · Enter to restart now`,
+    `↻ New version · restarting in ${secs}s · Esc stay · Enter now`,
+    `↻ Restarting in ${secs}s · Esc stay · Enter now`,
+    `↻ Restart in ${secs}s · Esc stay`,
+  ];
+  return forms.find(f => f.length <= room) || forms[forms.length - 1];
+}

package/lib/quoxon/demo.autoplay.js

@@ -0,0 +1,29 @@
+/**
+ * Deterministic script for `quox --demo --autoplay`: the same timings on every run, so a screen
+ * recording is repeatable. No Math.random, no wall clock in the plan; only fixed numbers and a seeded PRNG.
+ */
+export const AUTOPLAY_LABEL = 'DEMO: demo data, nothing real runs.';
+export const AUTOPLAY_REQUEST = 'Show me what you can do (demo)';
+export const AUTOPLAY_PROOF = '/proof';
+export const AUTOPLAY = Object.freeze({ seed: 20261013, startMs: 900, typeMinMs: 38, typeMaxMs: 78, afterTypeMs: 450, approvalHoldMs: 2500, afterKeyMs: 400, afterTurnMs: 900, finalHoldMs: 600 });
+
+/** Small seeded PRNG (mulberry32): deterministic across runs and platforms. */
+export function prng(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6D2B79F5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** Per-character delays (ms) for typing `text` at a human pace; identical for the same seed. */
+export function typingPlan(text, seed = AUTOPLAY.seed, { min = AUTOPLAY.typeMinMs, max = AUTOPLAY.typeMaxMs } = {}) {
+  const r = prng(seed);
+  return [...text].map(() => Math.round(min + r() * (max - min)));
+}
+
+/** Is autoplay requested? flag or QUOX_DEMO_AUTOPLAY=1. */
+export const autoplayOn = (flag, env = process.env) => Boolean(flag) || /^(1|true|yes|on)$/i.test(String(env.QUOX_DEMO_AUTOPLAY || ''));

package/lib/quoxon/demo.fixtures.js

@@ -0,0 +1,24 @@
+/** Simulated QUOXON journey for --demo, screenshots and tests. Nothing here talks to a server. */
+export const DEMO_STEPS = (turnId) => [
+  { wait: 150, ev: { type: 'turn.started', turn_id: turnId, conversation_id: 'demo-conv', agent: 'CommanderQ', provider: 'demo', model: 'demo-model', hat: 'operator' } },
+  { wait: 300, ev: { type: 'thinking', turn_id: turnId, stage: 'planning', message: 'Planning the steps' } },
+  { wait: 400, ev: { type: 'text.delta', turn_id: turnId, content: 'I will save that note, then restart the web service. ' } },
+  { wait: 300, ev: { type: 'tool.started', turn_id: turnId, call_id: 'c1', tool: 'memory_save', summary: 'save note "demo journey"' } },
+  { wait: 200, ev: { type: 'trace', turn_id: turnId, protocol: 'aee', label: 'envelope opened', ref: '01K4N8QXAB' } },
+  { wait: 700, ev: { type: 'tool.finished', turn_id: turnId, call_id: 'c1', tool: 'memory_save', status: 'ok', result_summary: 'saved', duration_ms: 640, envelope_id: 'env1', receipt: null } },
+  { wait: 300, ev: { type: 'tool.started', turn_id: turnId, call_id: 'c2', tool: 'host_restart', summary: 'restart web on edge-02' } },
+  { wait: 300, ev: { type: 'approval.requested', turn_id: turnId, call_id: 'c2', inbox_item_id: 'demo-item', approval_id: 'demo-appr', tool: 'host_restart', target: 'web on edge-02', scope: 'service restart, 1 host', risk: 'medium', dashboard_url: 'https://example.invalid/approvals/demo-item' } },
+  { gate: 'approval' },
+  { when: 'reject', wait: 200, ev: { type: 'approval.resolved', turn_id: turnId, call_id: 'c2', inbox_item_id: 'demo-item', decision: 'denied' } },
+  { when: 'reject', wait: 200, ev: { type: 'tool.finished', turn_id: turnId, call_id: 'c2', tool: 'host_restart', status: 'denied', result_summary: 'denied by you, not run', duration_ms: 0, envelope_id: null, receipt: null } },
+  { when: 'reject', wait: 300, ev: { type: 'text.delta', turn_id: turnId, content: 'Understood. The note is saved; web on edge-02 was NOT restarted because you denied it (demo data).' } },
+  { when: 'reject', wait: 200, ev: { type: 'turn.finished', turn_id: turnId, status: 'completed', conversation_id: 'demo-conv' } },
+  { when: 'approve', wait: 200, ev: { type: 'approval.resolved', turn_id: turnId, call_id: 'c2', inbox_item_id: 'demo-item', decision: 'approved' } },
+  { when: 'approve', wait: 900, ev: { type: 'tool.finished', turn_id: turnId, call_id: 'c2', tool: 'host_restart', status: 'ok', result_summary: 'restarted', duration_ms: 2300, envelope_id: 'env2', receipt: { ward_seq: 4069513, verified: true } } },
+  { when: 'approve', wait: 100, ev: { type: 'trace', turn_id: turnId, protocol: 'aocl', label: 'ingress ok identity ok policy ok' } },
+  { when: 'approve', wait: 100, ev: { type: 'trace', turn_id: turnId, protocol: 'ward', label: 'witnessed', ref: '4069513' } },
+  { when: 'approve', wait: 300, ev: { type: 'text.delta', turn_id: turnId, content: 'Done. The note is saved and web on edge-02 restarted (demo data, nothing real ran).' } },
+  { when: 'approve', wait: 200, ev: { type: 'turn.finished', turn_id: turnId, status: 'completed', conversation_id: 'demo-conv' } }
+];
+
+export const DEMO_LABEL = 'DEMO: simulated journey, no server, nothing real runs';

package/lib/quoxon/demo.js

@@ -0,0 +1,76 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { DEMO_STEPS } from './demo.fixtures.js';
+
+const sleep = (ms, signal) => new Promise((res) => {
+  const done = () => { clearTimeout(t); signal?.removeEventListener('abort', done); res(); };
+  const t = setTimeout(done, ms);
+  signal?.addEventListener('abort', done, { once: true });
+});
+
+/** A fake api with the same surface as createApi(), driven by DEMO_STEPS. */
+/**
+ * WALK-FIXES pty seam (demo only, never a real server): decisionsFile is a JSON state file
+ * { items: [decision inbox items], log: [], answerDelayMs?, approvalsDelayMs? }. approvals() lists the open ones,
+ * answerDecision() marks one answered and appends { id, key, note, at } to log, so a test in another process reads
+ * exactly what was submitted, and when.
+ */
+function decisionStore(file) {
+  const load = () => JSON.parse(readFileSync(file, 'utf8'));
+  const wait = (ms) => new Promise(r => setTimeout(r, ms || 0));
+  return {
+    // staleMs: an answered item is still listed for this long (a server that lags behind its own answers)
+    async open() { const d = load(); await wait(d.approvalsDelayMs); return d.items.filter(x => x.status === 'open' || (d.staleMs && x.answeredAt && Date.now() - x.answeredAt < d.staleMs)); },
+    async answer(id, key, note) {
+      const d0 = load(); await wait(d0.answerDelayMs);
+      const d = load(); const it = d.items.find(x => x.id === id);
+      if (!it || it.status !== 'open') { const e = new Error('already handled'); e.status = 404; throw e; }
+      it.status = 'answered'; it.answeredAt = Date.now(); it.answer = { key, note: note || null };
+      d.log.push({ id, key, note: note || null, at: Date.now() });
+      writeFileSync(file, JSON.stringify(d));
+      return { ok: true };
+    }
+  };
+}
+
+export function createDemoApi({ speed = 1, objects = false, decisionsFile = null } = {}) {
+  const decs = decisionsFile ? decisionStore(decisionsFile) : null;
+  let gate = null;
+  let decision = 'approve';
+  return {
+    orgId: () => 'demo-org',
+    async *stream({ turnId }, signal) {
+      decision = 'approve';
+      for (const step of DEMO_STEPS(turnId)) {
+        if (signal?.aborted) return;
+        if (step.when && step.when !== decision) continue;
+        if (step.gate) { await new Promise((res) => { gate = res; signal?.addEventListener('abort', res, { once: true }); }); continue; }
+        await sleep(step.wait / speed, signal);
+        if (signal?.aborted) return;
+        yield step.ev;
+      }
+    },
+    async steer() { return { ok: false, reason: 'unsupported' }; },
+    async interrupt() { return { ok: false }; },
+    async health() { return { ok: true, url: 'demo' }; },
+    // the open approval is in the inbox while the demo holds at the gate, so a poll never prunes its card
+    async approvals() { return [...(gate ? [{ id: 'demo-item', title: 'host_restart on web on edge-02', approval_id: 'demo-appr', created_at: new Date().toISOString() }] : []), ...(decs ? await decs.open() : [])]; },
+    ...(decs ? { async answerDecision(id, key, { note } = {}) { return decs.answer(id, key, note); }, async approvalStats() { return { awaiting: (await decs.open()).length + (gate ? 1 : 0) }; } } : {}),
+    async skills() { return [{ id: 'sk1', name: 'daily-fleet-check', description: 'Check fleet health and summarise.', edition: 'stable' }]; },
+    async skill(id) { return { id, name: 'daily-fleet-check', description: 'Check fleet health and summarise.', edition: 'stable' }; },
+    async conversationExists() { return { exists: true }; },
+    // /proof works in the demo journey (main.js asks for it); the other object views stay unavailable offline
+    ...(objects ? { objects: {
+      async proof(tool) {
+        const env = { id: tool.envelopeId, corr: 'demo-corr', payload: { success: true, tool_name: tool.tool } };
+        return { data: { tool, envelope: { ok: true, env },
+          aocl: { ok: true, list: [{ intent: 'aocl.identity.verified' }, { intent: 'aocl.policy.evaluated', payload: { allPassed: true } }] },
+          receipt: { ok: true, result: { status: 'WITNESSED', entry: { seq: 4069513 } } } } };
+      },
+      ...Object.fromEntries(['skill', 'agent', 'workflowRun', 'crystal', 'memory', 'rules', 'reconcile'].map((k) => [k, async () => ({ error: 'Object views are not available in the demo.' })]))
+    } } : {}),
+    async respond(_id, action) {
+      if (decs && _id !== 'demo-item') return decs.answer(_id, action === 'reject' ? 'n' : 'y', null); // a yes/no decision answered as an approval (the bulk card)
+      decision = action === 'reject' ? 'reject' : 'approve'; const g = gate; gate = null; g?.(); return { ok: true };
+    }
+  };
+}

package/lib/quoxon/devObserver.js

@@ -0,0 +1,20 @@
+/**
+ * Is a dev observer wired to this install? /observe and /note exist only for the developer whose
+ * window a QUOXON observer session watches; a customer has no observer, so for them these commands
+ * are hidden (help, palette, autocomplete) and refuse with a plain line.
+ *
+ * The switch is config driven, in the same style as the dev-transcripts flag: QUOX_DEV_OBSERVER=1
+ * turns it on for one shell, QUOX_DEV_OBSERVER=0 forces it off, otherwise the flag file
+ * ~/.config/quox/dev-observer decides (touch it on a dev box; it survives new shells).
+ */
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const DEV_OBSERVER_REFUSAL = 'No dev observer is set up on this install, so there is nothing to send this to.';
+
+export function devObserverOn(env = process.env, { home = homedir(), exists = existsSync } = {}) {
+  if (env.QUOX_DEV_OBSERVER === '0') return false;
+  if (env.QUOX_DEV_OBSERVER === '1') return true;
+  try { return exists(join(home, '.config', 'quox', 'dev-observer')); } catch { return false; }
+}

package/lib/quoxon/dividerAocl.js

@@ -0,0 +1,191 @@
+/**
+ * TUI-DIVIDER: the composer's bottom rule (`──────── anthropic claude-sonnet-5-5 ─`) as a live AOCL strip.
+ *
+ * Owner design (2026-10-17 22:09, after the first cut): a PIPELINE, like the dashboard command screen's
+ * LayerStackMini. One compact chain of 11 dots, one per AOCL layer, each in its own layer colour, sits just left of
+ * the model label: `────────•─•─●─●─◆─•─•─•─•─•─• anthropic claude-sonnet-5-5 ─`. On Enter the dots light left to
+ * right as the real layer events arrive; when they reach the model, only the label animates (katakana shimmer).
+ * Motion lives in one place at a time (the newest dot, or the label), never across the row. The finished state is
+ * the label green (red on an error or a block, with the blocking dot marked) for ~1.6 s, then the normal rule.
+ *
+ * HONESTY: only REAL state moves this. A pip lights only when that layer's `aocl.layer` event arrives (or a
+ * pre-stream refusal's `aocl_layers` record), in the colour of its real result. A bypassed layer (not evaluated
+ * on this path) stays unlit, and so does every layer of a server that sends no `aocl.layer`. The "model is
+ * working" phase starts on a real signal: the last pre-model layer (L4) reported, or the first model output.
+ * Dots light one step apart for readability (STEP_MS), but never before their own event.
+ *
+ * Pure: `dividerStep` folds actions into state, `dividerFrame` draws one frame (or null = draw the normal rule).
+ * Nothing here runs a timer; the app asks the clock for frames only while `dividerLive` says so.
+ */
+import stringWidth from 'string-width';
+import { wordFrame, wordColor } from './indicator.js';
+import { LAYER_NAMES } from './aocl.js';
+
+export const ORDER = ['L0', 'L1', 'L2', 'L3', 'L4', 'L5', 'L6', 'L7', 'L8', 'L9', 'L10'];
+const PRE_LAST = 'L4';
+export const GREEN_MS = 1600;   // the label holds green this long after a completed reply (under the app's 2 s idle guarantee, motion-app.test)
+export const RED_MS = 1600;     // and red this long after an error or a block (the error itself stays in the transcript)
+export const MIN_COLS = 70;     // narrower than this: the plain rule, no animation
+export const STEP_MS = 120;     // dots light at most one per step, left to right (never before their event)
+export const CURRENT_MS = 700;  // the newest dot blinks this long after it lights; then it is just lit
+export const TAG_MS = 1200;     // the newest layer's name shows beside the chain this long
+export const LIT_RESULTS = new Set(['pass', 'gated', 'blocked']);
+
+// Real model work only. `thinking` frames are mostly server staging (routing, processing, provider notes) sent
+// before turn.started; only the model's own reasoning counts.
+const MODEL_SIGNALS = new Set(['chunk', 'text.delta', 'tool.started']);
+const isModelSignal = (ev) => MODEL_SIGNALS.has(ev.type) || (ev.type === 'thinking' && ev.stage === 'model_reasoning');
+
+/** A fresh strip for a turn the user just sent. */
+export const dividerStart = (turnId, now) => ({ turnId, startedAt: now, pips: {}, seen: {}, order: [], modelAt: null, phase: 'gates', endedAt: null, blockedAt: null });
+
+function light(d, l, now) {
+  const id = String(l?.id || '');
+  if (!ORDER.includes(id) || d.pips[id]) return d; // unknown layer or already lit: nothing changes
+  const result = String(l.result || '');
+  if (!LIT_RESULTS.has(result)) { // bypass: a real event, but not evaluated: the pipeline steps over it, unlit
+    return result === 'bypass' && !(d.seen || {})[id] ? { ...d, seen: { ...(d.seen || {}), [id]: { result, at: now } } } : d;
+  }
+  let n = { ...d, pips: { ...d.pips, [id]: { result, at: now } }, seen: { ...(d.seen || {}), [id]: { result, at: now } }, order: [...d.order, id] };
+  if (result === 'blocked') n = { ...n, phase: 'error', blockedAt: id, endedAt: n.endedAt ?? now };
+  return n;
+}
+
+/**
+ * Fold one reducer action into the strip. `a` is the quoxon reducer action ({type:'turn.begin'} or
+ * {type:'event', ev}); unknown actions return `d` unchanged (same object).
+ */
+export function dividerStep(d, a, now) {
+  if (!a) return d;
+  if (a.type === 'turn.begin') return dividerStart(a.turnId, now);
+  if (a.type !== 'event' || !d || d.endedAt != null && a.ev?.type !== 'aocl.layer') return d;
+  const ev = a.ev || {};
+  if (ev.type === 'aocl.layer') {
+    if (d.endedAt != null && d.phase !== 'error') return d; // a finished green strip never changes
+    let n = light(d, ev, now);
+    const pre = ev.phase === 'pre' || ORDER.indexOf(String(ev.id)) <= ORDER.indexOf(PRE_LAST);
+    if (n.phase === 'gates' && (String(ev.id) === PRE_LAST || !pre)) n = { ...n, phase: 'model', modelAt: n.modelAt ?? now };
+    return n;
+  }
+  if (isModelSignal(ev)) return d.phase === 'gates' ? { ...d, phase: 'model', modelAt: now } : d;
+  if (ev.type === 'aocl.verdict' && ev.verdict === 'blocked') {
+    const id = ORDER.includes(ev.layer) ? ev.layer : 'L8';
+    return { ...d, phase: 'error', blockedAt: d.blockedAt || id, endedAt: d.endedAt ?? now };
+  }
+  if (ev.type === 'error') return { ...d, phase: 'error', endedAt: now };
+  if (ev.type === 'turn.finished') {
+    const ok = (ev.status || 'completed') === 'completed';
+    return ok && d.phase !== 'error' ? { ...d, phase: 'done', endedAt: now } : { ...d, phase: 'error', endedAt: d.endedAt ?? now };
+  }
+  return d;
+}
+
+/** True while the strip needs frames: a turn in flight, or the green/red hold after it. */
+export function dividerLive(d, now) {
+  if (!d) return false;
+  if (d.endedAt == null) return true;
+  return now - d.endedAt < (d.phase === 'done' ? GREEN_MS : RED_MS);
+}
+
+// Each layer's own colour, from the dashboard (src/lib/aee/envelope.js AOCL_LAYERS, which LayerStackMini uses).
+// L0 and L10 are grey there (#6b7280); the TUI has no grey text, so they take sky and violet.
+export const LAYER_HEX = {
+  L0: '#38bdf8', L1: '#3b82f6', L2: '#3b82f6', L3: '#f59e0b', L4: '#8b5cf6', L5: '#8b5cf6',
+  L6: '#6366f1', L7: '#f97316', L8: '#14b8a6', L9: '#22c55e', L10: '#a855f7',
+};
+const hexRgb = (h) => [1, 3, 5].map(i => parseInt(h.slice(i, i + 2), 16));
+const mixRgb = (a, b, t) => a.map((v, i) => Math.round(v + (b[i] - v) * t));
+const DARK = [30, 36, 48];
+export const layerRgb = (id) => hexRgb(LAYER_HEX[id]);
+export const dimRgb = (id) => mixRgb(layerRgb(id), DARK, 0.6); // pending / bypassed: the layer's own hue, dimmed (not grey)
+
+export const RGB = { done: [34, 197, 94], blocked: [239, 68, 68], model: [56, 189, 248] };
+const LIT = { pass: '●', gated: '◆', blocked: '✖' };
+const PENDING = '•';
+
+/**
+ * When each layer the server reported was reached in the pipeline: in layer order, one STEP_MS apart, never
+ * before its own event. Bypassed layers are reached (the chain passes them) but stay unlit.
+ */
+export function layerReachTimes(d) {
+  const out = {};
+  if (!d) return out;
+  let t = d.startedAt - STEP_MS;
+  for (const id of ORDER) {
+    const s = (d.seen || {})[id] || d.pips[id];
+    if (!s) continue;
+    t = Math.max(t + STEP_MS, s.at);
+    out[id] = t;
+  }
+  return out;
+}
+
+/** When the pipeline hands over to the model (the label starts to shimmer): every pre-model layer seen was reached. */
+export function modelReachedAt(d) {
+  if (!d || d.modelAt == null) return null;
+  const r = layerReachTimes(d);
+  const pre = ORDER.slice(0, ORDER.indexOf(PRE_LAST) + 1).map(id => r[id]).filter(x => x != null);
+  return Math.max(d.modelAt, ...pre, d.startedAt) + (pre.length ? STEP_MS : 0);
+}
+
+/** The chain of 11 dots joined by rule: cells [{ t, rgb, bold }]. Motion only on the newest dot. */
+export function chainCells(d, now, { still = false } = {}) {
+  const reach = layerReachTimes(d);
+  const reached = ORDER.filter(id => reach[id] != null && reach[id] <= now);
+  const newest = reached.filter(id => d.pips[id]).sort((a, b) => reach[b] - reach[a])[0] || null;
+  const cells = [];
+  ORDER.forEach((id, i) => {
+    if (i) cells.push({ t: '─' });
+    const p = d.pips[id];
+    if (p && reach[id] <= now) {
+      // only the newest dot blinks, only while the turn runs, and a blocked dot never dims (it stays red)
+      const blinkOff = !still && d.endedAt == null && p.result !== 'blocked' && id === newest && now - reach[id] < CURRENT_MS && Math.floor((now - reach[id]) / 175) % 2 === 1;
+      const rgb = p.result === 'blocked' ? RGB.blocked : layerRgb(id);
+      cells.push({ t: LIT[p.result], rgb: blinkOff ? dimRgb(id) : rgb, bold: !blinkOff });
+    } else cells.push({ t: PENDING, rgb: dimRgb(id) });
+  });
+  return { cells, newest, newestAt: newest ? reach[newest] : null };
+}
+
+/**
+ * One frame of the rule: `{ cells: [{ t, rgb?, bold?, label? }] }` whose widths sum to exactly `cols`, or null
+ * when the normal rule should draw (no strip, the hold is over, NO_COLOR, reduced motion, too narrow, no label).
+ * Cells without `rgb` take the rule's own colour; `label: true` takes the label's own colour.
+ * `still` (a slow redraw): no blink and no katakana, but every lit dot and the end colours stay.
+ */
+export function dividerFrame({ cols, label, d, now, mono = false, reduced = false, still = false, seed = 0 }) {
+  if (mono || reduced || !d || cols < MIN_COLS || !label || !dividerLive(d, now)) return null;
+  const lab = ` ${label} `;
+  const lw = stringWidth(lab);
+  const chain = chainCells(d, now, { still });
+  const cw = chain.cells.length;
+  const left = cols - lw - 1 - cw;
+  if (left < 4) return null;
+  // the newest lit layer names itself to the left of the chain, in its colour, while it is new
+  const tag = chain.newest && now - chain.newestAt < TAG_MS ? ` ${chain.newest} ${LAYER_NAMES[chain.newest] || ''} ` : '';
+  const fill = Math.max(1, left - (tag && tag.length + 1 <= left - 1 ? tag.length : 0));
+  const leftCells = Array.from({ length: fill }, () => ({ t: '─' }));
+  if (fill < left) {
+    const rgb = d.pips[chain.newest].result === 'blocked' ? RGB.blocked : layerRgb(chain.newest);
+    leftCells.splice(fill - 1, 0, ...[...tag].map(ch => ({ t: ch, rgb, bold: true })));
+  }
+  while (leftCells.length < left) leftCells.push({ t: '─' });
+  let labelCells;
+  if (d.phase === 'done') labelCells = [{ t: lab, rgb: RGB.done, bold: true }];
+  else if (d.phase === 'error') labelCells = [{ t: lab, rgb: RGB.blocked, bold: true }];
+  else {
+    const at = modelReachedAt(d);
+    if (at != null && now >= at) {
+      if (still) labelCells = [{ t: lab, rgb: RGB.model, bold: true }];
+      else {
+        const fr = wordFrame(label, now, { since: at, seed });
+        const n = fr.length;
+        labelCells = [{ t: ' ' }, ...fr.map((c, i) => ({ t: c.ch, rgb: wordColor('working', i, n, now, c.flash ? 'flash' : c.glyph ? 'glyph' : 'letter') })), { t: ' ' }];
+      }
+    } else labelCells = [{ t: lab, label: true }];
+  }
+  return { cells: [...leftCells, ...chain.cells, ...labelCells, { t: '─' }] };
+}
+
+/** Plain text of a frame (tests and pty proofs). */
+export const frameText = (f) => (f ? f.cells.map(c => c.t).join('') : null);