quoxcli 0.2.0 → 0.3.1

package/lib/quoxon/events.js

@@ -11,9 +11,14 @@
  *   turn     : null | { id, status: running|interrupting, startedAt, stage, activity }
  */
 
-import { splitSettled } from './markdown.js';
+import { dividerStep } from './dividerAocl.js';
+import { approvalFacts } from './approvalFacts.js';
+import { isConsentError, consentErrorText } from './consent.js';
+import { splitSettled } from './markdownSettle.js'; // not markdown.js: that loads React + Ink (QUOXON-LATENCY)
 import { nextActivity, actionActivity } from './activity.js';
 import { normUsage, turnTokens, fmtTokens, fmtCost } from './indicator.js';
+import { isLayerTrace, normaliseSummary, summaryFromTraces, verdictNote } from './aocl.js';
+import { toolResultText } from './toolError.js';
 
 export const TOOL_STATUSES = ['ok', 'failed', 'denied', 'effect_unknown'];
 export const APPROVAL_ARM_MS = 300;
@@ -23,10 +28,14 @@ export const HELD_KEY_MS = 1500;
 export const initialState = (over = {}) => ({
   history: [],
   blocks: [],
+  asks: [],         // ASK-SETTLE: open y/N/c ask cards (live, never scrollback) until answered/expired/closed
   turn: null,
   ctx: { agent: null, model: null, provider: null, endpoint: null, hat: null, conversationId: null },
   pending: [],      // client-side queue (Tab)
   steering: [],     // steer messages not yet accepted
+  lastTurnId: null, // the newest turn begun here: a card from an older turn is stale
+  lastAocl: null,  // QUOXON-AOCL: the last turn's normalised aocl.summary (for /aocl)
+  waiting: [],      // approvals raised by ANOTHER conversation/session: a notice only, never a focused card (answered via /approvals)
   approvals: [],    // approval cards waiting for a human, first is shown; survive the turn that raised them
   running: [],      // approved from this terminal, result arrives asynchronously (polled)
   inbox: [],        // last /approvals listing
@@ -46,21 +55,51 @@ export const initialState = (over = {}) => ({
  * streams keep using `chunk`. Returns { append, st } where st is { v1, lastChunk }.
  */
 export function textGate(st, ev) {
-  const g = st || { v1: false, lastChunk: null };
+  const g = st || { v1: false, lastChunk: null, acc: '' };
+  const acc = g.acc || '';
+  const add = (c) => (acc + c).slice(-200000);
   if (ev.type === 'turn.started') return { append: false, st: { ...g, v1: true } };
   if (ev.type === 'chunk') {
-    if (g.v1) return { append: false, st: g };
-    return { append: Boolean(ev.content), st: { ...g, lastChunk: ev.content ?? null } };
+    const c = ev.content;
+    if (!c) return { append: false, st: g };
+    // RESTORE-TUI: on a v1 stream a chunk is skipped only when it mirrors text already shown (the full text so far,
+    // or the delta it repeats). A chunk carrying NEW text is still answer text (it was dropped since dae720283).
+    if (g.v1 && acc.endsWith(c)) return { append: false, st: g };
+    return { append: true, st: { ...g, lastChunk: c, acc: add(c) } };
   }
   if (ev.type === 'text.delta') {
-    const mirrored = !g.v1 && g.lastChunk != null && g.lastChunk === ev.content;
-    return { append: Boolean(ev.content) && !mirrored, st: { v1: true, lastChunk: null } };
+    const c = ev.content;
+    const mirrored = g.lastChunk != null && g.lastChunk === c;
+    const append = Boolean(c) && !mirrored;
+    return { append, st: { v1: true, lastChunk: null, acc: append ? add(c) : acc } };
   }
   return { append: false, st: g };
 }
 
 const tms = (v) => { const t = typeof v === 'number' ? v : Date.parse(v); return Number.isFinite(t) ? t : null; };
 
+const short = (v, n = 120) => { const t = typeof v === 'string' ? v : (v == null ? '' : JSON.stringify(v)); return t.length > n ? t.slice(0, n - 1) + '…' : t; };
+const argText = (a) => a && typeof a === 'object' && !Array.isArray(a) && (a.argv || a.command) ? argText(a.argv ?? a.command) : Array.isArray(a) ? a.join(' ') : (a && typeof a === 'object' ? Object.entries(a).filter(([, v]) => v != null && typeof v !== 'object').slice(0, 4).map(([k, v]) => `${k}=${v}`).join(' ') : (a == null ? '' : String(a)));
+
+/**
+ * Describe ANY inbox approval from what the item carries: the tool or leaf, the command or key args, the target
+ * (explicit target, else the org it acts on), and who asked and when. Never invents; empty fields are null.
+ */
+export function describeInboxItem(it) {
+  const p = it?.payload || {};
+  const c = p.approval_context || {};
+  const m = c.method || {};
+  const ob = c.on_behalf_of || {};
+  const w = p.what && typeof p.what === 'object' ? p.what : {}; // APPROVAL-WHAT: the server's own action/target/summary wins
+  const tool = w.action || m.tool || c.tool || c.leaf || p.tool || p.leaf || null;
+  const argv = m.argv ?? m.args ?? c.argv ?? c.args ?? p.argv ?? p.args ?? m.command ?? c.command ?? p.command ?? null;
+  const cmd = short([m.leaf || c.leaf || p.leaf, argText(argv)].filter(Boolean).join(' ').trim() || null);
+  const target = w.target || m.target || c.target || p.target || cmd || w.target_none || c.target_org || c.org_name || p.org_name || c.org_id || p.org_id || null;
+  const by = ob.agent || ob.agent_id || ob.session_name || ob.session || c.requested_by?.agent_label || c.source_label || p.source || it?.source || null;
+  const what = w.summary ? String(w.summary) : (it?.title ? short(String(it.title), 160) : null);
+  return { tool, target: target ? short(target, 200) : null, title: what, by: by ? String(by) : null, at: it?.created_at ?? it?.createdAt ?? null };
+}
+
 /**
  * A pending inbox approval found by polling -> approval card, or null when it does not qualify.
  * Qualifies when created after `since` (the turn start, else app start), or raised on behalf of this
@@ -68,19 +107,67 @@ const tms = (v) => { const t = typeof v === 'number' ? v : Date.parse(v); return
  */
 export function cardFromInboxItem(it, { since = 0, userId = null, conversationId = null, now = 0 } = {}) {
   if (!it || !it.id) return null;
+  if (it.payload?.type === 'decision') return null; // quox ask: answered with /answer N key from /approvals, never a y/n key card
   const c = it.payload?.approval_context || {};
   const m = c.method || {};
   const created = tms(it.created_at ?? it.createdAt);
   const mine = Boolean(userId && c.on_behalf_of?.user_id && String(c.on_behalf_of.user_id) === String(userId));
   const here = Boolean(conversationId && c.on_behalf_of?.conversation_id === conversationId);
   if (!(created != null && created >= since) && !mine && !here) return null;
+  // QUOXON-REVIEW: collector tool approvals mint the inbox item with aee_correlation_id = the approval id;
+  // without it the card had no id, polling was skipped and every terminal approve read "timeout".
+  const toolApproval = it.payload?.type === 'native_tool_approval';
+  const approvalId = it.payload?.approval_id || it.approval_id || it.approvalId
+    || (toolApproval ? (it.aee_correlation_id || it.aeeCorrelationId || null) : null) || null;
+  const ob = c.on_behalf_of || {};
+  const d = describeInboxItem(it);
+  const tool = d.tool || String(it.title || it.id);
   return {
-    callId: `inbox:${it.id}`, inboxItemId: it.id, approvalId: it.payload?.approval_id || it.approval_id || it.approvalId || null,
-    tool: m.tool || String(it.title || it.id), target: m.target || null, scope: null, risk: c.risk || null,
-    url: it.dashboard_url || null, shownAt: now, undescribable: !m.tool || !m.target
+    callId: `inbox:${it.id}`, inboxItemId: it.id, approvalId,
+    tool, target: d.target, what: d.title, askedBy: d.by, askedAt: d.at, scope: null, risk: c.risk || null,
+    url: it.dashboard_url || null, shownAt: now, undescribable: !d.tool && !d.target,
+    facts: approvalFacts(it), // APPROVAL-WWWH: the exact command, hosts, chain, reason, time and read-only class
+    // only an item that names THIS conversation is ours; anything else came from another session and must not take the keyboard
+    foreign: !here,
+    origin: String(ob.agent || ob.agent_id || ob.session_name || ob.session || (ob.conversation_id ? `conversation ${String(ob.conversation_id).slice(0, 8)}` : approvalSourceLabel(it))),
+    privileged: isPrivileged({ tool, risk: c.risk, flag: c.privileged === true || c.elevated === true || it.payload?.privileged === true, title: it.title })
   };
 }
 
+/** Where an inbox approval came from: its source label, else the payload source, else its type. */
+export function approvalSourceLabel(it) {
+  const c = it?.payload?.approval_context || {};
+  return String(c.source_label || it?.payload?.source || it?.source || (c.requested_by && c.requested_by.agent_label) || it?.payload?.type || 'plugin or workflow');
+}
+
+/**
+ * QUOXON-FW7: every open inbox approval, grouped for /approvals. 'this conversation' (names this conversation,
+ * or already a card here), 'other sessions' (raised on behalf of another conversation or agent), and
+ * 'plugins and workflows' (everything else, labelled by source). Empty groups are dropped.
+ */
+export function groupApprovals(items, { conversationId = null, cardIds = [] } = {}) {
+  const g = { 'decisions asked of you': [], 'this conversation': [], 'other sessions': [], 'plugins and workflows': [] };
+  for (const item of items || []) {
+    if (item?.payload?.type === 'decision') { g['decisions asked of you'].push({ item, label: String(item.payload.session || 'session') }); continue; } // quox ask
+    const ob = item?.payload?.approval_context?.on_behalf_of || {};
+    const label = approvalSourceLabel(item);
+    // A card that names a conversation belongs here only when it is THIS one (a card shown in this window for another
+    // conversation, e.g. a privileged hat.switch, is still "other sessions"). No conversation named: a card here counts.
+    const mine = ob.conversation_id ? Boolean(conversationId) && ob.conversation_id === conversationId : cardIds.includes(item.id);
+    if (mine) g['this conversation'].push({ item, label });
+    else if (ob.conversation_id || ob.agent || ob.agent_id || ob.session_name || ob.session) g['other sessions'].push({ item, label: String(ob.session_name || ob.session || ob.agent || ob.agent_id || `conversation ${String(ob.conversation_id).slice(0, 8)}`) });
+    else g['plugins and workflows'].push({ item, label });
+  }
+  return Object.entries(g).filter(([, v]) => v.length).map(([group, v]) => ({ group, items: v }));
+}
+
+/** Privileged/elevated grants (hat switches and anything the server marks privileged or elevated) need an explicit confirm. */
+export function isPrivileged({ tool = '', risk = null, flag = false, title = '' } = {}) {
+  if (flag === true) return true;
+  if (String(tool) === 'hat.switch' || /^hat[ .]switch/i.test(String(title))) return true;
+  return /privileged|elevated|critical/i.test(String(risk || ''));
+}
+
 let uid = 0;
 const nid = () => ++uid;
 
@@ -101,6 +188,11 @@ function flush(s, force = false) {
   return out.length || blocks.length !== s.blocks.length ? { ...s, history: [...s.history, ...out], blocks } : s;
 }
 
+/** Fold the turn's VOLT tool count and list into its AOCL summary (footer count, /aocl list). */
+function withTools(sum, turn) {
+  const t = turn?.toolsOffer;
+  return t && t.offered != null ? { ...sum, toolsOffered: t.offered, toolsTotal: t.total, toolsList: t.list } : sum;
+}
 function note(s, text, tone = 'dim') {
   return { ...s, history: [...s.history, { id: nid(), kind: 'note', text, tone }] };
 }
@@ -133,6 +225,14 @@ function appendText(s00, content) {
   return addBlock(s, { kind: 'text', text: content });
 }
 
+/** QUOXON-FW3: who a delegation targets. Server fields first; older servers only put agent_id=<id> in the summary. */
+export function delegateInfo(ev) {
+  if (ev.tool !== 'delegate_to_agent') return {};
+  const id = ev.agent_id || (String(ev.summary || '').match(/\bagent_id=(\S+)/) || [])[1] || null;
+  if (!id) return {};
+  return { agentId: id, agentName: ev.agent_name || id, ...(ev.task_gist ? { taskGist: ev.task_gist } : {}) };
+}
+
 function upsertTool(s, ev, patch) {
   const i = s.blocks.findIndex(b => b.kind === 'tool' && b.callId === ev.call_id);
   if (i >= 0) {
@@ -172,7 +272,8 @@ export function summarizeTurn(s, status, now) {
   // Real server usage when it arrived; otherwise the estimate from streamed text; nothing when neither exists.
   const tk = turnTokens(t);
   if (tk > 0) parts.push(`${fmtTokens(tk)} tokens`);
-  const cost = fmtCost(t?.usage?.cost ?? normUsage(null, t?.doneCost).cost);
+  // A labelled estimate (cost_source, e.g. the claude CLI's own figure) is never shown as this turn's price; /cost explains it.
+  const cost = t?.usage?.costSource || t?.viaCli ? null : fmtCost(t?.usage?.cost ?? normUsage(null, t?.doneCost).cost);
   if (cost) parts.push(cost);
   if (status === 'interrupted' || status === 'failed') {
     if (t?.tools) parts.push(`${plural(finished, 'tool')} finished`);
@@ -215,15 +316,47 @@ function endTurn(s, status, now) {
 function reduceInner(s, a) {
   switch (a.type) {
     case 'user': // a submitted prompt
-      return { ...s, history: [...s.history, { id: nid(), kind: 'user', text: a.text, queued: !!a.queued }] };
+      return { ...s, history: [...s.history, { id: nid(), kind: 'user', text: a.text, queued: !!a.queued, ...(a.echo ? { echo: true } : {}) }] };
     case 'turn.begin':
-      return { ...s, turn: { id: a.turnId, status: 'running', startedAt: a.now, stage: null, activity: null, tools: 0, finishedTools: 0, approvals: 0, receipts: [], chars: 0, usage: null }, blocks: [], autoDrain: false };
+      return { ...s, lastTurnId: a.turnId, turn: { id: a.turnId, status: 'running', startedAt: a.now, stage: null, activity: null, tools: 0, finishedTools: 0, approvals: 0, receipts: [], chars: 0, usage: null }, blocks: [], autoDrain: false };
     case 'note':
       return note(s, a.text, a.tone);
+    // ASK-SETTLE (owner 2026-10-17): an open ask is a live card; settling it removes the card and leaves one line.
+    case 'ask.open': { // the same ask shown again (after a chat about it) replaces its card, never a second one
+      const asks = (s.asks || []).filter(x => x.text !== a.text);
+      return { ...s, asks: [...asks, { id: a.id, text: a.text, at: a.at ?? null }] };
+    }
+    case 'ask.settle': {
+      const asks = s.asks || [];
+      if (!asks.some(x => x.id === a.id)) return s;
+      if (a.silent) return { ...s, asks: asks.filter(x => x.id !== a.id) }; // a walkthrough card that ended normally: no leftover line
+      return note({ ...s, asks: asks.filter(x => x.id !== a.id) }, a.text, a.tone);
+    }
+    case 'slotmsg.settle': { // SLOT-RUN: an answered/expired run request collapses to one line in place
+      let hit = false;
+      const history = s.history.map(it => {
+        if (it.kind !== 'slotmsg' || !it.line?.run || it.line.run.askId !== a.askId || it.line.run.settled) return it;
+        hit = true;
+        return { ...it, line: { ...it.line, run: { ...it.line.run, settled: a.text, settledTone: a.tone } } };
+      });
+      return hit ? { ...s, history } : s;
+    }
+    case 'bang.out': // QUOXON-FW8: command output, shown as is (not note-painted); the transcript records only the action name
+      return { ...s, history: [...s.history, { id: nid(), kind: 'bang', text: a.text }] };
+    case 'slotmsg': // QUOXON-MESH: a slot chat line (slotChat.js slotLine), incoming or sent
+      return { ...s, history: [...s.history, { id: nid(), kind: 'slotmsg', line: a.line }] };
+    case 'tip': // a "did you know" tip (tips.js); text + the command to try
+      return { ...s, history: [...s.history, { id: nid(), kind: 'tip', text: a.text, cmd: a.cmd }] };
+    case 'bcard': // QUOXON-BROADCAST: the sender's framed delivery card (slash/broadcast.js broadcastCard), pure data
+      return { ...s, history: [...s.history, { id: nid(), kind: 'bcard', card: a.card }] };
+    case 'whatsnew': // the startup "What's new" box (whatsnew.js): [{ title, cmd }] + how many more
+      return { ...s, history: [...s.history, { id: nid(), kind: 'whatsnew', items: a.items, more: a.more, head: a.head, pad: a.pad }] };
     case 'notify':
       return { ...s, notify: { ...s.notify, ...a.patch } };
     case 'welcome':
       return { ...s, history: [...s.history, { id: nid(), kind: 'welcome', version: a.version }] };
+    case 'introShow': // /welcome: the first screen again (Q art + the greeting text), settled in history
+      return { ...s, history: [...s.history, { id: nid(), kind: 'intro', text: a.text, cols: a.cols }] };
     case 'help':
       return { ...s, history: [...s.history, { id: nid(), kind: 'help', model: a.model }] };
     case 'object': // inline object view (objects/): pure data, rebuilt at render width
@@ -232,6 +365,8 @@ function reduceInner(s, a) {
       return flush(addBlock(s, { kind: 'error', text: a.text }), false);
     case 'verbose':
       return { ...s, verbose: a.mode };
+    case 'aocl.table': // /aocl: the last turn's per-layer table, on demand
+      return { ...s, history: [...s.history, { id: nid(), kind: 'aocl', table: true, sum: s.lastAocl || null }] };
     case 'history.add': // restored turns (/resume): ordinary history items, plus their answers for /copy
       return { ...s, history: [...s.history, ...(a.items || []).map(i => ({ id: nid(), ...i }))], answers: [...(s.answers || []), ...(a.answers || [])].slice(-20) };
     case 'history.reset': // /clear: a fresh screen; nothing on the server is touched
@@ -273,20 +408,47 @@ function reduceInner(s, a) {
     }
     case 'interrupt.requested':
       return s.turn ? { ...s, turn: { ...s.turn, status: 'interrupting' } } : s;
+    case 'turn.deferred': // QUOXON-FW3: the send never reached the server; end the turn quietly (no failure summary, nothing ran)
+      return { ...s, turn: null, blocks: [], autoDrain: false };
     case 'stopped.local': { // SSE aborted by us because the server has no interrupt route
       let n = note(s, 'Stopped locally; work already sent may still finish. Verify before retrying.', 'warn');
       return endTurn(n, 'interrupted', a.now);
     }
     case 'approval.found': { // pending approval seen by polling (covers provider paths that emit no approval.requested)
       const card = cardFromInboxItem(a.item, { since: s.turn?.startedAt ?? a.since ?? 0, userId: a.userId, conversationId: s.ctx.conversationId, now: a.now || 0 });
+      if (card && card.approvalId) { // an event card raised without an inbox id learns it from the poll (else y answers a null id: 404)
+        const j = s.approvals.findIndex(x => !x.inboxItemId && x.approvalId === card.approvalId);
+        if (j >= 0) { const approvals = s.approvals.slice(); approvals[j] = { ...approvals[j], inboxItemId: card.inboxItemId, url: approvals[j].url || card.url, facts: approvals[j].facts || card.facts }; return { ...s, approvals, seenInbox: { ...s.seenInbox, [card.inboxItemId]: true } }; }
+      }
+      if (card && card.approvalId) { // an event stub that could not be described learns its description from the inbox item
+        const j = s.approvals.findIndex(x => x.undescribable && (x.inboxItemId === card.inboxItemId || x.approvalId === card.approvalId));
+        if (j >= 0 && !card.undescribable) { const approvals = s.approvals.slice(); approvals[j] = { ...approvals[j], tool: card.tool, target: card.target, what: card.what, askedBy: card.askedBy, askedAt: card.askedAt, facts: card.facts, undescribable: false }; return { ...s, approvals }; }
+      }
       if (!card || s.seenInbox[card.inboxItemId] || s.approvals.some(x => x.inboxItemId === card.inboxItemId || (card.approvalId && x.approvalId === card.approvalId))) return s;
-      return { ...s, approvals: [...s.approvals, card], seenInbox: { ...s.seenInbox, [card.inboxItemId]: true }, turn: s.turn ? { ...s.turn, approvals: s.turn.approvals + 1 } : s.turn };
+      if (card.foreign) { // another conversation's card: a compact notice, never the focused card
+        if (s.waiting.some(x => x.inboxItemId === card.inboxItemId)) return s;
+        return { ...s, waiting: [...s.waiting, card] };
+      }
+      return { ...s, approvals: [...s.approvals, { ...card, turnId: s.turn?.id ?? null }], seenInbox: { ...s.seenInbox, [card.inboxItemId]: true }, turn: s.turn ? { ...s.turn, approvals: s.turn.approvals + 1 } : s.turn };
+    }
+    case 'approval.gone': { // the server says it no longer knows this approval (404): someone already handled it
+      const hit = x => x.callId === a.callId || (a.inboxItemId && x.inboxItemId === a.inboxItemId);
+      const had = s.approvals.some(hit) || s.waiting.some(hit);
+      const n = { ...s, inbox: (s.inbox || []).filter(x => x.id !== a.inboxItemId), approvals: s.approvals.filter(x => !hit(x)), waiting: s.waiting.filter(x => !hit(x)), seenInbox: a.inboxItemId ? { ...s.seenInbox, [a.inboxItemId]: true } : s.seenInbox };
+      return had ? note(n, 'approval already handled', 'accent') : n;
     }
     case 'approval.dismiss':
       return { ...s, approvals: s.approvals.filter(x => x.callId !== a.callId) };
     case 'approval.sent': { // the human answered from this terminal
-      const rest = { ...s, approvals: s.approvals.filter(x => x.callId !== a.callId) };
+      const rest = { ...s, inbox: (s.inbox || []).filter(x => x.id !== a.inboxItemId), seenInbox: a.inboxItemId ? { ...s.seenInbox, [a.inboxItemId]: true } : s.seenInbox, approvals: s.approvals.filter(x => x.callId !== a.callId && !(a.inboxItemId && x.inboxItemId === a.inboxItemId)), waiting: s.waiting.filter(x => x.callId !== a.callId && x.inboxItemId !== a.callId) };
+      if (a.batch) return rest; // /approve N prints its own one-line summary
+      if (a.quiet && a.action === 'approve') return rest;
       if (a.action !== 'approve') return note(rest, `denied: ${a.tool || 'approval'}${a.target ? ` on ${a.target}` : ''}`, 'warn');
+      if (a.foreign) return note(rest, `✔ Approved ${a.tool || 'approval'}${a.target ? ` on ${a.target}` : ''}; the plugin or agent will act on it (its outcome is not tracked here)`, 'ok');
+      if (a.tool === 'hat.switch') { // applied server-side by the inbox approve; nothing to wait for
+        const to = String(a.target || '').split('\u2192').pop().replace(/\(privileged\)/, '').trim() || 'the new hat';
+        return note(rest, `Hat switched to ${to}. Ask again and I'll carry on.`, 'ok');
+      }
       const run = { callId: a.callId, approvalId: a.approvalId || null, tool: a.tool, target: a.target };
       return note({ ...rest, running: [...rest.running.filter(x => x.callId !== a.callId), run] },
         `approved; running (result arrives asynchronously)${a.tool ? `: ${a.tool}${a.target ? ` on ${a.target}` : ''}` : ''}`, 'ok');
@@ -298,12 +460,15 @@ function reduceInner(s, a) {
       if (a.outcome === 'done') return note(n, `result: ${what}: ${a.text || 'completed'}`, 'ok');
       if (a.outcome === 'failed') return note(n, `failed: ${what}: ${a.text || 'error'}`, 'warn');
       if (a.outcome === 'denied') return note(n, `denied: ${what}`, 'warn');
-      return note(n, `result not known yet: ${what}; check /approvals`, 'warn');
+      // FW4: never silent and never a guess. Say what is unknown and where the authoritative answer is.
+      const check = run && run.approvalId ? `quox approvals result ${run.approvalId} (or /approvals)` : '/approvals (no approval id was returned, so it cannot be tracked from here)';
+      return note(n, `result not known yet: ${what}; approved, but the server has not said whether it ran. It may still be running or may have run. Check: ${check}`, 'warn');
     }
     case 'inbox.sync': { // open approval ids from a successful inbox refresh
       const ids = new Set(a.ids);
       const approvals = s.approvals.filter(x => !x.inboxItemId || ids.has(x.inboxItemId) || (a.now || 0) - x.shownAt < 5000);
-      return approvals.length === s.approvals.length ? s : { ...s, approvals };
+      const waiting = s.waiting.filter(x => ids.has(x.inboxItemId));
+      return approvals.length === s.approvals.length && waiting.length === s.waiting.length ? s : { ...s, approvals, waiting };
     }
     case 'event':
       return reduceEvent(s, a.ev, a.now || 0);
@@ -315,6 +480,11 @@ function reduceInner(s, a) {
 /** The first card is armed from the moment it is actually SHOWN, not from when it was received. */
 export function reduce(s, a) {
   let n = reduceInner(s, a);
+  // TUI-DIVIDER: the bottom-rule AOCL strip, moved only by real turn events (dividerAocl.js).
+  if (a.type === 'turn.begin' || a.type === 'event') {
+    const dv = dividerStep(s.divider ?? null, a, a.now || 0);
+    if (dv !== (n.divider ?? null)) n = { ...n, divider: dv };
+  }
   // The honest activity word: only real events move it (see activity.js).
   if (n.turn) {
     const act = a.type === 'event' ? nextActivity(s.turn?.act, a.ev, a.now || 0, { hasText: Boolean(n.turn.chars) })
@@ -331,12 +501,15 @@ export function reduce(s, a) {
 function reduceEvent(s, ev, now) {
   switch (ev.type) {
     case 'connected': return s;
-    // TODO(contract v2): background.status is not in events v1; wire here once the server defines it.
+    // background.status is not in events v1 yet; handled so the line works the moment the server sends it (RESTORE-TUI: 4fbd3178c dropped it).
+    case 'background.status': return { ...s, background: Math.max(0, Number(ev.pending) || 0) };
     case 'turn.started': {
       const ctx = {
         agent: ev.agent ?? s.ctx.agent, model: ev.model ?? s.ctx.model, provider: ev.provider ?? s.ctx.provider,
         // B3: the host a self-hosted provider ran at; cleared when the server names none.
         endpoint: ev.provider ? (ev.endpoint ?? null) : (s.ctx.endpoint ?? null),
+        // QUOXON-PARITY: which Claude path ran (subscription CLI vs API key); cleared like endpoint.
+        auth: ev.provider ? (ev.auth ?? null) : (s.ctx.auth ?? null),
         hat: ev.hat ?? s.ctx.hat, conversationId: ev.conversation_id ?? s.ctx.conversationId
       };
       // The model THIS turn actually used, as the server reported it (never the profile's default).
@@ -378,13 +551,14 @@ function reduceEvent(s, ev, now) {
     case 'replay.gap':
       return addBlock(s, { kind: 'note', text: `Events ${ev.from} to ${ev.to} of this turn were not kept on the server (size cap); the rest follows.`, tone: 'warn' });
     case 'tool.started':
-      return upsertTool(s, ev, { status: 'running', summary: ev.summary || ev.tool, startedAt: now });
+      return upsertTool(s, ev, { status: 'running', summary: ev.summary || ev.tool, startedAt: now, ...delegateInfo(ev) });
     case 'tool.finished': {
       const status = TOOL_STATUSES.includes(ev.status) ? ev.status : 'unknown'; // never green for a status we do not know
       const first = !s.doneCalls[ev.call_id] && ['ok', 'failed', 'denied'].includes(status);
       let withTool = upsertTool(s, ev, {
-        status, resultSummary: ev.result_summary, durationMs: ev.duration_ms,
-        envelopeId: ev.envelope_id, receipt: ev.receipt || null
+        status, resultSummary: toolResultText(ev.result_summary, s.verbose), rawSummary: ev.result_summary, durationMs: ev.duration_ms,
+        envelopeId: ev.envelope_id, receipt: ev.receipt || null,
+        ...(Number.isFinite(ev.tools_used) ? { toolsUsed: ev.tools_used } : {})
       });
       if (first && withTool.turn) withTool = { ...withTool, turn: { ...withTool.turn, finishedTools: withTool.turn.finishedTools + 1 } };
       if (ev.receipt && ev.receipt.verified === true && withTool.turn && ev.receipt.ward_seq != null) {
@@ -396,7 +570,9 @@ function reduceEvent(s, ev, now) {
       const card = {
         callId: ev.call_id, inboxItemId: ev.inbox_item_id, approvalId: ev.approval_id, tool: ev.tool,
         target: ev.target, scope: ev.scope, risk: ev.risk, url: ev.dashboard_url, shownAt: now,
-        undescribable: ev.describable === false || !ev.target
+        undescribable: ev.describable === false || !ev.target,
+        turnId: s.turn?.id ?? ev.turn_id ?? null, // the turn this card arrived in (a stream event is always this conversation)
+        privileged: isPrivileged({ tool: ev.tool, risk: ev.risk, flag: ev.privileged === true || ev.elevated === true })
       };
       if (s.approvals.some(x => x.callId === card.callId)) return s;
       const dup = s.approvals.findIndex(x => (card.inboxItemId && x.inboxItemId === card.inboxItemId) || (card.approvalId && x.approvalId === card.approvalId));
@@ -404,13 +580,15 @@ function reduceEvent(s, ev, now) {
         const approvals = s.approvals.slice(); approvals[dup] = { ...approvals[dup], callId: card.callId };
         return { ...s, approvals };
       }
+      const wi = card.inboxItemId ? s.waiting.findIndex(x => x.inboxItemId === card.inboxItemId) : -1;
+      if (wi >= 0) s = { ...s, waiting: s.waiting.filter((_, i) => i !== wi) }; // the stream says it is ours after all
       if (card.inboxItemId && s.seenInbox[card.inboxItemId]) return s; // already shown and answered
       return { ...s, seenInbox: card.inboxItemId ? { ...s.seenInbox, [card.inboxItemId]: true } : s.seenInbox, approvals: [...s.approvals, card], turn: s.turn ? { ...s.turn, approvals: s.turn.approvals + 1 } : s.turn };
     }
     case 'approval.resolved': {
       const card = s.approvals.find(x => x.callId === ev.call_id);
       const n = { ...s, approvals: s.approvals.filter(x => x.callId !== ev.call_id) };
-      return card || ev.decision ? note(n, `approval ${ev.decision || 'resolved'}${card ? `: ${card.tool} on ${card.target}` : ''}`, ev.decision === 'approved' ? 'ok' : 'warn') : n;
+      return card || ev.decision ? note(n, `${ev.decision === 'approved' ? '✔ approved by you' : `approval ${ev.decision || 'resolved'}`}${card ? `: ${card.tool} on ${card.target}` : ''}`, ev.decision === 'approved' ? 'ok' : 'warn') : n;
     }
     case 'steer.accepted': {
       const i = s.steering.findIndex(x => x.text === ev.text);
@@ -418,10 +596,27 @@ function reduceEvent(s, ev, now) {
       return addBlock({ ...s, steering }, { kind: 'note', text: `steered: ${ev.text}`, tone: 'accent' });
     }
     case 'trace':
+      // QUOXON-AOCL: per-layer AOCL rows fold into ONE line per turn (aocl.summary); /aocl shows the table.
+      if (ev.protocol === 'volt' && /tools offered/i.test(ev.label || '')) { // kept for the footer count and /aocl, shown only in verbose
+        const m = String(ev.label).match(/(\d+)\s+of\s+(\d+)/);
+        const list = String(ev.detail || '');
+        const toolsOffered = m ? Number(m[1]) : (list ? list.split(/,\s*/).filter(Boolean).length : null);
+        if (s.turn) s = { ...s, turn: { ...s.turn, toolsOffer: { offered: toolsOffered, total: m ? Number(m[2]) : null, list } } };
+      }
+      if (isLayerTrace(ev)) return s.turn ? { ...s, turn: { ...s.turn, aoclTraces: [...(s.turn.aoclTraces || []), { label: ev.label, detail: ev.detail }] } } : s;
       if (s.verbose === 'off') return s;
       return addBlock(s, { kind: 'trace', protocol: ev.protocol, label: ev.label, ref: ev.ref, detail: ev.detail });
+    case 'aocl.summary': {
+      const sum = withTools(normaliseSummary(ev), s.turn);
+      const n = { ...s, lastAocl: sum, turn: s.turn ? { ...s.turn, aoclSummary: true } : s.turn };
+      return addBlock(n, { kind: 'aocl', sum }); // the one-line footer shows at every verbosity
+    }
+    case 'aocl.verdict': {
+      const v = verdictNote(ev);
+      return v.tone === 'error' ? addBlock(s, { kind: 'error', text: v.text }) : addBlock(s, { kind: 'note', text: v.text, tone: v.tone });
+    }
     case 'error': {
-      const n = addBlock(s, { kind: 'error', text: String(ev.error || 'stream error') });
+      const n = addBlock(s, { kind: 'error', text: isConsentError(ev) ? consentErrorText(ev) : String(ev.error || 'stream error') });
       return n;
     }
     case 'turn.finished': case 'done': {
@@ -435,8 +630,16 @@ function reduceEvent(s, ev, now) {
       // `done` only carries text/session; turn.finished (sent just after it) ends the turn. A legacy
       // server never sends turn.finished: the app synthesises one when the stream closes.
       // usage: `done` may carry cost_usd; turn.finished carries `usage` (input/output tokens, maybe cost_usd).
-      if (ev.type === 'done') return { ...n, turn: { ...n.turn, doneCost: ev.cost_usd } };
-      n = { ...n, turn: { ...n.turn, usage: normUsage(ev.usage, n.turn.doneCost) } };
+      // cli_session_id on `done` = the claude CLI path: its cost is that CLI's own estimate even from a server that
+      // does not label it yet (cost_source 'claude-cli', R3 D5).
+      if (ev.type === 'done') return { ...n, turn: { ...n.turn, doneCost: ev.cost_usd, viaCli: Boolean(ev.cli_session_id) } };
+      // An older server sends per-layer AOCL traces and no aocl.summary: fold them into the one line here.
+      if (!n.turn.aoclSummary && n.turn.aoclTraces?.length) {
+        const sum = withTools(summaryFromTraces(n.turn.aoclTraces), n.turn);
+        n = { ...n, lastAocl: sum };
+        n = addBlock(n, { kind: 'aocl', sum });
+      }
+      n = { ...n, turn: { ...n.turn, usage: normUsage(n.turn.viaCli && ev.usage && !ev.usage.cost_source ? { ...ev.usage, cost_source: 'claude-cli' } : ev.usage, n.turn.doneCost) } };
       return endTurn(n, ev.status || 'completed', now);
     }
     default:
@@ -456,3 +659,19 @@ export function approvalKeyAllowed({ now, shownAt, lastKeyAt, heldKey = null, ch
   if (heldKey != null && ch === heldKey && (lastKeyAt == null || now - lastKeyAt < HELD_KEY_MS)) return false;
   return true;
 }
+
+/**
+ * What an approval is for, without repeating who asked: titles often start "<who> wants to: ..." (the source label
+ * already says who), and a generic "Approval required" title falls back to the item's summary or description.
+ */
+export function approvalWhat(it) {
+  const w = it?.payload?.what;
+  if (w && typeof w === 'object' && typeof w.summary === 'string' && w.summary.trim()) { // APPROVAL-WHAT: the server says what will happen
+    const s = w.summary.trim(); const tg = typeof w.target === 'string' ? w.target.trim() : '';
+    return tg && !s.includes(tg) ? `${s} (target: ${tg})` : (!tg && w.target_none ? `${s} (${String(w.target_none).trim()})` : s);
+  }
+  let t = String(it?.title || it?.id || '').replace(/^[^:]{0,80}\bwants to:\s*/i, '').trim();
+  const more = it?.summary || it?.description || it?.detail || '';
+  if ((!t || /^approval (?:required|needed)\b/i.test(t)) && more) t = String(more).trim();
+  return t || String(it?.id || 'approval');
+}

package/lib/quoxon/feedback.js

@@ -0,0 +1,50 @@
+/**
+ * /feedback: tell the Quox team something, through the public quox.ai feedback API
+ * (POST https://api.quox.ai/api/feedback, anonymous, 5 per hour per IP; lands in the quox.ai admin feedback view).
+ * /gripe stays the GitHub path. What is sent is type + message (the CLI version is appended to the message)
+ * and nothing else: no name, email, org, profile or token. The user sees the exact payload and says y first.
+ */
+export const FEEDBACK_URL = 'https://api.quox.ai/api/feedback';
+const MIN = 5, MAX = 5000; // the endpoint refuses outside these (api/routes/feedback.js in quox-website)
+const TIMEOUT_MS = 15000;
+
+/** -> { type:'feedback', message } | null when the endpoint would refuse it. */
+export function feedbackPayload(text, version) {
+  const body = String(text || '').trim();
+  if (body.length < MIN) return null;
+  const message = `${body}\n\n(sent with /feedback from quox CLI ${version || 'unknown'})`;
+  if (message.length > MAX) return null;
+  return { type: 'feedback', message };
+}
+
+/** The lines shown before asking: where it goes and exactly what is in the body. */
+export function feedbackPreview(payload, url = FEEDBACK_URL) {
+  return [
+    `POST ${url}  (the Quox team at quox.ai, not your Quox server)`,
+    'type: feedback',
+    'message:',
+    ...String(payload.message).split('\n').map(l => `  ${l}`),
+    'Nothing else: no name, email, org or token.',
+  ];
+}
+
+/** -> { ok:true, id, url } | { ok:false, message }. Status is checked before the body is trusted. */
+export async function sendFeedback(payload, { fetchImpl = globalThis.fetch, url = FEEDBACK_URL, version = null, timeoutMs = TIMEOUT_MS } = {}) {
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Accept: 'application/json', 'User-Agent': `quox-cli/${version || 'unknown'}` },
+      body: JSON.stringify({ type: payload.type, message: payload.message }),
+      signal: ctl.signal,
+    });
+    let data = null;
+    try { data = await res.json(); } catch { data = null; }
+    if (!res.ok) return { ok: false, message: `HTTP ${res.status}: ${(data && data.error) || 'the feedback API refused it'}` };
+    if (!data || data.success !== true) return { ok: false, message: `HTTP ${res.status} but the reply did not confirm it was stored` };
+    return { ok: true, id: data.id ?? null, url };
+  } catch (e) {
+    return { ok: false, message: e?.name === 'AbortError' ? `no answer from ${url} within ${Math.round(timeoutMs / 1000)} s` : (e?.message || 'failed') };
+  } finally { clearTimeout(t); }
+}

package/lib/quoxon/gallery.js

@@ -1,17 +1,19 @@
 /**
  * `quox motion`: the product version of the animation lab (~/quoxon-work/intro/lab). Plays every Q motion
- * with a caption: Orbit & Lock, Portal, Particle collapse, the Dragon's Eye, the perpetual status Q in its
+ * with a caption: Orbit & Lock, Portal, Particle collapse, the perpetual status Q in its
  * four states, the hello, the composer ring and the reveal effects. No server, no account, nothing sent.
  *
  * Scenes are pure: galleryScenes() returns { id, title, caption, ms, frame(t) -> ANSI lines }. runGallery()
  * is the only part that touches a terminal (cursor, timers, signals).
  */
 import {
-  labSize, orbitCellsAt, portalCellsAt, particleCellsAt, eyeCellsAt, cellsToAnsi, qCells,
-  INTRO_MS, PORTAL_MS, EYE_MS, SKY, VIOLET, AMBER,
+  labSize, orbitCellsAt, portalCellsAt, particleCellsAt, cellsToAnsi, qCells,
+  INTRO_MS, PORTAL_MS, SKY, VIOLET, AMBER,
 } from './qart.js';
 import { qGlyph, glyphAnsi, GLYPH_STATES } from './qglyph.js';
 import { helloCells, helloAnsi, helloGradient, helloMs } from './qhello.js';
+import { CLIPS, MOOD_CLIPS, clipCells, clipCaption } from './qdragonScenes.js';
+import { isLight } from './theme.js';
 
 const RESET = '\x1b[0m';
 const fg = (rgb) => `\x1b[38;2;${rgb.map((v) => Math.max(0, Math.min(255, Math.round(v)))).join(';')}m`;
@@ -125,8 +127,12 @@ export const PERP_MS = 2600;
  * The gallery's scenes for a terminal. narrow forces the 40-column layout (the compact particle Q).
  * Each scene: { id, title, caption, ms, frame(t, { mono }) -> string[] }.
  */
-export function galleryScenes({ cols = 100, rows = 30, narrow = false } = {}) {
+export function galleryScenes({ cols = 100, rows = 30, narrow = false, theme = isLight() ? 'light' : 'dark' } = {}) {
   const W = narrow ? 40 : cols;
+  // the dragon (qdragonScenes.js): eyes as quadrant blocks with a background colour, the lab's light palette on light terminals
+  const fit = (str) => (str.length > W ? str.slice(0, W - 1) + '…' : str);
+  const dragon = (name, t, o) => [...art(clipCells(name, t, { cols: W, theme, mono: o.mono })), '', paint(fit(clipCaption(name, t)), MUTED, o.mono)];
+  const MOOD_SPAN = MOOD_CLIPS.map((m) => CLIPS[m].dur + 400);
   const size = narrow ? 'small' : labSize(W, rows);
   const big = size === 'small' ? 'small' : size;
   const art = (cells) => cellsToAnsi(cells);
@@ -138,8 +144,6 @@ export function galleryScenes({ cols = 100, rows = 30, narrow = false } = {}) {
       frame: (t, o) => art(portalCellsAt(big, t, { color: !o.mono })) },
     { id: 'particle', title: 'Particle collapse', caption: 'density rises on a circle, then collapses into the compact Q', ms: 1100 + 500,
       frame: (t, o) => art(particleCellsAt('small', t, { color: !o.mono })) },
-    { id: 'eye', title: "The Dragon's Eye", caption: 'a slit-pupil eye opens in the bowl, blinks once, and dissolves back into the Q (/eye; rarely on launch)', ms: EYE_MS + 500,
-      frame: (t, o) => art(eyeCellsAt(big, t, { color: !o.mono })) },
     { id: 'hello', title: 'Hello', caption: 'the Q locks, then says hello: the line decodes in from katakana with a short afterglow', ms: INTRO_MS + helloMs(hello) + 600,
       frame: (t, o) => {
         const q = art(t < INTRO_MS ? orbitCellsAt(big, t, { color: !o.mono }) : qCells(big, { color: !o.mono }));
@@ -162,9 +166,19 @@ export function galleryScenes({ cols = 100, rows = 30, narrow = false } = {}) {
       frame: (t, o) => ringLines(Math.min(W - 2, 72), ringState(t), o.mono) },
     { id: 'fx', title: 'Reveal effects', caption: 'tool row, answer drop-in, approval arming, receipt seal, ProofFlow, closing line', ms: FX_MS,
       frame: (t, o) => fxLines(t, Math.min(W - 2, 78), o.mono) },
+    { id: 'dragon', title: CLIPS.pick.title, caption: CLIPS.pick.caption, ms: CLIPS.pick.dur, frame: (t, o) => dragon('pick', t, o) },
+    { id: 'dragon-fire', title: CLIPS.fire.title, caption: CLIPS.fire.caption, ms: CLIPS.fire.dur, frame: (t, o) => dragon('fire', t, o) },
+    { id: 'dragon-moods', title: 'Dragon moods', caption: 'at the cinematic motion level the dragon reacts: wide eyes and an amber glint while it waits for you, a wink when done, a puff of smoke on failure, and a greeting on launch',
+      ms: MOOD_SPAN.reduce((a, b) => a + b, 0),
+      frame: (t, o) => {
+        let i = 0, s0 = 0;
+        while (i < MOOD_CLIPS.length - 1 && t >= s0 + MOOD_SPAN[i]) s0 += MOOD_SPAN[i++];
+        const m = MOOD_CLIPS[i];
+        return [...art(clipCells(m, t - s0, { cols: Math.min(W, 64), theme, mono: o.mono })), '', paint(fit(`${m}: ${CLIPS[m].caption.split(':')[1].replace(/\s*\(.*\)$/, '').trim()}`), MUTED, o.mono)];
+      } },
   ];
 }
-export const SCENE_IDS = ['orbit', 'portal', 'particle', 'eye', 'hello', 'perpetual', 'ring', 'fx'];
+export const SCENE_IDS = ['orbit', 'portal', 'particle', 'hello', 'perpetual', 'ring', 'fx', 'dragon', 'dragon-fire', 'dragon-moods'];
 
 // ---- runner (the only impure part) ---------------------------------------------------------------------------
 const visible = (s) => s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');  // eslint-disable-line no-control-regex