quoxcli 0.4.0 → 0.5.0

package/lib/quoxon/commands.js

@@ -60,13 +60,18 @@ const ARGS = {
   slot: [{ after: [], src: 'slots', choices: [{ value: 'log', desc: 'recent messages in the held slot' }] }],
   mode: [{ after: [], choices: [{ value: 'ask', desc: 'ask first (the default)' }, { value: 'plan', desc: 'plan only: investigates and proposes, changes nothing' }] }],
   say: [{ after: [], src: 'slots' }],
-  broadcast: [{ after: [], choices: [{ value: '--slots', desc: 'only these slots, comma separated' }, { value: '--priority', desc: 'urgent shows red' }, { value: '--ack', desc: 'ask recipients to /ack' }] }],
+  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 or Cipher' }] },
+    { 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: ['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' }] }
   ],
-  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' }] }],
+  ext: [
+    { after: [], choices: [{ value: 'list', desc: 'each listed extension and where it was found' }, { value: 'on', desc: 'load one now and at every start' }, { value: 'off', desc: 'unload one' }, { value: 'tab', desc: 'focus an extension panel (off collapses)' }, { value: 'set', desc: 'change one of its settings' }, { value: 'settings', desc: 'show its settings' }] },
+    { 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' }],
   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: [
@@ -126,8 +131,10 @@ export const REGISTRY = [
   { id: 'paste', kind: 'key', group: 'Talk', usage: 'paste', desc: 'long pastes collapse to [Pasted text #N +L lines] and expand on send', status: 'active' },
   { id: 'ctrlc', kind: 'key', group: 'Talk', usage: 'Ctrl+C', desc: 'clear the draft; during a turn interrupt; twice when idle quits', status: 'active' },
   // Approvals
-  { id: 'approvals', kind: 'command', group: 'Approvals', usage: '/approvals [mine|agents|old|<agent>|N]', desc: 'the questions waiting for you, one at a time', server: true, cap: 'approvals', status: 'active' },
-  { id: 'inbox', kind: 'command', new: true, group: 'Approvals', usage: '/inbox [N | read N|all | open N]', desc: 'your Quox inbox: the latest 10 as a table, N shows one in full, read marks read, open takes an approval to /approvals', needs: ['inboxItems'], cap: 'approvals', status: 'active', args: ARGS.inbox },
+  { 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: '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' },
   { id: 'approve', kind: 'command', group: 'Approvals', usage: '/approve N | 1 y 2 n | agent <name>', desc: 'approve item N from the list, or everything one agent asked', server: true, cap: 'approvals', status: 'active',
@@ -141,11 +148,15 @@ export const REGISTRY = [
     detail: 'Like /approve N, but asks for your step-up PIN first when there is no live human-present window. The digits are never shown, saved, or sent anywhere except the PIN check.' },
   { id: 'override', kind: 'command', group: 'Approvals', usage: '/override <block id|last> <reason>', desc: 'override ONE blocked action (PIN, recorded and witnessed)', server: true, cap: 'approvals', status: 'active',
     detail: 'When a policy block refuses an action (safety level, budget cap, AOCL or WARD deny), a person with a fresh PIN can override that one action. The reason, your name and the block are recorded and witnessed. Today only safety blocks (E-STOP, DEFCON RED dispatch refusals) are honoured by a gate; other block types are recorded but stay blocked, and the answer says so. "last" is the most recent block this window saw.' },
+  { id: 'verify-email', kind: 'command', group: 'Approvals', usage: '/verify-email <email> --reason "<why>"', desc: 'mark a user email verified (instance admin; preview, then your PIN; audited)', server: true, cap: 'approvals', status: 'active',
+    detail: 'The TUI front of quox admin users verify-email: the same endpoint, and the server stays the only gate (instance admin, a human caller, a one-shot step-up token, a reason). --reason is required and is recorded in the audit log; --user-id <id> refuses unless the address belongs to that user. You see what will happen and answer y/N, then the private PIN card opens. It always asks for the PIN afresh: a live /authenticate window is not reused or spent. The PIN is never an argument, never shown, saved or logged.' },
   // Skills and rules
   { id: 'skills', kind: 'command', group: 'Skills', usage: '/skills [name]', desc: 'list your org\'s governed skills, or show one as a card', needs: ['skills'], cap: 'skills', status: 'active',
     detail: 'Lists your org skills (reusable procedures an agent follows; not Crystals, which are deterministic replays) with edition and one-line description. /skills <name> shows its card: purpose, version and review state, tests (results only when run-tests recorded them), the agents it is for, where it came from, recorded use, and how to run it.' },
   { id: 'skill', kind: 'command', group: 'Skills', usage: '/skill <name> [args]', desc: 'ask Quox to run a skill (governed: approvals still apply)', server: true, cap: 'skills', status: 'active',
     detail: 'Sends "Run the skill <name> with: <args>" as a normal turn, so CommanderQ runs it through the usual governed path. Nothing is executed from here, and approval cards work as always.' },
+  { id: 'callmeforapprovals', kind: 'command', new: true, group: 'Approvals', usage: '/callmeforapprovals [on|off|status]', desc: 'phone me when a high-risk approval sits unanswered: status, on or off (human org admin only)', needs: ['callMe'], status: 'active', aliases: ['callme'],
+    detail: 'The same call as quox approvals call-me. Alone it shows whether the phone-me switch is on, how long an approval waits before the call, quiet hours, the minimum risk tier, and whether the watcher on the server is actually alive (or says it cannot tell). on or off flips only the switch (add --after <minutes> or --quiet 22:00-08:00 to tune it); every other setting is kept. The call only reads you one approval and asks: approve needs a keypad PIN, nothing is ever approved for you. Org admins only; an agent login is refused.' },
   { id: 'plugins', kind: 'command', group: 'Skills', usage: '/plugins [name]', desc: 'plugins (extensions, add-ons) your org has installed: enabled state and version; /plugins <name> shows one', needs: ['pluginList'], status: 'active', aliases: ['plugin', 'extensions', 'extension', 'addons', 'apps'],
     detail: 'Read-only. Lists the plugins installed for the active org (the same call as quox plugin list) with enabled or disabled and the version. /plugins <name> shows one plugin (as quox plugin get). Also answers to /extensions, /extension, /addons and /apps; "/extension list" works too.' },
   { id: 'todo', kind: 'command', group: 'Awareness', usage: '/todo <text>', desc: 'add an Action Tracker item; /todo move do2 done moves one; /todo alone lists', needs: ['todoAdd', 'todoList', 'todoMove'], status: 'active',
@@ -219,6 +230,10 @@ export const REGISTRY = [
     detail: '/feedback <text> shows exactly what will be sent (type feedback, your text, and the quox CLI version; no name, email, org or token) to https://api.quox.ai/api/feedback, the Quox team rather than your own Quox server, and asks y/N. y sends it; anything else leaves it unsent. The Quox site takes 5 a hour per address. /gripe is different: it files a GitHub issue through your org.' },
   { id: 'gripe', kind: 'command', group: 'Conversation', usage: '/gripe <text>', desc: 'file a GitHub issue through the GRIPE agent; shows it first, /gripe! files at once', needs: ['gripe'], status: 'active', aliases: ['gripe!'],
     detail: 'The same governed path as `quox gripe`: the GRIPE agent files the issue through your org\'s GitHub connector (default repo quoxai/quox). /gripe <text> shows what would be filed and asks; /gripe! (alone, within 2 minutes) files it, or /gripe! <text> files straight away. The issue link is shown when one comes back; with no link it says so and treats it as not filed.' },
+  { id: 'gripes', kind: 'command', group: 'Conversation', usage: '/gripes', desc: 'gripes waiting to be filed and recently filed, with issue links', status: 'active',
+    detail: 'When Quox does not answer (timeout, network, server error) /gripe! saves the gripe on this machine, in ~/.quox/gripe-queue.json, and files it when Quox answers again: on start, then at most every 2 minutes, giving up after 24 hours with a visible line. Each gripe carries a key so a filing that actually succeeded before the timeout is never filed twice. /gripes lists what is waiting and what was filed, with the issue links.' },
+  { id: 'outbox', kind: 'command', group: 'Conversation', usage: '/outbox [drop N|send]', desc: 'messages saved while QuoxCORE did not answer; sent when it does', needs: ['slotSay'], status: 'active',
+    detail: 'When a /say or @slot message cannot be sent because QuoxCORE is not answering (connection failed, refused, timeout, server error), it is kept on this machine in ~/.quox/slot-outbox.json (mode 0600, up to 50) and sent in order when QuoxCORE answers again, with a line per message. A refusal (permission, no such slot) is never queued: the error shows and your text is back in the prompt. /outbox lists them, /outbox drop N removes one, /outbox send retries now. A message whose window closed mid-send is marked as possibly delivered and is only retried by /outbox send, so nothing is sent twice by surprise.' },
   { id: 'sessions', kind: 'command', group: 'Conversation', usage: '/sessions [all|refs]', desc: 'everything live in your org by name and where it runs; refs adds ids, all adds every chat', needs: ['sessionsIndex'], status: 'active',
     detail: 'Each row leads with the session name and where it runs (host, or "host unknown" when the server does not know), then how long it has been up and when it was last active. Sections: terminal sessions, slots, work (objectives, loops, workflows) and chats. /sessions refs adds ids and attach commands under each row; /sessions all includes every chat from the last 24 h. The same data as `quox sessions`. Names set with /rename are kept on this machine (~/.config/quox/sessions.json).' },
   { id: 'active', kind: 'command', new: true, group: 'Conversation', usage: '/active [sessions|slots|agents]', desc: 'who is doing what: one line per active worker, grouped working / waiting on you / idle (same as `quox active`)', needs: ['sessionsIndex'], status: 'active',
@@ -235,8 +250,8 @@ export const REGISTRY = [
     detail: 'Subscribes this window to the slot\'s live stream; the last ~10 messages show first. Holding (/slot) stays separate and exclusive. Post with #<slot> <text> or /say; #<slot> alone makes it the default target (a bare # undoes it). /<slot> join, /<slot> leave and /join #<slot> work too. Your lines are signed with this session\'s name and person, never as a human profile.' },
   { id: 'leave', kind: 'command', group: 'Conversation', usage: '/leave <slot>', desc: 'leave a slot room you joined (does not release a hold)', needs: ['slotSay'], cap: 'slots', status: 'active', args: ARGS.say },
   { 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] <text>', desc: 'tell every held slot in this org at once, signed as you', needs: ['slotBroadcast'], cap: 'slots', status: 'active', aliases: ['roar'], 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. Not yet: --at (schedule), --fleet, --org, --voice.' },
+  { 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,
     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',
@@ -323,6 +338,9 @@ export const REGISTRY = [
   { 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: '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'],
+    detail: 'On sets your presence to sleeping with the note "do not disturb" (sessions see it) and the window only counts what arrives: "🌙 do not disturb · N waiting · /morningreport". Bare /dnd toggles. /afk and /sleep imply it. Saying you are going to sleep (chat or /broadcast) offers it, y/N. A restarted window restores it from the server. /back or /dnd off ends it.' },
+  { id: 'morningreport', kind: 'command', new: true, group: 'Context', usage: '/morningreport', desc: 'everything collected while do not disturb was on: incidents first, approvals, inbox (xN), slot messages, sessions that need you; then offers to turn it off', status: 'active' },
   { id: 'back', kind: 'command', new: true, group: 'Context', usage: '/back', desc: 'mark yourself present and show what happened since /afk (same as /away)', status: 'active' },
   { id: 'huh', kind: 'command', new: true, group: 'Conversation', usage: '/huh [question]', desc: 'explain the last output in plain words, using one turn on your model (same as /dragon explain)', status: 'active' },
   { id: 'sleep', kind: 'command', new: true, group: 'Conversation', usage: '/sleep', desc: 'tell other sessions you are away sleeping so they stop waiting on your approvals (they still queue), then the dragon curls up (same as /dragon sleep)', status: 'active' },
@@ -371,8 +389,8 @@ export const REGISTRY = [
       'profile does the same for one --print run.' },
   { id: 'deck', ext: 'quoxdeck', kind: 'command', group: 'Context', usage: '/deck on|off|status', desc: 'QuoxDeck: an optional MIDI pad surface; pads open an approval or preselect an answer, you confirm here', status: 'active',
     detail: 'Provided by the optional quoxdeck extension, not by core: npm i -g quoxdeck, then quox ext add quoxdeck (until then /deck says so). quoxon pushes approvals, health and loops to the deck at most once a second. A pad only opens an approval view or fills the composer with the answer; it never answers for you, and high risk still needs the step-up PIN. The setting is saved, so the deck comes back on at the next start.' },
-  { id: 'ext', kind: 'command', group: 'Context', usage: '/ext list|on|off <name>', desc: 'optional extensions (npm packages) that add surfaces to this window', status: 'active',
-    detail: 'Extensions load only when installed (npm i -g <pkg>) and listed (quox ext add <pkg>). /ext list shows each one and where it was found, on|off switches one for the next start and now. An extension can open an approval or preselect an answer; it cannot answer for you. Contract: cli/lib/quoxon/EXTENSIONS.md.' },
+  { id: 'ext', kind: 'command', group: 'Context', usage: '/ext list|on|off|tab|set|settings <name>', desc: 'optional extensions (npm packages) that add surfaces to this window', status: 'active', args: ARGS.ext,
+    detail: 'Extensions load only when installed (npm i -g <pkg>) and listed (quox ext add <pkg>). /ext list shows each one and where it was found, on|off switches one for the next start and now. An extension can open an approval or preselect an answer; it cannot answer for you. /ext tab <name> (or Ctrl+]) focuses an extension panel and Esc returns to the composer; /ext set <name> <key> <value> and /ext settings <name> change and show its settings. Contract: cli/lib/quoxon/EXTENSIONS.md.' },
   { id: 'row', kind: 'command', group: 'Context', usage: '/row [new|add|list|edit <id>|rm <id>|test <id>|reload|on|off]', desc: 'your own live lines above the status bar: stats from a URL, your Quox, a plugin or a command', status: 'active', args: ARGS.row,
     detail:
       '/row new walks you through one row with y/N cards and shows what it will say before saving; /row edit <id> changes one. ' +
@@ -405,6 +423,18 @@ for (const e of VENDOR_ENTRIES) {
 // The palette row's one-line wording (commandShort.js); /help keeps the long desc.
 for (const e of REGISTRY) if (e.kind === 'command' && !e.short && SHORT[e.id]) e.short = SHORT[e.id];
 
+/** Commands of loaded extensions join the registry (help, palette, Tab) while loaded: [{ name, help, ext, subcommands }]. Static ids win. */
+export function setExtEntries(cmds) {
+  for (let i = REGISTRY.length - 1; i >= 0; i--) if (REGISTRY[i].dyn) REGISTRY.splice(i, 1);
+  for (const c of cmds || []) {
+    const id = String(c.name || '').replace(/^\//, '');
+    if (!id || REGISTRY.some((e) => e.id === id)) continue;
+    const subs = c.subcommands || [];
+    REGISTRY.push({ id, dyn: true, ext: c.ext, kind: 'command', group: 'Context', usage: subs.length ? `/${id} ${subs.map((s) => s.name).join('|')}` : `/${id}`, desc: c.help || `from the ${c.ext} extension`, status: 'active',
+      ...(subs.length ? { args: [{ after: [], choices: subs.map((s) => ({ value: s.name, desc: s.help || '' })) }] } : {}) });
+  }
+}
+
 const norm = (s) => String(s || '').trim().toLowerCase().replace(/^\//, '');
 
 /** Dev-only entries (/observe, /devnote) are invisible unless a dev observer is configured. */
@@ -500,7 +530,7 @@ export function suggestCommands(input, max = 3) {
   if (!q) return [];
   const names = [...new Set(commandNames())];
   const lev = (a, b) => { const dp = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]); for (let j = 1; j <= b.length; j++) dp[0][j] = j; for (let i = 1; i <= a.length; i++) for (let j = 1; j <= b.length; j++) dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)); return dp[a.length][b.length]; };
-  return names.map(n => { const k = n.slice(1); const rel = q.startsWith(k) || k.startsWith(q) || (k.length >= 2 && q.includes(k)) || (q.length >= 2 && k.includes(q)); const head = q.length >= 3 && k.length > q.length ? lev(q, k.slice(0, q.length)) + 0.5 : Infinity; return { n, d: rel ? 0 : Math.min(lev(q, k), head), len: Math.abs(k.length - q.length) }; })
+  return names.map(n => { const k = n.slice(1); const sep = k.length >= 2 && q.length > k.length && q.startsWith(k) && /[-_ :]/.test(q[k.length]); const rel = sep || k.startsWith(q) || (k.length >= 2 && q.includes(k) && q.length - k.length <= 2) || (q.length >= 2 && k.includes(q)); const head = q.length >= 3 && k.length > q.length ? lev(q, k.slice(0, q.length)) + 0.5 : Infinity; return { n, d: sep ? -1 : rel ? 0 : Math.min(lev(q, k), head), len: Math.abs(k.length - q.length) }; })
     .filter(x => x.d <= Math.max(2, Math.floor(q.length / 3)))
     .sort((a, b) => a.d - b.d || a.len - b.len || a.n.localeCompare(b.n)).slice(0, max).map(x => x.n);
 }

package/lib/quoxon/connect.js

@@ -125,7 +125,7 @@ export const pickRow = (rows, type) => {
  * `caps` is the server's capabilities answer, the source of truth for whether each provider is usable
  * (providers.js, shared with /model and /doctor). Anything neither can answer is "? unknown".
  */
-export function connectionLines(res, caps = null) {
+export function connectionLines(res, caps = null, { includeOthers = true } = {}) {
   const STATUS_PROVIDERS = [PROVIDERS.openai, PROVIDERS.anthropic, PROVIDERS.ollama, PROVIDERS.openrouter, PROVIDERS.huggingface, PROVIDERS.groq, PROVIDERS.together, PROVIDERS.lmstudio, PROVIDERS.vllm, PROVIDERS.custom];
   const out = [];
   const ok = res && res.ok && Array.isArray(res.rows);
@@ -136,7 +136,7 @@ export function connectionLines(res, caps = null) {
     const st = providerState({ cap: p.id, vault: p.type }, caps, res);
     const def = st.row;
     if (st.state === 'unknown') out.push([`? ${p.name}  unknown (vault not readable)`, 'warn']);
-    else if (st.state === 'connected' && def) out.push([`● ${p.name}  connected · ${def.label || def.id} · ${testTag(def)}`, def.test_status === 'failed' ? 'warn' : 'ok']);
+    else if (st.state === 'connected' && def) out.push([`● ${p.name}  connected · ${def.label || def.id} · ${testTag(def)}${def.test_status === 'failed' ? ` · re-test: quox provider test ${p.id}` : ''}`, def.test_status === 'failed' ? 'warn' : 'ok']);
     else if (st.state === 'connected') out.push([`● ${p.name}  ready on this server (an instance-wide key, not in your org vault)`, 'ok']);
     else if (st.state === 'stored') out.push([`◐ ${p.name}  stored but not the default · quox vault set-default ${st.row.id}`, 'warn']);
     else if (st.state === 'unavailable') out.push([`○ ${p.name}  not available here${st.reason ? `: ${st.reason}` : ''}`]);
@@ -155,7 +155,9 @@ export function connectionLines(res, caps = null) {
     if (!cur || (r.is_default && !cur.is_default)) others.set(r.integration_type, r);
   }
   const list = [...others.values()];
-  if (list.length) {
+  if (!includeOthers) {
+    if (list.length) out.push([`  ${list.length} other integration${list.length === 1 ? '' : 's'} in your vault: quox provider list --all`]);
+  } else if (list.length) {
     out.push(['Integrations in your vault:']);
     for (const r of list.slice(0, 12)) out.push([`● ${r.integration_type}  ${r.label || r.id} · ${testTag(r)}`, r.test_status === 'failed' ? 'warn' : undefined]);
     if (list.length > 12) out.push([`  +${list.length - 12} more · quox vault list`]);

package/lib/quoxon/deckLazy.js

@@ -0,0 +1,58 @@
+/**
+ * LAZY PATH (QUOXON, 2026-10-29; plan first-run-onboarding-plan.md section 4): /deck on a machine that lacks the
+ * quoxdeck extension, or the ALSA headers its native midi dependency builds against, OFFERS one y/N instead of a raw
+ * build error. Pure planning plus an injected runner: nothing here touches the machine until the user says y, and
+ * sudo is the user's own (the exact command is shown first; no password is ever read, stored or passed).
+ */
+import { spawnSync } from 'node:child_process';
+
+export const DECK_PKG = 'quoxdeck';
+export const ALSA_PKG = 'libasound2-dev';
+const SYSTEM = { apt: { cmd: `sudo apt-get install -y ${ALSA_PKG}`, pkg: ALSA_PKG }, dnf: { cmd: 'sudo dnf install -y alsa-lib-devel', pkg: 'alsa-lib-devel' } };
+const NPM_CMD = `npm i -g ${DECK_PKG}`;
+const ADD_CMD = `quox ext add ${DECK_PKG}`;
+
+const quick = (file, args) => { try { return spawnSync(file, args, { stdio: 'ignore', timeout: 3000 }); } catch { return { status: 1 }; } };
+/** Cheap ALSA header check: pkg-config, else the header path. */
+export async function defaultHasAlsa() {
+  if (quick('pkg-config', ['--exists', 'alsa']).status === 0) return true;
+  return ['/usr/include/alsa/asoundlib.h'].some((p) => quick('test', ['-f', p]).status === 0);
+}
+/** apt or dnf only; anything else is null (we never guess further). */
+export async function defaultPackageManager() {
+  for (const pm of ['apt-get', 'dnf']) if (quick('sh', ['-c', `command -v ${pm}`]).status === 0) return pm === 'dnf' ? 'dnf' : 'apt';
+  return null;
+}
+
+/**
+ * -> null (nothing to offer) | { text } (no automatic path: say it, show manual commands)
+ *    | { question, steps:[{label, cmd, interactive?}], manual:[cmd] }
+ */
+export async function deckOffer({ platform = process.platform, isInstalled, hasAlsa = defaultHasAlsa, packageManager = defaultPackageManager } = {}) {
+  const installed = Boolean(await isInstalled());
+  const alsaMissing = platform === 'linux' && !(await hasAlsa());
+  if (installed && !alsaMissing) return null;
+  const pm = alsaMissing ? await packageManager() : null;
+  if (alsaMissing && !pm) {
+    return { steps: null, text: `quoxdeck needs the ALSA development headers (${ALSA_PKG} on Debian, alsa-lib-devel on Fedora). This machine has neither apt or dnf, so install them with your own package manager, then run: ${NPM_CMD} && ${ADD_CMD}` };
+  }
+  const steps = [];
+  if (alsaMissing) steps.push({ label: `system package ${SYSTEM[pm].pkg}`, cmd: SYSTEM[pm].cmd, interactive: true });
+  steps.push({ label: installed ? 'rebuild the quoxdeck extension' : 'install the quoxdeck extension', cmd: NPM_CMD });
+  steps.push({ label: 'list it in quoxon', cmd: ADD_CMD });
+  const need = [...(alsaMissing ? [`system package ${SYSTEM[pm].pkg}`] : []), 'the quoxdeck extension'];
+  return { steps, manual: steps.map((s) => s.cmd), question: `quoxdeck needs: ${need.join(', then ')}. Install now?` };
+}
+
+export const declineText = (o) => `Nothing to turn off. When you want it: ${o.manual.join(' && ')}`;
+
+/** Runs the steps in order via the injected run(step); stops at the first failure; re-runs /deck only on full success. */
+export async function runDeckOffer(o, { run, say = () => {}, rerun = async () => {} }) {
+  for (const s of o.steps) {
+    say(`Running: ${s.cmd}`);
+    let r; try { r = await run(s); } catch (e) { r = { code: 1, error: e?.message }; }
+    if (r?.code !== 0) { say(`Stopped at: ${s.cmd} (${r?.error || `exit ${r?.code ?? 'unknown'}`}). Nothing after it ran. To finish by hand: ${o.manual.slice(o.steps.indexOf(s)).join(' && ')}`, 'warn'); return { ok: false, failed: s.cmd }; }
+  }
+  await rerun();
+  return { ok: true };
+}

package/lib/quoxon/destructive.js

@@ -0,0 +1,35 @@
+// A DESTRUCTIVE approval (owner 2026-10-27 16:15 UTC, after two delete_workflow cards were approved by one 'y' each)
+// needs a stronger confirm: the human types the object's name. One place decides what is destructive.
+import { describeInboxItem } from './events.js';
+
+/** Tools named delete_*, remove_*, purge_*, destroy_*, drop_* or wipe_* (the prefix only; "undelete_x" is not one). */
+export const DESTRUCTIVE_TOOL = /^(delete|remove|purge|destroy|drop|wipe)_/i;
+export const isDestructiveTool = (tool) => DESTRUCTIVE_TOOL.test(String(tool ?? '').trim());
+
+const flagged = (o) => Boolean(o && (o.destructive === true || o.irreversible === true));
+
+/** True when the server marks the item destructive or irreversible, else when its tool name follows the rule. */
+export function isDestructive(it) {
+  if (!it) return false;
+  const p = it.payload || {}; const c = p.approval_context || {};
+  if (flagged(it) || flagged(p) || flagged(c) || flagged(c.method) || flagged(p.what)) return true;
+  return isDestructiveTool(describeInboxItem(it).tool);
+}
+
+const str = (v) => (typeof v === 'string' && v.trim() ? v.trim() : typeof v === 'number' ? String(v) : null);
+const argsOf = (it) => {
+  const p = it?.payload || {}; const c = p.approval_context || {}; const m = c.method || {};
+  const a = m.args ?? m.input ?? c.args ?? c.input ?? p.args ?? p.input ?? p.action_params ?? null;
+  if (a && typeof a === 'object' && !Array.isArray(a)) return a;
+  if (typeof a === 'string') { try { const j = JSON.parse(a); if (j && typeof j === 'object' && !Array.isArray(j)) return j; } catch { /* not JSON */ } }
+  return {};
+};
+
+/** What gets deleted: { label, name }. The human name when the input has one (name, workflow_name, host_name...), else the id from the input, else the short item id. name is what the human must type. */
+export function destructiveObject(it) {
+  const a = argsOf(it);
+  const nameKey = Object.keys(a).find(k => /(^|_)name$/i.test(k) && str(a[k]));
+  const idKey = Object.keys(a).find(k => /(^|_)id$/i.test(k) && str(a[k]));
+  const v = (nameKey && str(a[nameKey])) || (idKey && str(a[idKey])) || String(it?.id ?? 'item').slice(0, 8);
+  return { label: v, name: v };
+}

package/lib/quoxon/dnd.js

@@ -0,0 +1,71 @@
+/**
+ * DO-NOT-DISTURB (owner 2026-10-28: "sleep means sleep"). Pure helpers for /donotdisturb (/dnd) and /morningreport.
+ * While DND is on the window collects instead of announcing; the app holds the collected arrivals and these functions
+ * turn them into the morning digest. No I/O here.
+ */
+export const DND_NOTE = 'do not disturb';
+export const DND_USAGE = 'Usage: /donotdisturb [on|off] [until HH:MM]  (alias /dnd; bare turns it on)';
+
+/** `/dnd [on|off] [until HH:MM]` -> { ok, op: 'on'|'off'|'toggle', until: {h,m}|null } | { ok:false, error }. */
+export function parseDndArgs(arg) {
+  const a = String(arg || '').trim().toLowerCase();
+  if (!a) return { ok: true, op: 'toggle', until: null };
+  const m = /^(?:(on|off)\s*)?(?:until\s+(\d{1,2}):(\d{2}))?$/.exec(a);
+  if (!m || (!m[1] && m[2] === undefined)) return { ok: false, error: DND_USAGE };
+  let until = null;
+  if (m[2] !== undefined) {
+    const h = Number(m[2]), mi = Number(m[3]);
+    if (h > 23 || mi > 59) return { ok: false, error: DND_USAGE };
+    if (m[1] === 'off') return { ok: false, error: DND_USAGE };
+    until = { h, m: mi };
+  }
+  return { ok: true, op: m[1] || 'on', until };
+}
+
+/** The next local HH:MM after `now` as epoch ms. */
+export function untilEpoch({ h, m }, now = Date.now()) {
+  const d = new Date(now); d.setHours(h, m, 0, 0);
+  if (d.getTime() <= now) d.setDate(d.getDate() + 1);
+  return d.getTime();
+}
+
+/** Text that says the owner is heading off: going to sleep / off to bed / signing off for the night / night all. */
+const SLEEP_RE = /\b(?:i['’]?m|i am|im|we['’]?re|owner(?: is)?|adam(?: is)?)?\s*(?:going to (?:sleep|bed)|off to (?:bed|sleep)|heading to (?:bed|sleep)|going offline|signing off(?: for (?:the )?(?:night|today|now))?|logging off for the night|turning in(?: for the night)?)\b|\bnight[,!. ]+(?:all|everyone|team|folks)\b|\bgood ?night (?:all|everyone|team|folks)\b/i;
+export const sleepIntent = (text) => SLEEP_RE.test(String(text || ''));
+
+/** `/afk <text>` whose text says sleep/bed/night: the owner means /sleep. */
+export const afkMeansSleep = (text) => /\b(?:sleep|sleeping|asleep|bed|bedtime|night|goodnight)\b/i.test(String(text || '')) || /\bgood night\b/i.test(String(text || ''));
+
+export const newCollected = () => ({ inbox: [], slots: [], since: Date.now() });
+
+const titleOf = (it) => String(it.title || it.kind || 'untitled');
+const INCIDENT_RE = /incident|outage|critical|sev[ -]?[01]|down\b|breach|alert|failed/i;
+export const isIncident = (it) => INCIDENT_RE.test(`${it.kind || ''} ${it.severity || ''} ${it.priority || ''} ${titleOf(it)}`);
+
+/** Collapse by title with a count: [{ title, n }] in first-seen order. */
+export function collapseByTitle(items) {
+  const m = new Map();
+  for (const it of items) { const k = titleOf(it); m.set(k, (m.get(k) || 0) + 1); }
+  return [...m].map(([title, n]) => ({ title, n }));
+}
+
+/** How many things wait for the owner: approvals + collected inbox arrivals + collected slot messages. */
+export const waitingCount = (c, approvals = 0) => approvals + (c?.inbox?.length || 0) + (c?.slots?.length || 0);
+
+/** The digest as [text, tone] lines. Incidents first, then approvals, inbox (xN), slot messages, sessions that need you. */
+export function morningLines(c, { approvals = 0, sessions = [] } = {}) {
+  const lines = [];
+  const inc = c.inbox.filter(isIncident), rest = c.inbox.filter((i) => !isIncident(i));
+  const group = (head, items, tone) => { if (items.length) { lines.push([head, tone]); for (const g of collapseByTitle(items)) lines.push([`  ${g.title}${g.n > 1 ? ` (×${g.n})` : ''}`, 'plain']); } };
+  group(`Incidents (${inc.length})`, inc, 'warn');
+  if (approvals) lines.push([`Approvals waiting (${approvals}): /approvals`, 'warn']);
+  group(`Inbox (${rest.length})`, rest, 'plain');
+  if (c.slots.length) {
+    lines.push([`Slot messages (${c.slots.length})`, 'plain']);
+    for (const s of c.slots.slice(0, 10)) lines.push([`  ${s.from}: ${String(s.text).replace(/\s+/g, ' ').slice(0, 90)}`, 'plain']);
+    if (c.slots.length > 10) lines.push([`  ... ${c.slots.length - 10} more`, 'dim']);
+  }
+  if (sessions.length) { lines.push([`Sessions that need you (${sessions.length})`, 'warn']); for (const s of sessions.slice(0, 8)) lines.push([`  ${s}`, 'plain']); }
+  if (!lines.length) lines.push(['Nothing collected while you were away.', 'ok']);
+  return lines;
+}

package/lib/quoxon/dragonCompanion.js

@@ -1,5 +1,5 @@
 /**
- * Dragon companion for Quoxon (Lucid, Hyperion, Seer, Sentinel, Drago, Cipher). The controller owns attach state and feeds REAL stream
+ * Dragon companion for Quoxon (Lucid, Hyperion, Seer, Sentinel, Drago, Cipher, Vulcan, Quoxperticus). 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).
@@ -13,7 +13,7 @@ import { useFrame } from './motion/frame.js';
 import { loadCompanionView } from '../dragon/companionView.js';
 import { ART_MIN_COLS as SLOT_MIN_COLS, ART_MIN_ROWS as SLOT_MIN_ROWS } from '../dragon/frames.js';
 import { companionPlan, motionPolicy, normaliseMode, COMPANION_MODES, VENDORED_DRAGONLAB, dragonForAgent, companionMode } from '../dragon/select.js';
-import { createMomentEngine, createRosterWatch, LONG_TASK_MS, SUMMON_COOLDOWN_MS } from './dragonMoments.js';
+import { createMomentEngine, createRosterWatch, createSenderWatch, LONG_TASK_MS, SUMMON_COOLDOWN_MS } from './dragonMoments.js';
 import { moodForEvent } from './motion/level.js';
 
 const h = React.createElement;
@@ -50,8 +50,8 @@ export function toCompanionEvent(action) {
 }
 
 export function createCompanionController({ settings = () => ({}), env = process.env, isTTY = true, exists = existsSync, now = Date.now, importer = null, makeView = loadCompanionView, jobs = null, typing = () => false } = {}) {
-  let noticed = false, showUntil = 0, shownAt = 0, unpainted = false, waitingFrame = false, trigger = 'attach', forced = false, timer = null, job = null;
-  let summoned = null, summonCaption = null; const lastSummon = new Map(); const rosterWatch = createRosterWatch(); // a domain moment's dragon (not the attached one) and its truthful caption
+  let noticed = false, narrowNoticed = false, showUntil = 0, shownAt = 0, unpainted = false, waitingFrame = false, trigger = 'attach', forced = false, timer = null, job = null;
+  let summoned = null, summonCaption = null; const lastSummon = new Map(); const rosterWatch = createRosterWatch(); const senderWatch = createSenderWatch({ now }); // a domain moment's dragon (not the attached one) and its truthful caption
   const moments = createMomentEngine({ now });
   let agent = null, plan = { enabled: false, why: 'no agent attached' }, view = null, state = null, token = 0, greet = true;
   const listeners = new Set();
@@ -141,15 +141,35 @@ export function createCompanionController({ settings = () => ({}), env = process
      * screen, and not the same dragon again inside SUMMON_COOLDOWN_MS. Works with nothing attached. The caption is the moment's own
      * truthful line. -> true when it showed.
      */
-    async summon(dragon, caption) {
+    canSummon(dragon) {
       if (companionMode(settings(), env) !== 'on' || typing() || live()) return false;
       const last = lastSummon.get(dragon);
-      if (last != null && now() - last < SUMMON_COOLDOWN_MS) return false;
+      return !(last != null && now() - last < SUMMON_COOLDOWN_MS);
+    },
+    async summon(dragon, caption) {
+      if (!this.canSummon(dragon)) return false;
       lastSummon.set(dragon, now());
       if (agent && dragonForAgent(agent) === dragon && view && plan.persist) { summonCaption = caption; appear('summon'); return true; }
       await load({ show: true, as: dragon, caption, persist: true, why: 'summon' });
       return Boolean(view);
     },
+    /**
+     * A slot message landed in the owner's stream: a fresh line from a session whose agent has a dragon summons that dragon for one
+     * dwell (dragonMoments.js slotMessageMoment; deduped, per-sender cooldown). `opts` = { broadcast, run }. -> true when it showed.
+     */
+    async slotMessage(m, opts = {}) {
+      const mo = senderWatch.observe(m, opts);
+      if (!mo || !this.canSummon(mo.dragon)) return false;
+      senderWatch.shown(mo.sender);
+      return this.summon(mo.dragon, mo.caption);
+    },
+    /** Another session's approval card newly waiting (state prev -> next), asked by a dragon agent: that dragon appears. */
+    async waitingCards(prev, next) {
+      const mo = senderWatch.card(prev, next);
+      if (!mo || !this.canSummon(mo.dragon)) return false;
+      senderWatch.shown(mo.sender);
+      return this.summon(mo.dragon, mo.caption);
+    },
     /** Roster rows (every refresh) -> the first objective/loop that just finished or failed summons its dragon. */
     watchRoster(rows) { const m = rosterWatch.observe(rows)[0]; return m ? this.summon(m.dragon, m.caption) : Promise.resolve(false); },
     /** True while the dragon is on screen and moving: the host asks the shared clock for frames only then. */
@@ -182,6 +202,16 @@ export function createCompanionController({ settings = () => ({}), env = process
       return `Dragon companion is ${plan.mode} but its art could not be loaded, so no dragon will show (${plan.why}). /dragon companion status`;
     },
     mode: () => plan.mode,
+    /**
+     * Once per session: a dragon is attached and would show, but this window is too small for the art, so all that appears is a
+     * one-line label. Say why in plain words rather than hiding it silently. Otherwise null.
+     */
+    narrowNotice({ cols, rows }) {
+      if (narrowNoticed || !agent || !dragonForAgent(agent) || !plan.enabled || !view) return null;
+      if (cols >= ART_MIN_COLS && rows >= ART_MIN_ROWS) return null;
+      narrowNoticed = true;
+      return `The dragon needs ${ART_MIN_COLS} columns and ${ART_MIN_ROWS} rows to be drawn; this window is ${cols} by ${rows}, so you only get its caption line. Widen the window to see it.`;
+    },
     /** -> null | { kind:'art', frame, caption, name } | { kind:'label', text } */
     snapshot(t, { cols, rows }) {
       const out = this.snapshotNow(t, { cols, rows });
@@ -219,7 +249,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 and Cipher have dragons.`, invoke: true };
+    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 };
   }
   const m = normaliseMode(w);
   if (!m) return { text: `Usage: /dragon companion ${COMPANION_MODES.join('|')}|status`, tone: 'warn' };

package/lib/quoxon/dragonMoments.js

@@ -5,6 +5,8 @@
  * dragon shows itself. The controller (dragonCompanion.js) runs the engine on every stream fact and owns the routing: while a
  * companion owns the moments the Q dragon stays quiet, so a moment is never two dragons.
  */
+import { dragonForAgent } from '../dragon/select.js';
+
 export const MOMENTS = Object.freeze({
   approval: Object.freeze({ mood: 'waiting', companion: true }),
   failure: Object.freeze({ mood: 'failure', companion: true }),
@@ -80,3 +82,79 @@ export function createRosterWatch() {
     },
   };
 }
+
+// ---- sender moments: a named session or agent speaks to the owner, so its own dragon appears (companion mode `on` only) ---------
+/** The same sender cannot call its dragon again for this long once it has shown (a chatty session is one dragon, not a parade). */
+export const SENDER_COOLDOWN_MS = 5 * 60 * 1000;
+/** Only a message this recent is a moment: a backlog replayed on (re)connect is history, not news. */
+export const SLOT_FRESH_MS = 2 * 60 * 1000;
+
+const head = (s) => String(s).split(/[\s\-_.:/]+/)[0];
+/** One name -> a dragon id: the whole name, its first word, or that word without trailing digits (quoxperticus-126). */
+function dragonForName(name) {
+  const s = String(name ?? '').trim();
+  if (!s) return null;
+  return dragonForAgent(s) || dragonForAgent(head(s)) || dragonForAgent(head(s).replace(/\d+$/, ''));
+}
+/**
+ * A slot message sender -> its agent's dragon, or null. `from` is "slot (display)" or a bare name. The speaker (the display name
+ * in brackets) wins, then the bare name, then the slot it holds. Only approved dragons (select.js AGENT_DRAGON) can match.
+ */
+export function dragonForSender(m) {
+  if (!m) return null;
+  const from = String(m.from ?? '').trim();
+  const inner = (from.match(/\(([^)]*)\)\s*$/) || [])[1];
+  const bare = from.replace(/\s*\(.*$/, '');
+  for (const n of [inner, bare, m.from_slot]) { const d = dragonForName(n); if (d) return d; }
+  return null;
+}
+const senderKey = (m) => String(m?.from_slot || m?.from || '').replace(/\s*\(.*$/, '').trim().toLowerCase();
+
+/** A fresh slot message from a dragon session -> { dragon, sender, caption } | null. The caption says who and what kind, never the content. */
+export function slotMessageMoment(m, { now = Date.now(), broadcast = false, run = false } = {}) {
+  const dragon = dragonForSender(m);
+  if (!dragon) return null;
+  const t = Date.parse(m.created_at ?? m.createdAt ?? '');
+  if (!Number.isFinite(t) || now - t > SLOT_FRESH_MS) return null;
+  const who = String(m.from).trim();
+  const caption = run ? `${who} asks you to run a command.` : broadcast ? `Broadcast from ${who}.` : `Message from ${who}.`;
+  return { dragon, sender: senderKey(m), caption };
+}
+
+/** Another session's approval card newly waiting, asked by an agent with a dragon -> { dragon, sender, key, caption } | null. */
+export function waitingCardMoment(prev, next) {
+  const before = new Set((prev?.waiting || []).map(c => c.inboxItemId));
+  for (const c of next?.waiting || []) {
+    if (!c || before.has(c.inboxItemId)) continue;
+    const who = c.origin || c.askedBy;
+    const dragon = dragonForName(who) || dragonForName(c.askedBy);
+    if (!dragon) continue;
+    return { dragon, sender: String(who).toLowerCase(), key: c.inboxItemId, caption: `${who} wants your approval${c.tool ? ` (${c.tool})` : ''}.` };
+  }
+  return null;
+}
+
+/**
+ * Dedupe + per-sender cooldown for sender moments. observe() remembers the message id at once (a re-delivery is never a second
+ * moment); shown() starts the sender's cooldown, so a moment refused because the owner was typing does not silence that sender.
+ */
+export function createSenderWatch({ now = Date.now, cooldownMs = SENDER_COOLDOWN_MS } = {}) {
+  const seen = new Set(), last = new Map();
+  const remember = (k) => { seen.add(k); if (seen.size > 500) seen.delete(seen.values().next().value); };
+  const cool = (sender) => { const t = last.get(sender); return t != null && now() - t < cooldownMs; };
+  return {
+    observe(m, opts = {}) {
+      const id = m?.event_id || m?.id || (m?.created_at ? `${m.created_at}|${m.seq ?? ''}|${m.from ?? ''}` : null);
+      if (id != null) { if (seen.has(String(id))) return null; remember(String(id)); }
+      const mo = slotMessageMoment(m, { ...opts, now: now() });
+      return mo && !cool(mo.sender) ? mo : null;
+    },
+    card(prev, next) {
+      const mo = waitingCardMoment(prev, next);
+      if (!mo || seen.has(`card:${mo.key}`)) return null;
+      remember(`card:${mo.key}`);
+      return cool(mo.sender) ? null : mo;
+    },
+    shown(sender) { last.set(sender, now()); },
+  };
+}

package/lib/quoxon/echo.js

@@ -10,6 +10,7 @@ export const ECHO_CAP = 2000;
 export function echoLine(text, { cols = 100 } = {}) {
   let t = String(text ?? '').trim();
   if (PIN_CMD.test(t)) t = t.split(/\s+/)[0]; // a stray argument may be a PIN: never shown
+  if (/^\/verify-email(\s|$)/i.test(t) && /(^|\D)\d{6}(\D|$)/.test(t)) t = '/verify-email'; // a 6-digit run may be a PIN typed by mistake: never shown
   const full = redactSecrets(t).text;
   return { shown: clip(full.replace(/\s*\n\s*/g, ' '), ECHO_CAP), full };
 }