quoxcli 0.5.0 → 0.6.1

package/lib/quoxon/approvalsView.js

@@ -356,6 +356,8 @@ export const NO_REASON = 'No reason given: ask the session, or say no.';
 export const NO_JUSTIFICATION = 'No plain justification given: ask the session, or say no.';
 const justificationOf = (p) => String(p.justification || p.plain_justification || '').replace(/\s+/g, ' ').trim();
 /** ADVICE for a test-edit (loosening) card: only facts the card carries (payload.diff_stats), never the asker's own recommendation, which has its own star line. */
+/** ADVICE for an ordinary decision whose asker starred an option: the star line already shows the asker's pick, so ADVICE must not echo it back as if it were an independent view (owner 2026-11-08: "it's a bad reason"). */
+export const NO_INDEPENDENT_VIEW_ASK = 'No independent view: the star marks the asker\'s own pick. Judge the WHY, or press ? to ask about it.';
 export const NO_INDEPENDENT_VIEW = 'No independent view: judge the JUSTIFY text and the diff (/diff or the files listed).';
 /** The `quox ask loosening` verb titles its card "Approve test edits: <paths>", which isLoosening does not match. */
 const TEST_EDIT_RE = /approve\s+(?:loosening|test)\b/i;
@@ -385,7 +387,7 @@ export function walkCard(it, i, total, { cols = 0 } = {}) {
     : rec && (loose || TEST_EDIT_RE.test(String(it.title || '')))
     ? looseAdvice(p)
     : rec
-    ? `I would ${yn ? (rec.key === 'y' ? 'say yes' : 'say no') : `go with ${optWord(rec)} (${rec.key})`}. The asker recommended it.`
+    ? NO_INDEPENDENT_VIEW_ASK
     : `${who} gave no recommendation, and I will not guess one.${dflt ? ` If nobody answers it would take ${optWord(dflt)} (${dflt.key}).` : ''}`;
   const keyClash = (k) => p.options.some(o => o.key === k);
   const choices = [

package/lib/quoxon/ask.js

@@ -86,7 +86,7 @@ export function askClock(at = Date.now()) {
   return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
 }
 
-/** The one line an ask leaves behind. outcome.kind: yes | no | run | skipped (outcome.cmd) | expired | closed. */
+/** The one line an ask leaves behind. outcome.kind: yes | no | run | skipped (outcome.cmd) | expired | elsewhere (outcome.choice, outcome.at) | closed. */
 export function settledAskLine(question, outcome, at = Date.now()) {
   const q = String(question || '').trim();
   const t = askClock(at);
@@ -97,11 +97,13 @@ export function settledAskLine(question, outcome, at = Date.now()) {
     case 'skipped': return `✔ ${q} skipped, you ran ${String(outcome.cmd || 'a command').split(/\s/)[0]} (${t})`;
     case 'dismissed': return `↷ ${q} offer dismissed (${t})`;
     case 'expired': return `⌛ ${q} expired, not answered (${t})`;
+    // TUI-CARD-SYNC (owner 2026-11-08): answered in another window; the time is when it was answered there, never this settle
+    case 'elsewhere': return `✔ ${q} answered elsewhere (${[outcome.choice || null, Number.isFinite(outcome.at) ? askClock(outcome.at) : null].filter(Boolean).join(', ') || 'by another window'})`;
     default: return `↷ ${q} no longer open (${t})`;
   }
 }
 /** The note tone a settled line is shown in (never dim: no grey text). */
-export const settledAskTone = (kind) => (kind === 'yes' || kind === 'run' ? 'ok' : 'plain');
+export const settledAskTone = (kind) => (kind === 'yes' || kind === 'run' || kind === 'elsewhere' ? 'ok' : 'plain');
 
 /** What a submitted line does to an open ask: { kind } for an answer, or null (c / free text keeps it open). */
 export function askOutcomeOf(text, { runWord = false } = {}) {

package/lib/quoxon/bang.js

@@ -12,6 +12,7 @@
  * is handed the terminal, the same way a slot run request is.
  */
 import { spawn } from 'node:child_process';
+import { isWebPty, SHELL_REFUSED } from './webPty.js';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 
@@ -133,7 +134,12 @@ const STDIN_HINT = /stdin|end of file|\bEOF\b|password|passphrase|\[y\/n\]|\(y\/
  * result: { code, signal, ms, timedOut, killed, lines, truncated, text, stdinNote }
  * onData(text) is called with accepted output only (capped at MAX_LINES / MAX_BYTES); `text` is the same capped capture.
  */
-export function runBang(plan, { cwd = process.cwd(), env = process.env, timeoutMs, onData = () => {}, graceMs = KILL_GRACE_MS, now = Date.now, shell } = {}) {
+export function runBang(plan, { cwd = process.cwd(), env = process.env, timeoutMs, onData = () => {}, graceMs = KILL_GRACE_MS, now = Date.now, shell, columns } = {}) {
+  if (isWebPty(env)) { // QUOXON web PTY: no local process from a browser terminal
+    return { kill: () => {}, done: Promise.resolve({ code: 126, signal: null, ms: 0, timedOut: false, killed: false, lines: 1, truncated: false, text: `${SHELL_REFUSED}\n` }) };
+  }
+  // The child writes to a pipe, so it cannot see the pane width; COLUMNS tells it (tables fit the TUI, owner 2026-11-07).
+  if (Number(columns) > 0) env = { ...env, COLUMNS: String(Math.floor(Number(columns))) };
   const tmo = Number(timeoutMs ?? env.QUOX_BANG_TIMEOUT_MS ?? DEFAULT_TIMEOUT_MS) || DEFAULT_TIMEOUT_MS;
   const t0 = now();
   let file, args;

package/lib/quoxon/commandShort.js

@@ -64,7 +64,7 @@ export const SHORT = {
   leave: 'leave a slot room you joined',
   rooms: 'rooms this window has joined, with unread counts',
   broadcast: 'tell every held slot in this org at once',
-  page: 'urgent message to one slot, with acknowledgement',
+  page: 'urgent message to one or more slots, acked',
   ack: 'acknowledge a broadcast',
   send: 'send a local text file into a slot (64 KB cap)',
   attach: 'send your turns to a specific agent',

package/lib/quoxon/commands.js

@@ -63,7 +63,7 @@ const ARGS = {
   broadcast: [{ after: [], choices: [{ value: '--slots', desc: 'only these slots, comma separated' }, { value: '--priority', desc: 'urgent shows red' }, { value: '--ack', desc: 'ask recipients to /ack' }, { value: '--active', desc: 'only sessions listening now; dormant are skipped' }, { value: '--dry-run', desc: 'with --active: list who would be reached, send nothing' }] }],
   send: [{ after: [], src: 'slots' }, { after: ['*'], src: 'files', of: 'partial' }],
   dragon: [
-    { after: [], choices: ['explain', 'ask', 'sleep', 'fly', 'hero', 'fire', 'classic', { value: 'companion', desc: 'the dragon beside an attached Lucid, Hyperion, Seer, Sentinel, Drago, Cipher, Vulcan or Quoxperticus' }] },
+    { after: [], choices: ['explain', 'ask', 'sleep', 'fly', 'hero', 'fire', 'classic', { value: 'companion', desc: 'the dragon beside an attached Lucid, Hyperion, Seer, Sentinel, Drago, Cipher, Vulcan, Quoxperticus, Janus, Archivist, Architect, Roady or Weaver' }] },
     { after: ['companion'], choices: [{ value: 'on', desc: 'on attach and key moments, then leaves' }, { value: 'greeting', desc: 'only on attach, then leaves' }, { value: 'off', desc: 'never on its own (/dragon shows it)' }, { value: 'status', desc: 'what is set and whether the art loads' }] }
   ],
   ext: [
@@ -71,7 +71,7 @@ const ARGS = {
     { after: ['on'], src: 'ext.listed' }, { after: ['off'], src: 'ext.loaded' }, { after: ['tab'], src: 'ext.panels' },
     { after: ['set'], src: 'ext.loaded' }, { after: ['settings'], src: 'ext.loaded' }, { after: ['set', '*'], src: 'ext.keys', of: 1 }
   ],
-  inbox: [{ after: [], choices: [{ value: 'read', desc: 'read N | all: mark items read' }, { value: 'open', desc: 'open N: take an approval to /approvals' }, { value: 'latest', desc: 'the latest 10' }, { value: 'mute', desc: 'mute <from> [1h|8h|1d]: no arrival lines from that source (approvals never muted)' }, { value: 'unmute', desc: 'unmute <from>' }, { value: 'mutes', desc: 'muted sources and when they expire' }] }, { after: ['mute'], src: 'inbox.sources' }, { after: ['unmute'], src: 'inbox.mutes' }],
+  inbox: [{ after: [], choices: [{ value: 'show', desc: 'show N: the whole item (same as /inbox N)' }, { value: 'read', desc: 'read N | all: mark items read (does not show them)' }, { value: 'open', desc: 'open N: an approval goes to /approvals, any other item is shown' }, { value: 'latest', desc: 'the latest 10' }, { value: 'mute', desc: 'mute <from> [1h|8h|1d]: no arrival lines from that source (approvals never muted)' }, { value: 'unmute', desc: 'unmute <from>' }, { value: 'mutes', desc: 'muted sources and when they expire' }] }, { after: ['mute'], src: 'inbox.sources' }, { after: ['unmute'], src: 'inbox.mutes' }],
   tips: [{ after: [], choices: topicList().map(t => ({ value: t.topic, desc: `${t.count} tip${t.count === 1 ? "" : "s"}` })) }],
   whatsnew: [{ after: [], choices: [{ value: 'all', desc: 'every command and entry, regardless of seen' }, { value: 'on', desc: 'show the card at startup when something is new' }, { value: 'off', desc: 'stop the startup card' }] }],
   'tip-settings': [{ after: [], choices: [
@@ -133,7 +133,7 @@ export const REGISTRY = [
   // Approvals
   { id: 'approvals', kind: 'command', group: 'Approvals', usage: '/approvals [mine|agents|old|<agent>|N|auto on|off]', desc: 'the questions waiting for you, one at a time', server: true, cap: 'approvals', status: 'active',
     detail: 'New approvals and questions open by themselves as the one-at-a-time card (after your draft, typing pause or turn; never mid-typing, never answered for you), including ones in your other orgs, which are answered there without switching. /approvals auto off keeps them as the ⏸ line; the setting is saved on this profile.' },
-  { id: 'inbox', kind: 'command', new: true, group: 'Approvals', usage: '/inbox [N | read N|N-M|all | open N | mute <from> [1h|8h|1d] | unmute <from> | mutes]', desc: 'your Quox inbox: the latest 10 as a table, N shows one in full, read marks read, open takes an approval to /approvals; mute silences a source\'s arrival lines (default 8h, approvals never muted), repeats of the same title collapse to (×N)', needs: ['inboxItems'], cap: 'approvals', status: 'active', args: ARGS.inbox },
+  { id: 'inbox', kind: 'command', new: true, group: 'Approvals', usage: '/inbox [N | show N | read N|N-M|all | open N | mute <from> [1h|8h|1d] | unmute <from> | mutes]', desc: 'your Quox inbox: the latest 10 as a table, N (or show N, N show) shows one in full, read marks read without showing, open takes an approval to /approvals and shows any other item; mute silences a source\'s arrival lines (default 8h, approvals never muted), repeats of the same title collapse to (×N)', needs: ['inboxItems'], cap: 'approvals', status: 'active', args: ARGS.inbox },
   { id: 'mail', kind: 'command', new: true, group: 'Approvals', usage: '/mail [N | focus|fyi|auto|screened]', desc: 'your triaged email (InboxQ), read only: the latest 10, N reads one with its triage reason', needs: ['mailMessages'], status: 'active' },
   { id: 'walkthrough', kind: 'command', new: true, group: 'Approvals', usage: '/walkthrough', desc: 'walk through what is waiting for you one question at a time: what it does, why, my advice, then your choice (same as /approvals walkthrough)', server: true, cap: 'approvals', status: 'active' },
   { id: 'yestoall', kind: 'command', new: true, group: 'Approvals', usage: '/yestoall', desc: 'approve everything waiting for you (same as /approve all; privileged ones still ask)', server: true, cap: 'approvals', status: 'active' },
@@ -252,7 +252,7 @@ export const REGISTRY = [
   { id: 'rooms', kind: 'command', new: true, group: 'Conversation', usage: '/rooms', desc: 'rooms (groups) this window has joined, with unread counts; also on the status line', needs: ['slotSay'], cap: 'slots', status: 'active', aliases: ['groups'] },
   { id: 'broadcast', kind: 'command', new: true, group: 'Conversation', usage: '/broadcast [--slots a,b] [--priority urgent] [--ack] [--active [--dry-run]] <text>', desc: 'tell every held slot in this org at once, signed as you', needs: ['slotBroadcast'], cap: 'slots', status: 'active', aliases: ['roar', 'broadcast-active'], args: ARGS.broadcast,
     detail: 'One server call delivers to every slot held in this org (never another org), or only --slots a,b. --priority urgent marks it red for recipients. --ack asks them to reply /ack <id>; you then see "Broadcast delivery: delivered N / acknowledged M / awaiting K" update. You get a framed card: how many sessions have it (stored in the slot, listening sessions see it at once) and a separate chat-rooms count (sent / sending / failed). /broadcast status <id> redraws it. Typing it is your consent. --active (or /broadcast-active) reaches only sessions listening right now (a live slot wait); dormant slots are skipped and not woken, and the card says how many. --dry-run (with --active) lists who would be reached and who is skipped, and sends nothing. Not yet: --at (schedule), --fleet, --org, --voice.' },
-  { id: 'page', kind: 'command', new: true, group: 'Conversation', usage: '/page <slot> <text>', desc: 'urgent message to one slot, acknowledgement requested', needs: ['slotBroadcast'], cap: 'slots', status: 'active', args: ARGS.say,
+  { id: 'page', kind: 'command', new: true, group: 'Conversation', usage: '/page <slot>[,<slot>...] <text>', desc: 'urgent message to one or more slots (a,b,c or a b c), acknowledgement requested', needs: ['slotBroadcast'], cap: 'slots', status: 'active', args: ARGS.say,
     detail: 'Like /broadcast to a single slot with --priority urgent --ack: it shows red there, asks them to /ack, and you see when they have.' },
   { id: 'ack', kind: 'command', new: true, group: 'Conversation', usage: '/ack <broadcast id>', desc: 'acknowledge a broadcast, as the slot this window holds', needs: ['slotAck'], cap: 'slots', status: 'active',
     detail: 'The id is in the broadcast line ("ack with /ack bc_...").' },
@@ -335,7 +335,7 @@ export const REGISTRY = [
     detail: '/org lists the orgs your login belongs to. /org switch <name or id> matches loosely, asks y/N (or /org yes), then re-scopes the login (the same exchange as quox org switch) and starts a new conversation in that org; the status line shows the org. /org back (or /org -) returns to the org you were in before, with the same single y/N. A switch only succeeds for orgs you are a member of; the server decides.' },
   { id: 'statusline', kind: 'key', group: 'Context', usage: 'status line', desc: 'profile · org · agent · model · mode, under the composer', status: 'active' },
   { id: 'r', kind: 'command', new: true, group: 'Conversation', usage: '/r <text>', desc: 'reply to whoever last messaged you (slot or room); also /reply', needs: ['slotSay'], cap: 'slots', status: 'active', aliases: ['reply'] },
-  { id: 'poke', kind: 'command', new: true, group: 'Conversation', usage: '/poke <slot or session> [text]', desc: 'wake a session: an urgent page asking it to acknowledge (also /wake, /nudge, /ping)', needs: ['slotBroadcast'], cap: 'slots', status: 'active', aliases: ['wake', 'nudge', 'ping', 'slap', 'awaken'] },
+  { id: 'poke', kind: 'command', new: true, group: 'Conversation', usage: '/poke <slot>[,<slot>...] [text]', desc: 'wake one or more sessions (a,b,c or a b c): an urgent page asking each to acknowledge (also /wake, /nudge, /ping)', needs: ['slotBroadcast'], cap: 'slots', status: 'active', aliases: ['wake', 'nudge', 'ping', 'slap', 'awaken'] },
   { id: 'afk', kind: 'command', new: true, group: 'Context', usage: '/afk [note]', desc: 'tell sessions you are away (they stop waiting on approvals, which still queue); /back then shows everything since, grouped', status: 'active',
     detail: 'Sets your presence on the server (per user and org): sessions saying into hitl, triage-q or this window\'s slot see "owner away since 15:54 UTC (note): approvals will queue"; `quox presence`, `quox slot list`, quox ask and agents see it too. Nothing is approved while you are away. /back or any typed message marks you present.' },
   { id: 'donotdisturb', kind: 'command', new: true, group: 'Context', usage: '/donotdisturb [on|off] [until HH:MM]', desc: 'sleep means sleep: collect arrivals quietly (no notices, cards, bells) until you ask for /morningreport; also /dnd', status: 'active', aliases: ['dnd'],

package/lib/quoxon/delegationDragon.js

@@ -0,0 +1,49 @@
+/**
+ * Owner 2026-11-08: with dragons on, CommanderQ handing a turn to a specialist shows a small STATIC dragon in the chat
+ * stream, above the delegation row, with one line naming the hand-off. No animation and no timers: the art is drawn once
+ * with the row. Dragons off (the /dragon companion setting, or lite mode) changes nothing.
+ * The decision is stamped on the tool.started event when it arrives (markDelegationDragon) so a row printed once keeps
+ * its dragon, and the pure reducer never reads settings.
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { companionMode, motionPolicy } from '../dragon/select.js';
+import { c } from './theme.js';
+
+const h = React.createElement;
+
+/** Below this many columns the art is dropped; the hand-off line stays. */
+export const DRAGON_ART_MIN_COLS = 40;
+
+/** Original compact dragon, plain ASCII so every terminal draws it at the width it says. */
+export const DELEGATION_DRAGON_ART = Object.freeze([
+  '      __/\\__/\\',
+  '  ___/ o      \\~~<',
+  ' <___   ___/\\  \\',
+  '     \\_/    \\_/\\_\\'
+]);
+
+/** Dragons on = the companion mode is on or greeting, and decoration is not off (lite or a dumb terminal). Same rule as /detach's greeting. */
+export function delegationDragonOn(settings = {}, env = process.env) {
+  return companionMode(settings, env) !== 'off' && !motionPolicy(env).off;
+}
+
+/** A delegate_to_agent tool.started action gains ev.dragon when dragons are on. Anything else comes back as the same object. */
+export function markDelegationDragon(a, on) {
+  if (!on || a?.type !== 'event' || a.ev?.type !== 'tool.started' || a.ev.tool !== 'delegate_to_agent') return a;
+  return { ...a, ev: { ...a.ev, dragon: true } };
+}
+
+/** The lines a marked delegation row draws above itself: art (when it fits), then the hand-off line. [] = none. */
+export function delegationDragonLines(b, cols) {
+  if (!b?.dragon || !b.agentName) return [];
+  const art = cols >= DRAGON_ART_MIN_COLS ? DELEGATION_DRAGON_ART.map(text => ({ text, art: true })) : [];
+  return [...art, { text: `\u{1F409} CommanderQ hands this to ${b.agentName}`, art: false }];
+}
+
+export function DelegationDragon({ b, cols }) {
+  const lines = delegationDragonLines(b, cols);
+  if (!lines.length) return null;
+  return h(Box, { flexDirection: 'column', paddingLeft: 2 },
+    ...lines.map((l, i) => h(Text, { key: i, wrap: 'truncate-end', color: c(l.art ? 'violet' : 'text'), bold: !l.art }, l.text)));
+}

package/lib/quoxon/dnd.js

@@ -69,3 +69,50 @@ export function morningLines(c, { approvals = 0, sessions = [] } = {}) {
   if (!lines.length) lines.push(['Nothing collected while you were away.', 'ok']);
   return lines;
 }
+
+const oneLine = (t, n = 80) => { const s = String(t || '').replace(/\s+/g, ' ').trim(); return s.length > n ? `${s.slice(0, n - 1)}…` : s; };
+
+/** Slot messages grouped per sender, newest sender first: [{ from, n, text (latest), ts }]. */
+export function slotsBySender(slots) {
+  const m = new Map();
+  for (const s of slots || []) {
+    const from = String(s.from || 'slot'), ts = Number(s.ts) || 0, g = m.get(from);
+    if (!g) m.set(from, { from, n: 1, text: s.text, ts });
+    else { g.n += 1; if (ts >= g.ts) { g.text = s.text; g.ts = ts; } }
+  }
+  return [...m.values()].sort((a, b) => b.ts - a.ts);
+}
+
+/**
+ * The since-last-seen digest when nothing was held (do not disturb was off). Owner 2026-11-09: a morning report must
+ * not depend on DND. Order: approvals waiting, slot messages to you (per sender, newest first), sessions that need you,
+ * incidents. Each section is capped with a "+N more" pointer. [[text, tone]].
+ * approvals/incidents: [{ title }]; slots: [{ from, text, ts }]; sessions: [string].
+ */
+export function sinceLines({ approvals = [], slots = [], sessions = [], incidents = [] } = {}, { maxApprovals = 3, maxSenders = 5, maxSessions = 5, maxIncidents = 3 } = {}) {
+  const lines = [];
+  const more = (n, ptr) => lines.push([`  +${n} more${ptr ? ` · ${ptr}` : ''}`, 'dim']);
+  if (approvals.length) {
+    lines.push([`Approvals waiting (${approvals.length})`, 'warn']);
+    for (const a of approvals.slice(0, maxApprovals)) lines.push([`  ${oneLine(a.title || a.summary || a.id || 'approval')}`, 'plain']);
+    if (approvals.length > maxApprovals) more(approvals.length - maxApprovals, '/approvals');
+  }
+  if (slots.length) {
+    const g = slotsBySender(slots);
+    lines.push([`Slot messages to you (${slots.length})`, 'plain']);
+    for (const s of g.slice(0, maxSenders)) lines.push([`  ${s.from}${s.n > 1 ? ` ×${s.n}` : ''}: ${oneLine(s.text)}`, 'plain']);
+    if (g.length > maxSenders) lines.push([`  +${g.length - maxSenders} more senders`, 'dim']);
+  }
+  if (sessions.length) {
+    lines.push([`Sessions that need you (${sessions.length})`, 'warn']);
+    for (const s of sessions.slice(0, maxSessions)) lines.push([`  ${oneLine(s)}`, 'plain']);
+    if (sessions.length > maxSessions) more(sessions.length - maxSessions, '/sitrep');
+  }
+  if (incidents.length) {
+    lines.push([`Incidents (${incidents.length})`, 'warn']);
+    for (const i of incidents.slice(0, maxIncidents)) lines.push([`  ${oneLine(i.title || i.kind)}`, 'plain']);
+    if (incidents.length > maxIncidents) more(incidents.length - maxIncidents, '/away');
+  }
+  if (!lines.length) lines.push(['Nothing is waiting on you since you were last here.', 'ok']);
+  return lines;
+}

package/lib/quoxon/dragonCompanion.js

@@ -1,5 +1,5 @@
 /**
- * Dragon companion for Quoxon (Lucid, Hyperion, Seer, Sentinel, Drago, Cipher, Vulcan, Quoxperticus). The controller owns attach state and feeds REAL stream
+ * Dragon companion for Quoxon (Lucid, Hyperion, Seer, Sentinel, Drago, Cipher, Vulcan, Quoxperticus, Janus, Archivist, Architect, Roady, Weaver). The controller owns attach state and feeds REAL stream
  * events to dragonlab's pure view (integration/companions-v1/view.mjs: the same reducer and renderer the CLI
  * uses). No art, state logic or timers are duplicated here; this file only decides, translates and lays out.
  * Decisions: docs/dragons/COMPANION-UX.md. The reducer never overwrites pending approvals or failures, but the host only SHOWS the dragon during a dwell (attach, key moment, invoke).
@@ -226,20 +226,33 @@ export function createCompanionController({ settings = () => ({}), env = process
       const mood = job?.mood === 'concerned' && !state.approvals.length ? 'concerned' : null;
       try { v = view.view(state, t, { cols, rows: big ? rows : 1, mood }); } catch { return null; }
       if (v.hidden) return null;
-      // One caption per trigger: "Attached." only on an attach; an invoke says who is here; an approval always says so.
-      let caption = v.caption;
-      const summonedCaption = summonCaption;
-      if (state.approvals.length) caption = 'Waiting for your approval.';
-      else if (job?.caption && !state.issue) caption = job.caption; // the dragon's job: a real read (jobs.js); an approval or a recorded failure still comes first
-      else if (state.phase === 'connecting') caption = trigger === 'attach' ? 'Attached.' : trigger === 'invoke' ? `${view.name} is here.` : v.caption;
-      if (summonedCaption && now() < showUntil) caption = summonedCaption; // a domain moment states its own fact
-      if (!big) return { kind: 'label', text: `${view.name}: ${caption}` };
+      // Owner, 2026-11-10: no caption by default. A caption only names a real event: an approval waiting, a failed step, a stream that
+      // ended with the outcome unknown, a job read that found something wrong, or a domain moment's own fact. Idle, arrival, generic
+      // work, power flourishes, mottos and calm job reads say nothing (the reducer's own captions are never shown).
+      const summonedCaption = summonCaption && now() < showUntil ? summonCaption : null; // a domain moment states its own fact
+      const caption = summonedCaption || eventCaption(state, job);
+      if (!big) return caption ? { kind: 'label', text: `${view.name}: ${caption}` } : null;
       if (!v.frame) { waitingFrame = true; return null; } // the first frame is still being drawn off the main thread: draw nothing rather than a gap
       return { kind: 'art', frame: v.frame, caption, name: view.name };
     },
   };
 }
 
+/**
+ * The only captions the companion shows: each names a real host event. -> string | null. Pure.
+ * Allowlist, in priority order: an approval waiting, a failed step (an error, a failed tool or turn, a denied approval), a stream that
+ * ended without a verified outcome, a job read that found something wrong. Anything else (idle, arrival, working, thinking, power
+ * flourishes, mottos, a calm job read) is null.
+ */
+export function eventCaption(state, job = null) {
+  if (!state) return null;
+  if (state.approvals?.length) return 'Waiting for your approval.';
+  if (state.issue || state.phase === 'error') return 'That step failed.';
+  if (state.phase === 'disconnected') return 'Stream ended, outcome unknown.';
+  if (job?.mood === 'concerned' && job.caption) return job.caption;
+  return null;
+}
+
 /** "/dragon companion <arg>" -> { text, tone, save?, refresh? }. Pure. */
 export function companionCommand(arg, { settings = {}, plan = null, artProblem = null } = {}) {
   // `invoke: true` = the host also plays the attached agent's dragon for a dwell (a status check is a call for the dragon too).
@@ -249,7 +262,7 @@ export function companionCommand(arg, { settings = {}, plan = null, artProblem =
     const mode = cur || plan?.mode || 'on';
     const now = plan?.enabled ? `showing ${plan.id}` : `not showing (${plan?.why || 'no agent attached'})`;
     if (artProblem && mode !== 'off') return { text: `Dragon companion: ${mode}, but the art can't be loaded so no dragon will show (${artProblem}). /dragon companion on|greeting|off.`, tone: 'warn' };
-    return { text: `Dragon companion: ${mode}, ${now}. /dragon companion on|greeting|off. Only Lucid, Hyperion, Seer, Sentinel, Drago, Cipher, Vulcan and Quoxperticus have dragons.`, invoke: true };
+    return { text: `Dragon companion: ${mode}, ${now}. /dragon companion on|greeting|off. Only Lucid, Hyperion, Seer, Sentinel, Drago, Cipher, Vulcan, Quoxperticus, Janus, Archivist, Architect, Roady and Weaver have dragons.`, invoke: true };
   }
   const m = normaliseMode(w);
   if (!m) return { text: `Usage: /dragon companion ${COMPANION_MODES.join('|')}|status`, tone: 'warn' };
@@ -270,8 +283,7 @@ export function DragonCompanionLive({ ctl, cols, rows }) {
   return h(Box, { flexDirection: 'row', marginTop: 1 },
     h(Box, { flexDirection: 'column', flexShrink: 0 }, ...snap.frame.map((r, k) => h(Text, { key: k, wrap: 'truncate' }, ...cellNodes(r, `dc${k}-`)))),
     h(Box, { flexDirection: 'column', paddingLeft: 2 },
-      h(Text, { bold: true }, snap.name.toUpperCase()),
-      h(Text, { wrap: 'wrap' }, snap.caption)));
+      ...(snap.caption ? [h(Text, { key: 'n', bold: true }, snap.name.toUpperCase()), h(Text, { key: 'c', wrap: 'wrap' }, snap.caption)] : [])));
 }
 
 /**

package/lib/quoxon/events.js

@@ -119,6 +119,13 @@ export function describeInboxItem(it) {
  * Qualifies when created after `since` (the turn start, else app start), or raised on behalf of this
  * user, or in this conversation. The inbox list is already scoped to the signed-in user and org.
  */
+/** The contact-consent proposal on an inbox item (proposeOptin.js), or null. It has no executor: the TUI records the grant. */
+export function consentOf(it) {
+  const p = it?.payload || {};
+  if (p.kind_detail !== 'contactability_optin' || !p.recipient || !p.channel) return null;
+  return { recipient: String(p.recipient), channel: String(p.channel), proposed: p.proposed && typeof p.proposed === 'object' ? p.proposed : {} };
+}
+
 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
@@ -138,6 +145,7 @@ export function cardFromInboxItem(it, { since = 0, userId = null, conversationId
   const tool = d.tool || String(it.title || it.id);
   return {
     callId: `inbox:${it.id}`, inboxItemId: it.id, approvalId,
+    consent: consentOf(it), // a contact-consent proposal: approving records nothing until the person gives the lawful basis
     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 && !it._plan,
     plan: it._plan ? { lines: planLines(it._plan.steps), loaded: it._plan.loaded !== false, orgId: it._plan.orgId || null, orgName: it._plan.orgName || null } : null, // the plan's steps + the item's own org
@@ -260,7 +268,7 @@ 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 } : {}) };
+  return { agentId: id, agentName: ev.agent_name || id, ...(ev.task_gist ? { taskGist: ev.task_gist } : {}), ...(ev.dragon === true ? { dragon: true } : {}) };
 }
 
 function upsertTool(s, ev, patch) {
@@ -473,6 +481,8 @@ function reduceInner(s, a) {
       return { ...s, approvals: s.approvals.filter(x => x.callId !== a.callId) };
     case 'approval.sent': { // the human answered from this terminal
       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.notRecorded) return note(rest, a.notRecorded, 'warn'); // the server answered 2xx but did not record the yes
+      if (a.consent && a.action === 'approve') return note(rest, `approved, but no consent is recorded yet: ${a.consent.recipient} via ${a.consent.channel} needs the lawful basis. Type it now (one line), or n to leave it unrecorded.`, 'warn');
       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, approvalSentence(a, false), 'warn');
@@ -496,6 +506,7 @@ function reduceInner(s, a) {
       if (a.outcome === 'done') return note(n, `result: ${what}: ${a.text || 'completed'}`, 'ok');
       if (a.outcome === 'failed') return note(n, `${Number.isInteger(a.exit) && a.exit >= 1 ? `ran, exit ${a.exit}` : 'failed'}: ${what}: ${a.text || 'error'}`, 'warn');
       if (a.outcome === 'denied') return note(n, `denied: ${what}`, 'warn');
+      if (a.outcome === 'unrecorded') return note(n, `not run: ${what}. Your yes was saved in your inbox but never reached the tool runner: the server still shows the approval pending, with nobody recorded as deciding. Nothing ran. Ask the agent again for a fresh approval. Check: quox approvals result ${run && run.approvalId ? run.approvalId : '(no id)'}`, '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');

package/lib/quoxon/extensions.js

@@ -10,6 +10,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { pathToFileURL, fileURLToPath } from 'node:url';
+import { isWebPty, EXTENSIONS_REFUSED } from './webPty.js';
 
 export const THROTTLE_MS = 1000;
 export const RELOAD_DEBOUNCE_MS = 2000; // fs.watch burst -> one check
@@ -156,6 +157,7 @@ export function findPackageJson(entry) {
  * -> { ok:true, mod, where } | { ok:false, notFound:true, tried:[...] } | { ok:false, error }
  */
 export async function resolveExtension(name, { env = process.env, importer = defaultImporter, execPath = process.execPath, npmRoot = globalNpmRoot, exists = fs.existsSync } = {}) {
+  if (isWebPty(env)) return { ok: false, error: EXTENSIONS_REFUSED, tried: [] }; // QUOXON web PTY: no module loads from a browser terminal
   const tried = [];
   const ov = env?.[envKey(name)];
   if (ov) {

package/lib/quoxon/foreignText.js

@@ -0,0 +1,49 @@
+/**
+ * QUOXON (owner 2026-11-09, "this was messy.. what even is that?"): text written by ANOTHER session (slot messages,
+ * broadcasts, room lines, loop observe lines) can carry terminal colour codes: a QuoxGlyph announce line printed
+ * with 24-bit SGR colour. Real escapes would repaint this window; escapes whose ESC byte was dropped on the way
+ * show as text (`1m38;2;56;189;248mG...0m 2m│0m`). Both are stripped here, never recoloured.
+ *
+ * Remnants are removed only in shapes that are never prose: a 24-bit/256 colour run (`38;2;R;G;Bm`), a run of two
+ * or more SGR tokens, or a lone reset/bold/dim token (`0m`, `1m`, `2m`) glued to a letter or glyph before it, or to
+ * a glyph or box character after it. "ran 5m ago", "10m", "2m 30s", "(2m)", "2min" stay as they are.
+ */
+
+const OSC = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g;
+const CSI = /(?:\x1b\[|\x9b)[0-?]*[ -/]*[@-~]/g;
+const STR = /\x1b[PX^_][^\x1b]*(?:\x1b\\)?/g;
+const ESC2 = /\x1b[@-Z\\-_]?/g;
+
+// A run of SGR-shaped tokens with their ESC (and maybe their `[`) lost.
+const RUN = /\[?\d{1,3}(?:;\d{1,3})*m(?:\[?\d{1,3}(?:;\d{1,3})*m)*/g;
+const TOKEN = /\[?\d{1,3}(?:;\d{1,3})*m/g;
+const COLOUR = /(?:^|;)(?:38|48|58);(?:2;\d{1,3};\d{1,3};\d{1,3}|5;\d{1,3})m$/;
+const LONE = /^\[?[012]m$/;
+const LETTER = /\p{L}/u;
+const ASCII = /[\x00-\x7f]/;
+
+function remnant(run, before, after) {
+  const toks = run.match(TOKEN) || [];
+  if (toks.length >= 2) return true;
+  const t = toks[0] || '';
+  if (COLOUR.test(t.replace(/^\[/, ''))) return true;
+  if (!LONE.test(t)) return false;
+  // glued before: a letter ("E0m") or a non-ASCII glyph ("│0m", "✔0m"); never a space, digit or ASCII punctuation
+  const gluedBefore = before !== '' && (LETTER.test(before) || !ASCII.test(before)) && !/\s/.test(before);
+  // glued after: a non-ASCII glyph or box character ("2m│"); never a letter ("2min"), space or punctuation
+  const gluedAfter = after !== '' && !ASCII.test(after) && !LETTER.test(after) && !/\s/.test(after);
+  return gluedBefore || gluedAfter;
+}
+
+/** Text from another session, with every terminal escape and every orphaned colour-code remnant removed. */
+export function stripForeignAnsi(text) {
+  let t = String(text ?? '');
+  if (!t) return t;
+  t = t.replace(OSC, '').replace(CSI, '').replace(STR, '').replace(ESC2, '');
+  if (!/\d+m/.test(t)) return t;
+  return t.replace(RUN, (run, off, s) => {
+    const before = [...s.slice(Math.max(0, off - 2), off)].pop() || '';
+    const after = [...s.slice(off + run.length, off + run.length + 2)][0] || '';
+    return remnant(run, before, after) ? '' : run;
+  });
+}

package/lib/quoxon/inboxView.js

@@ -100,7 +100,7 @@ export function inboxTable(items, now = Date.now(), cols = 100, max = 10, mutes
     out.push({ text: `${un ? '●' : ' '} ${pad(i + 1, 3)}${pad(ageOf(it.created_at ?? it.createdAt, now), 6)}${pad(fromOf(it), 14)}${pad(shown, tw)} ${un ? 'unread' : (it.status || 'read')}${mu ? ' (muted)' : ''}`, tone: un && !mu ? 'accent' : 'dim' });
   });
   const un = unreadItems(items).filter((i) => !isMuted(i, mutes, now)).length;
-  out.push({ text: `${un} unread · /inbox N open one · /inbox read N|all · /inbox unread N|all · /inbox open N (approvals) · /inbox mute <from> [1h|8h|1d] · email is /mail`, tone: 'dim' });
+  out.push({ text: `${un} unread · /inbox N or /inbox show N reads one · /inbox read N|all marks · /inbox unread N|all · /inbox open N (approvals) · /inbox mute <from> [1h|8h|1d] · email is /mail`, tone: 'dim' });
   return out;
 }
 
@@ -130,7 +130,7 @@ export function parseInbox(arg) {
     const dur = m[3] === undefined ? MUTE_DEFAULT_MS : muteDuration(m[3]);
     return dur ? { kind: 'mute', source: m[2], ms: dur } : { kind: 'usage' };
   }
-  m = /^(?:show\s+)?#?(\d+)$/.exec(a); if (m) return { kind: 'show', n: Number(m[1]) };
+  m = /^(?:(?:show|view)\s+)?#?(\d+)$/.exec(a); if (m) return { kind: 'show', n: Number(m[1]) };
   m = /^(open|read|unread)\s+(.+)$/.exec(a);
   if (m) {
     if ((m[1] === 'read' || m[1] === 'unread') && m[2] === 'all') return { kind: m[1], all: true };
@@ -138,16 +138,16 @@ export function parseInbox(arg) {
     if (m[1] === 'open') return ns.length === 1 ? { kind: 'open', n: ns[0] } : { kind: 'usage' };
     return one(m[1], ns);
   }
-  m = /^(.+?)\s+(open|read|unread|show)$/.exec(a); // word order: /inbox 1 open, /inbox 5-8 read
+  m = /^(.+?)\s+(open|read|unread|show|view)$/.exec(a); // word order: /inbox 1 open, /inbox 5-8 read, /inbox 1 show
   if (m) {
     const ns = parseNumbers(m[1]); if (!ns) return { kind: 'usage' };
     if (m[2] === 'open') return ns.length === 1 ? { kind: 'open', n: ns[0] } : { kind: 'usage' };
-    if (m[2] === 'show') return ns.length === 1 ? { kind: 'show', n: ns[0] } : { kind: 'usage' };
+    if (m[2] === 'show' || m[2] === 'view') return ns.length === 1 ? { kind: 'show', n: ns[0] } : { kind: 'usage' };
     return one(m[2], ns);
   }
   return { kind: 'usage' };
 }
-export const INBOX_USAGE = 'Usage: /inbox | /inbox N | /inbox read N|N-M|all | /inbox unread N|N-M|all (undo a read) | /inbox open N (or /inbox 1 open, /inbox 1 read, /inbox 1 unread) | /inbox mute <from> [1h|8h|1d] | /inbox unmute <from> | /inbox mutes (email is /mail)';
+export const INBOX_USAGE = 'Usage: /inbox | /inbox N or /inbox show N or /inbox N show (the whole item) | /inbox read N|N-M|all (marks read, does not show) | /inbox unread N|N-M|all (undo a read) | /inbox open N (an approval goes to /approvals; shows any other item) | /inbox mute <from> [1h|8h|1d] | /inbox unmute <from> | /inbox mutes (email is /mail)';
 
 /** The first non-empty string among the item's own body fields and the payload's (body_md is the stored column every task/info item uses). */
 const bodyOf = (it) => {

package/lib/quoxon/launcher.js

@@ -18,6 +18,7 @@ import { spawn } from 'node:child_process';
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir, constants as osConstants } from 'node:os';
 import { join } from 'node:path';
+import { isWebPty } from './webPty.js';
 
 /** The client asks its launcher for a restart with this exit code AND a handoff file (both, never one alone). */
 export const RESTART_EXIT_CODE = 75;
@@ -46,7 +47,7 @@ export function resetLauncherHandoff() { handoff = undefined; }
 
 /** Should this invocation become the launcher? Only an interactive client on a real terminal, never a launched child. */
 export function shouldLaunch({ argv = [], env = process.env, isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY) } = {}) {
-  if (!isTTY || env[LAUNCHER_HANDOFF_ENV] || env[NO_LAUNCHER_ENV] === '1') return false;
+  if (!isTTY || env[LAUNCHER_HANDOFF_ENV] || env[NO_LAUNCHER_ENV] === '1' || isWebPty(env)) return false;
   const head = argv.indexOf('--') === -1 ? argv : argv.slice(0, argv.indexOf('--'));
   return !head.some(a => a === '--print' || a.startsWith('--print=') || a === '-h' || a === '--help');
 }

package/lib/quoxon/loopCard.js

@@ -16,6 +16,7 @@
  */
 import { graphemes } from './textBuffer.js';
 import { cellWidth } from './cells.js';
+import { stripForeignAnsi } from './foreignText.js';
 
 /** Below this width the card is one line (the full title is printed once in chat when the loop starts). */
 export const NARROW_COLS = 60;
@@ -39,7 +40,7 @@ const SPIN = ['◐', '◓', '◑', '◒'];
 
 /* ---- text helpers --------------------------------------------------------------------------- */
 
-const oneLine = (s) => String(s ?? '').replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, '').replace(/\r/g, '');
+const oneLine = (s) => stripForeignAnsi(s).replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, '').replace(/\r/g, '');
 const width = (s) => cellWidth(s);
 
 /** Wrap at spaces; a token longer than the line is broken by cells, never dropped. Keeps blank lines. */

package/lib/quoxon/main.js

@@ -22,6 +22,7 @@ import { parseArgs, USAGE, noServerConfigured, mainPrint, pickProfile, chatCrede
 
 export { captureEarlyInput } from './earlyInput.js';
 import { isNeverAnswered, healthyStamp } from './neverAnswered.js';
+import { isWebPty, SHELL_REFUSED } from './webPty.js';
 
 /**
  * Clear the screen before the chat client? Never right after Getting started: its finale (the one-time
@@ -40,12 +41,12 @@ export async function main(argv = process.argv.slice(2)) {
   if (opts.errors.length) { early?.release(); process.stderr.write(`quox: ${opts.errors.join('; ')}\n${USAGE}\n`); process.exitCode = 1; return; }
   const cwd = process.cwd().replace(process.env.HOME || '\0', '~');
   const { resolveCliVersion } = await import('../core/version.js');
-  let version = '0.5.0';
+  let version = '0.6.1';
   try { version = resolveCliVersion?.() || version; } catch { /* keep default */ }
   if (opts.print) return mainPrint(opts);
   let replay = null;
   let fromGettingStarted = false;
-  if (opts.demoOnboarding || (!opts.demo && await noServerConfigured(opts, await import('../core/config.js')))) {
+  if (!isWebPty(process.env) && (opts.demoOnboarding || (!opts.demo && await noServerConfigured(opts, await import('../core/config.js'))))) { // QUOXON web PTY: never the installer journey
     // Getting started (FIRST_RUN_JOURNEY.md C2a): a separate view, never the chat client talking.
     if (process.stdout.isTTY && !opts.noClear) process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
     const welcome = shouldShowWelcome({ print: false });
@@ -165,6 +166,11 @@ export async function main(argv = process.argv.slice(2)) {
   catch (e) { screenRec?.stop(); transcript?.end(`crash: ${e?.message || e}`); throw e; }
   finally { screenRec?.stop(); process.stdout.off('resize', onResize); }
   if (!restart) return;
+  if (isWebPty(process.env)) { // QUOXON web PTY: no connect flow, update or re-exec on the server; the page reconnects instead
+    restoreTerminal();
+    process.stdout.write(`\n${SHELL_REFUSED}. Use Reconnect on the page to start a fresh session.\n`);
+    return;
+  }
   if (restart.connect) { // ONBOARD-P2: "Connect to a different server?" said y; the connect flow owns the terminal (certificate card, sign-in)
     restoreTerminal();
     const { connectServer } = await import('./onboarding/connectServer.js');

package/lib/quoxon/onboarding/dockerOffer.js

@@ -12,6 +12,7 @@
 import { spawnSync } from 'node:child_process';
 import { askText } from '../ask.js';
 import * as T from './copy.js';
+import { isWebPty, SHELL_REFUSED } from '../webPty.js';
 
 export const DOCKER_INSTALL_CMD = 'curl -fsSL https://get.docker.com | sudo sh && sudo usermod -aG docker "$USER"';
 export const DOCKER_GROUP_CMD = 'sudo usermod -aG docker "$USER"';
@@ -31,7 +32,8 @@ export function dockerOffer(rows) {
 const shq = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
 
 /** Runs the offer with the terminal attached. -> { action: 'exit', status } */
-export function runDockerOffer(kind, { spawn = spawnSync, out = (s) => process.stdout.write(s), node = process.execPath, bin } = {}) {
+export function runDockerOffer(kind, { spawn = spawnSync, out = (s) => process.stdout.write(s), node = process.execPath, bin, env = process.env } = {}) {
+  if (isWebPty(env)) { out(`\n${SHELL_REFUSED}\n`); return { action: 'exit', status: 126 }; } // QUOXON web PTY
   const command = COMMANDS[kind];
   if (command) {
     out(`\n${T.DOCKER_OFFER_RUNNING}\n  ${command}\n\n`);

package/lib/quoxon/onboarding/view.js

@@ -102,7 +102,7 @@ const Hint = ({ text, cols }) => h(Box, { paddingLeft: 2 }, h(Text, { color: c('
 
 // ---- the view ---------------------------------------------------------------------------------
 export function GettingStarted({
-  columns, version = '0.5.0', cwd = '', welcome = false, animateIntro, earlyInput = null,
+  columns, version = '0.6.1', cwd = '', welcome = false, animateIntro, earlyInput = null,
   journeyPath, dryRun = false, runner = null, preflightDeps, runChecks = runPreflight, findLocal = probeLocalQuox, findOllama = detectOllama,
   requestCredential, broker = null, finisher = null, onExit = () => {}, now = () => Date.now()
 }) {

package/lib/quoxon/render.js

@@ -3,6 +3,7 @@
  * horizontal rules only (no side borders), semantic colour, mono-safe.
  */
 import { toolCardLines } from './toolCards.js';
+import { DelegationDragon, delegationDragonLines } from './delegationDragon.js';
 import React from 'react';
 import chalk from 'chalk';
 import { Box, Text, useStdout } from 'ink';
@@ -556,7 +557,9 @@ export function HistoryItem({ item, cols, live = false, fx = null, pulse = null,
         : h(Text, { key: i, color: c('dim') }, ...runs(paintRuns(l, 'muted'))))));
     }
     case 'text': return h(Box, { marginTop: gap ?? 1, paddingLeft: 2, flexDirection: 'column' }, h(Markdown, { text: item.text, cols: cols - 2, live }));
-    case 'tool': return h(ToolRow, { b: item, cols, fx, pulse, ignite });
+    case 'tool': return item.dragon // dragons on: a static dragon marks CommanderQ's hand-off (delegationDragon.js)
+      ? h(Box, { flexDirection: 'column' }, h(DelegationDragon, { b: item, cols }), h(ToolRow, { b: item, cols, fx, pulse, ignite }))
+      : h(ToolRow, { b: item, cols, fx, pulse, ignite });
     case 'trace': return h(TraceRow, { b: item, cols, fx, pulse });
     case 'aocl': return h(AoclRow, { item, cols });
     case 'error': return h(ErrorView, { item, cols, fx });
@@ -811,7 +814,7 @@ export function liveRows(blocks, cols) {
       case 'summary': return n + noteLines(b.text, cols - 4).length;
       case 'error': return n + errorRows(b.text, cols);
       case 'slotmsg': return n + (b.line?.run && !b.line.run.settled ? 9 + Math.ceil(String(b.line.run.cmd || '').length / Math.max(10, cols - 8)) : 1); // ASK-SETTLE: an armed run card is held live
-      case 'tool': return n + 1 + (b.status === 'running' ? 0 : toolCardLines(b, cols).length);
+      case 'tool': return n + 1 + delegationDragonLines(b, cols).length + (b.status === 'running' ? 0 : toolCardLines(b, cols).length);
       case 'loopcard': return n + (loopPinned(b.card) ? 0 : 1 + loopCardLines(b.card, cols).length);
       default: return n + 1;
     }