quoxcli 0.3.1 → 0.5.0

package/lib/quoxon/dragonMoments.js

@@ -0,0 +1,160 @@
+/**
+ * ONE moment engine for both dragon systems. A "moment" is a stream fact worth a dragon: an approval is waiting, a turn or the
+ * stream failed, a long turn finished, a turn finished. The classification (and its dedupe) lives here once; the table says what
+ * each moment calls: `mood` is the Q dragon's cinematic clip (qmotion playDragon), `companion` is whether an attached companion
+ * 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 }),
+  long: Object.freeze({ mood: 'success', companion: true }),
+  success: Object.freeze({ mood: 'success', companion: false }),
+});
+/** A turn at least this long counts as a "long task" when it finishes. */
+export const LONG_TASK_MS = 30000;
+
+export function createMomentEngine({ now = Date.now } = {}) {
+  const seen = new Set();
+  let turnStart = null;
+  const moment = (kind) => ({ kind, ...MOMENTS[kind] });
+  return {
+    turnStarted() { turnStart = now(); },
+    reset() { seen.clear(); turnStart = null; },
+    /** A reducer event (the companion's vocabulary) -> { kind, mood, companion } | null. */
+    observe(ev) {
+      if (!ev) return null;
+      if (ev.type === 'approval.requested') {
+        // The same approval arrives twice (the stream event, then the inbox poll) under different ids: one moment for it.
+        const keys = [ev.call_id, ev.inbox_item_id, ev.approval_id].filter(Boolean).map(String);
+        if (keys.some(k => seen.has(k))) return null;
+        keys.forEach(k => seen.add(k));
+        return moment('approval');
+      }
+      if (ev.type === 'error') return moment('failure');
+      if (ev.type === 'turn.finished') {
+        const started = turnStart; turnStart = null;
+        if (ev.status === 'failed' || ev.status === 'unconfirmed') return moment('failure');
+        if (ev.status !== 'completed') return null;
+        return moment(started != null && now() - started >= LONG_TASK_MS ? 'long' : 'success');
+      }
+      return null;
+    },
+  };
+}
+
+// ---- domain moments: a fact from the estate summons the matching dragon (companion mode `on` only) ------------------------
+/** A dragon summoned by a domain moment cannot be summoned again for this long. */
+export const SUMMON_COOLDOWN_MS = 60000;
+
+/**
+ * An objective or loop roster row -> { dragon, caption } when it has finished or failed, else null. The caption states only
+ * what the row says. The roster row carries no agent, so the dragon is Seer (the plan dragon); an agent field would pick its own.
+ */
+export function objectiveMoment(row) {
+  if (!row || (row.kind !== 'objective' && row.kind !== 'loop') || (row.state !== 'done' && row.state !== 'failed')) return null;
+  const noun = row.kind === 'loop' ? 'Loop' : 'Objective', name = row.name || row.id;
+  const caption = row.state === 'done' ? `${noun} finished: ${name}.` : `${noun} failed: ${name}${row.activity ? ` (${row.activity})` : ''}.`;
+  return { dragon: 'seer', caption };
+}
+
+/**
+ * Watches roster rows and reports each objective/loop that was seen unfinished and is now done or failed, once. The first
+ * observation is a baseline (rows already finished at startup never fire); a reported key is retired for good.
+ */
+export function createRosterWatch() {
+  const active = new Set(), retired = new Set();
+  let primed = false;
+  return {
+    observe(rows = []) {
+      const out = [];
+      for (const r of rows) {
+        if (!r || (r.kind !== 'objective' && r.kind !== 'loop') || retired.has(r.key)) continue;
+        if (r.state === 'done' || r.state === 'failed') {
+          if (active.delete(r.key) && primed) { const m = objectiveMoment(r); if (m) out.push(m); }
+          retired.add(r.key);
+        } else active.add(r.key);
+      }
+      primed = true;
+      return out;
+    },
+  };
+}
+
+// ---- 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/dragonReads.js

@@ -0,0 +1,68 @@
+/**
+ * The reads behind the dragon jobs (lib/dragon/jobs.js). Each is the same call a `quox` verb already makes, read-only,
+ * bounded, retries off. The CLI client throws on a non-2xx, so a throw is the failure and a returned body is checked for the
+ * error shapes some routes use with a 200 (success:false). Nothing here turns an error into a count.
+ */
+import { resolveEndpoint } from '../api/endpoints.js';
+import { healthOf } from './objects/fleet.js';
+
+const TIMEOUT = 5000;
+const STATE = { 1: 'up', 0: 'down', 2: 'pending', 3: 'maintenance' };
+const kumaState = (m) => (m && typeof m.state === 'string' ? m.state : m && Object.hasOwn(STATE, m.status) ? STATE[m.status] : 'unknown'); // same mapping as `quox kuma`
+const whyOf = (e) => (e?.status ? `HTTP ${e.status}` : /timed out/i.test(e?.message || '') ? 'timed out' : e?.message || 'failed');
+
+export function createDragonReads({ client }) {
+  const get = (name, params, query) => { const ep = resolveEndpoint(name, params); return client.get(ep.path, { service: ep.service, query, retries: 0, timeout: TIMEOUT }); };
+  return {
+    /** WARD inclusion receipt of one envelope (POST /ward/verify-receipt, the route /proof uses). -> { ok, result } | { ok:false, error } */
+    async verifyReceipt(envelopeId) {
+      try {
+        const d = await client.post('/ward/verify-receipt', { service: 'collector', body: { source_id: envelopeId, source_kind: 'AEE' }, retries: 0, timeout: TIMEOUT });
+        return { ok: true, result: d?.result || d };
+      } catch (e) { return { ok: false, error: whyOf(e) }; }
+    },
+    /** `quox kuma` live read -> { up, down, total, avgPing, downNames, ageSeconds } */
+    async routes() {
+      const d = await get('mon.kuma.live.get');
+      if (d?.success === false) throw new Error(`kuma returned an error body: ${d.error || 'no detail'}`);
+      if (!Array.isArray(d?.monitors)) throw new Error('kuma answered with no monitors list');
+      const ms = d.monitors;
+      const up = ms.filter(m => kumaState(m) === 'up'), down = ms.filter(m => kumaState(m) === 'down');
+      const pings = up.filter(m => m.ping != null).map(m => Number(m.ping)).filter(Number.isFinite); // a null ping is no measurement, not 0 ms
+      return { up: up.length, down: down.length, total: ms.length, avgPing: pings.length ? pings.reduce((a, b) => a + b, 0) / pings.length : null, downNames: down.map(m => m.name || `monitor ${m.id}`), ageSeconds: Number.isFinite(d.ageSeconds) ? d.ageSeconds : null };
+    },
+    /** `quox plan focus` -> { id, done, total } of the first focus stream; null when nothing is in focus or there is no roadmap. */
+    async plan() {
+      const rms = (await get('quoxplan.roadmaps.list'))?.roadmaps;
+      if (!Array.isArray(rms)) throw new Error('quoxplan answered with no roadmaps list');
+      if (!rms.length) return null;
+      const streams = (await get('quoxplan.roadmap.streams.list', { roadmapId: rms[0].id }, { lens: 'focus' }))?.streams;
+      if (!Array.isArray(streams)) throw new Error('quoxplan answered with no streams list');
+      if (!streams.length) return null;
+      // The first few focus streams, in the server's order: the first one that has phases gives "x of y". A stream with none (a meta
+      // stream) or whose phases could not be read is only named, never given a made-up count.
+      const top = streams.slice(0, 3);
+      const details = await Promise.allSettled(top.map(t => get('quoxplan.stream.get', { id: t.id })));
+      const rows = top.map((t, i) => {
+        const phases = details[i].status === 'fulfilled' && Array.isArray(details[i].value?.phases) ? details[i].value.phases : null;
+        return phases ? { id: t.id, done: phases.filter(p => p.done_at || /^(done|complete)/i.test(String(p.status || ''))).length, total: phases.length } : { id: t.id, done: null, total: null };
+      });
+      return rows.find(r => r.total > 0) || rows[0];
+    },
+    /** `quox fleet hosts` rows bucketed by health. */
+    async fleet() {
+      const d = await get('v1.fleet.hosts.list');
+      const hosts = Array.isArray(d) ? d : d?.hosts;
+      if (!Array.isArray(hosts)) throw new Error('unexpected fleet response');
+      const c = { total: hosts.length, healthy: 0, degraded: 0, unhealthy: 0, offline: 0, unknown: 0 };
+      for (const h of hosts) c[healthOf(h)]++;
+      return c;
+    },
+    /** The org's open security findings (engagement store). */
+    async findings() {
+      const d = await get('engagement.findings.open', {});
+      if (!Array.isArray(d?.findings)) throw new Error('unexpected findings response');
+      return { open: d.findings.length, severe: d.findings.filter(f => /^(critical|high)$/i.test(String(f.severity || ''))).length };
+    },
+  };
+}

package/lib/quoxon/dragonView.js

@@ -32,10 +32,10 @@ export function DragonTalk({ cols, label, talking, since, still = false }) {
 }
 
 /** /dragon-fly: one pass of the dragon in flight across the live region (qdragonFly.js). `still`: a single frame, no motion. */
-export function FlyLive({ cols, rows, startedAt, still = false }) {
+export function FlyLive({ cols, rows, startedAt, still = false, chromeH = null }) {
   useFrame();
   const c = flyCols(cols);
-  const cells = flyFrame(Date.now() - startedAt, c, { still, mono: mono(), theme: isLight() ? 'light' : 'dark', termRows: rows });
+  const cells = flyFrame(Date.now() - startedAt, c, { still, mono: mono(), theme: isLight() ? 'light' : 'dark', termRows: rows, chromeH });
   return h(Box, { flexDirection: 'column', marginTop: 1 },
     ...cells.map((row, k) => h(Text, { key: k, wrap: 'truncate' }, ...cellNodes(row, `f${k}-`))));
 }

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 };
 }

package/lib/quoxon/events.js

@@ -11,8 +11,13 @@
  *   turn     : null | { id, status: running|interrupting, startedAt, stage, activity }
  */
 
+import { eventLine } from '../core/announce.js';
+import { isDestructive, isDestructiveTool, destructiveObject } from './destructive.js';
+import { heldReason } from './bulkRisk.js';
+import { approvalSentence } from './approvalSentence.js';
 import { dividerStep } from './dividerAocl.js';
 import { approvalFacts } from './approvalFacts.js';
+import { planLines } from './planSteps.js';
 import { isConsentError, consentErrorText } from './consent.js';
 import { splitSettled } from './markdownSettle.js'; // not markdown.js: that loads React + Ink (QUOXON-LATENCY)
 import { nextActivity, actionActivity } from './activity.js';
@@ -78,6 +83,15 @@ export function textGate(st, ev) {
 
 const tms = (v) => { const t = typeof v === 'number' ? v : Date.parse(v); return Number.isFinite(t) ? t : null; };
 
+/** A machine source key (`devsuite_pack_install:<host>:<pack>:<ver>`) is never shown as a requester: it names a human-readable origin instead. */
+const SOURCE_KEY = /^[A-Za-z][\w.-]*(:[^:\s]+){2,}$/;
+const SOURCE_NAMES = [[/^devsuite_/i, 'DevSuite (skill-pack sync)']];
+export function humanRequester(v) {
+  const t = String(v ?? '').trim(); if (!t || !SOURCE_KEY.test(t)) return t || null;
+  const hit = SOURCE_NAMES.find(([re]) => re.test(t)); if (hit) return hit[1];
+  const head = t.split(':')[0].replace(/[_-]+/g, ' ').trim();
+  return head ? head.charAt(0).toUpperCase() + head.slice(1) : 'plugin or workflow';
+}
 const short = (v, n = 120) => { const t = typeof v === 'string' ? v : (v == null ? '' : JSON.stringify(v)); return t.length > n ? t.slice(0, n - 1) + '…' : t; };
 const argText = (a) => a && typeof a === 'object' && !Array.isArray(a) && (a.argv || a.command) ? argText(a.argv ?? a.command) : Array.isArray(a) ? a.join(' ') : (a && typeof a === 'object' ? Object.entries(a).filter(([, v]) => v != null && typeof v !== 'object').slice(0, 4).map(([k, v]) => `${k}=${v}`).join(' ') : (a == null ? '' : String(a)));
 
@@ -95,7 +109,7 @@ export function describeInboxItem(it) {
   const argv = m.argv ?? m.args ?? c.argv ?? c.args ?? p.argv ?? p.args ?? m.command ?? c.command ?? p.command ?? null;
   const cmd = short([m.leaf || c.leaf || p.leaf, argText(argv)].filter(Boolean).join(' ').trim() || null);
   const target = w.target || m.target || c.target || p.target || cmd || w.target_none || c.target_org || c.org_name || p.org_name || c.org_id || p.org_id || null;
-  const by = ob.agent || ob.agent_id || ob.session_name || ob.session || c.requested_by?.agent_label || c.source_label || p.source || it?.source || null;
+  const by = humanRequester(ob.agent || ob.agent_id || ob.session_name || ob.session || c.requested_by?.agent_label || c.source_label || p.source || it?.source || null);
   const what = w.summary ? String(w.summary) : (it?.title ? short(String(it.title), 160) : null);
   return { tool, target: target ? short(target, 200) : null, title: what, by: by ? String(by) : null, at: it?.created_at ?? it?.createdAt ?? null };
 }
@@ -125,7 +139,11 @@ export function cardFromInboxItem(it, { since = 0, userId = null, conversationId
   return {
     callId: `inbox:${it.id}`, inboxItemId: it.id, approvalId,
     tool, target: d.target, what: d.title, askedBy: d.by, askedAt: d.at, scope: null, risk: c.risk || null,
-    url: it.dashboard_url || null, shownAt: now, undescribable: !d.tool && !d.target,
+    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
+    destructive: isDestructive(it) ? destructiveObject(it) : null, // typed-name confirm before a y approves it
+    disruptive: [it, it.payload, c, m, it.payload?.what].some(o => o && o.disruptive === true), // server-marked: never batched
+    held: heldReason(it), // a risky ask is never part of a batch card
     facts: approvalFacts(it), // APPROVAL-WWWH: the exact command, hosts, chain, reason, time and read-only class
     // only an item that names THIS conversation is ours; anything else came from another session and must not take the keyboard
     foreign: !here,
@@ -137,7 +155,7 @@ export function cardFromInboxItem(it, { since = 0, userId = null, conversationId
 /** Where an inbox approval came from: its source label, else the payload source, else its type. */
 export function approvalSourceLabel(it) {
   const c = it?.payload?.approval_context || {};
-  return String(c.source_label || it?.payload?.source || it?.source || (c.requested_by && c.requested_by.agent_label) || it?.payload?.type || 'plugin or workflow');
+  return humanRequester(c.source_label || it?.payload?.source || it?.source || (c.requested_by && c.requested_by.agent_label) || it?.payload?.type || 'plugin or workflow');
 }
 
 /**
@@ -161,6 +179,18 @@ export function groupApprovals(items, { conversationId = null, cardIds = [] } =
   return Object.entries(g).filter(([, v]) => v.length).map(([group, v]) => ({ group, items: v }));
 }
 
+/**
+ * QLOOP-LIVE: which approval card the keyboard goes to first. Cards about a loop THIS window is watching lead, then the rest of
+ * this conversation, then other sessions' items (stable inside each rank). The loop id appears in the card's target / description.
+ */
+export function orderApprovals(cards, mineIds = []) {
+  const ids = (mineIds || []).filter(Boolean).map(String);
+  const rank = (c) => (ids.length && ids.some((id) => [c.target, c.what, c.facts?.where].some((t) => t != null && String(t).includes(id))) ? 0 : c.foreign ? 2 : 1);
+  return cards.map((c, i) => ({ c, i, r: rank(c) })).sort((a, b) => a.r - b.r || a.i - b.i).map((x) => x.c);
+}
+/** Cards raised by other sessions (the "other sessions: N" tail). */
+export const otherSessionsCount = (cards) => (cards || []).filter((c) => c.foreign).length;
+
 /** Privileged/elevated grants (hat switches and anything the server marks privileged or elevated) need an explicit confirm. */
 export function isPrivileged({ tool = '', risk = null, flag = false, title = '' } = {}) {
   if (flag === true) return true;
@@ -345,6 +375,8 @@ function reduceInner(s, a) {
       return { ...s, history: [...s.history, { id: nid(), kind: 'bang', text: a.text }] };
     case 'slotmsg': // QUOXON-MESH: a slot chat line (slotChat.js slotLine), incoming or sent
       return { ...s, history: [...s.history, { id: nid(), kind: 'slotmsg', line: a.line }] };
+    case 'loopcard': // QLOOP-LIVE: a live loop card; the card object is mutated in place by loopCards.js
+      return { ...s, history: [...s.history, { id: nid(), kind: 'loopcard', card: a.card }] };
     case 'tip': // a "did you know" tip (tips.js); text + the command to try
       return { ...s, history: [...s.history, { id: nid(), kind: 'tip', text: a.text, cmd: a.cmd }] };
     case 'bcard': // QUOXON-BROADCAST: the sender's framed delivery card (slash/broadcast.js broadcastCard), pure data
@@ -360,7 +392,7 @@ function reduceInner(s, a) {
     case 'help':
       return { ...s, history: [...s.history, { id: nid(), kind: 'help', model: a.model }] };
     case 'object': // inline object view (objects/): pure data, rebuilt at render width
-      return { ...s, history: [...s.history, { id: nid(), kind: 'object', obj: a.obj }] };
+      return { ...s, notify: scopeNotify(s.notify, a.obj), history: [...s.history, { id: nid(), kind: 'object', obj: a.obj }] };
     case 'error':
       return flush(addBlock(s, { kind: 'error', text: a.text }), false);
     case 'verbose':
@@ -418,11 +450,11 @@ function reduceInner(s, a) {
       const card = cardFromInboxItem(a.item, { since: s.turn?.startedAt ?? a.since ?? 0, userId: a.userId, conversationId: s.ctx.conversationId, now: a.now || 0 });
       if (card && card.approvalId) { // an event card raised without an inbox id learns it from the poll (else y answers a null id: 404)
         const j = s.approvals.findIndex(x => !x.inboxItemId && x.approvalId === card.approvalId);
-        if (j >= 0) { const approvals = s.approvals.slice(); approvals[j] = { ...approvals[j], inboxItemId: card.inboxItemId, url: approvals[j].url || card.url, facts: approvals[j].facts || card.facts }; return { ...s, approvals, seenInbox: { ...s.seenInbox, [card.inboxItemId]: true } }; }
+        if (j >= 0) { const approvals = s.approvals.slice(); approvals[j] = { ...approvals[j], inboxItemId: card.inboxItemId, url: approvals[j].url || card.url, facts: approvals[j].facts || card.facts, destructive: approvals[j].destructive || card.destructive }; return { ...s, approvals, seenInbox: { ...s.seenInbox, [card.inboxItemId]: true } }; }
       }
       if (card && card.approvalId) { // an event stub that could not be described learns its description from the inbox item
         const j = s.approvals.findIndex(x => x.undescribable && (x.inboxItemId === card.inboxItemId || x.approvalId === card.approvalId));
-        if (j >= 0 && !card.undescribable) { const approvals = s.approvals.slice(); approvals[j] = { ...approvals[j], tool: card.tool, target: card.target, what: card.what, askedBy: card.askedBy, askedAt: card.askedAt, facts: card.facts, undescribable: false }; return { ...s, approvals }; }
+        if (j >= 0 && !card.undescribable) { const approvals = s.approvals.slice(); approvals[j] = { ...approvals[j], tool: card.tool, target: card.target, what: card.what, askedBy: card.askedBy, askedAt: card.askedAt, facts: card.facts, destructive: approvals[j].destructive || card.destructive, undescribable: false }; return { ...s, approvals }; }
       }
       if (!card || s.seenInbox[card.inboxItemId] || s.approvals.some(x => x.inboxItemId === card.inboxItemId || (card.approvalId && x.approvalId === card.approvalId))) return s;
       if (card.foreign) { // another conversation's card: a compact notice, never the focused card
@@ -443,8 +475,12 @@ function reduceInner(s, a) {
       const rest = { ...s, inbox: (s.inbox || []).filter(x => x.id !== a.inboxItemId), seenInbox: a.inboxItemId ? { ...s.seenInbox, [a.inboxItemId]: true } : s.seenInbox, approvals: s.approvals.filter(x => x.callId !== a.callId && !(a.inboxItemId && x.inboxItemId === a.inboxItemId)), waiting: s.waiting.filter(x => x.callId !== a.callId && x.inboxItemId !== a.callId) };
       if (a.batch) return rest; // /approve N prints its own one-line summary
       if (a.quiet && a.action === 'approve') return rest;
-      if (a.action !== 'approve') return note(rest, `denied: ${a.tool || 'approval'}${a.target ? ` on ${a.target}` : ''}`, 'warn');
-      if (a.foreign) return note(rest, `✔ Approved ${a.tool || 'approval'}${a.target ? ` on ${a.target}` : ''}; the plugin or agent will act on it (its outcome is not tracked here)`, 'ok');
+      if (a.action !== 'approve') return note(rest, approvalSentence(a, false), 'warn');
+      if (a.foreign && a.approvalId) { // tracked: the poll adds one follow-up line with the outcome
+        const run = { callId: a.callId, approvalId: a.approvalId, tool: a.tool, target: a.target };
+        return note({ ...rest, running: [...rest.running.filter(x => x.callId !== a.callId), run] }, approvalSentence(a, true), 'ok');
+      }
+      if (a.foreign) return note(rest, approvalSentence(a, true), 'ok');
       if (a.tool === 'hat.switch') { // applied server-side by the inbox approve; nothing to wait for
         const to = String(a.target || '').split('\u2192').pop().replace(/\(privileged\)/, '').trim() || 'the new hat';
         return note(rest, `Hat switched to ${to}. Ask again and I'll carry on.`, 'ok');
@@ -458,7 +494,7 @@ function reduceInner(s, a) {
       const n = { ...s, running: s.running.filter(x => x.callId !== a.callId) };
       const what = run ? `${run.tool || 'approval'}${run.target ? ` on ${run.target}` : ''}` : 'approval';
       if (a.outcome === 'done') return note(n, `result: ${what}: ${a.text || 'completed'}`, 'ok');
-      if (a.outcome === 'failed') return note(n, `failed: ${what}: ${a.text || 'error'}`, 'warn');
+      if (a.outcome === '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');
       // 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)';
@@ -478,6 +514,15 @@ function reduceInner(s, a) {
 }
 
 /** The first card is armed from the moment it is actually SHOWN, not from when it was received. */
+/** An away/sitrep card that lists older items or a source it cannot see: the approvals bar must not say all-clear next to it. */
+function scopeNotify(n, obj) {
+  const d = obj?.data;
+  if (!d || (obj.type !== 'away' && obj.type !== 'sitrep')) return n;
+  const outstanding = obj.type === 'away' ? (d.standing?.count || 0) : (d.needs || []).length;
+  const blind = Array.isArray(d.blind) ? d.blind.length : 0;
+  return { ...n, outstanding, blind };
+}
+
 export function reduce(s, a) {
   let n = reduceInner(s, a);
   // TUI-DIVIDER: the bottom-rule AOCL strip, moved only by real turn events (dividerAocl.js).
@@ -485,6 +530,9 @@ export function reduce(s, a) {
     const dv = dividerStep(s.divider ?? null, a, a.now || 0);
     if (dv !== (n.divider ?? null)) n = { ...n, divider: dv };
   }
+  // A turn that ends WITHOUT a turn.finished event (stopped.local, turn.deferred, a /clear cancel) must not leave the
+  // strip open: endedAt stayed null, dividerLive stayed true, and the dot train + scrambled label looped on a dead turn.
+  if (n.divider && n.divider.endedAt == null && !n.turn) n = { ...n, divider: null };
   // The honest activity word: only real events move it (see activity.js).
   if (n.turn) {
     const act = a.type === 'event' ? nextActivity(s.turn?.act, a.ev, a.now || 0, { hasText: Boolean(n.turn.chars) })
@@ -558,6 +606,7 @@ function reduceEvent(s, ev, now) {
       let withTool = upsertTool(s, ev, {
         status, resultSummary: toolResultText(ev.result_summary, s.verbose), rawSummary: ev.result_summary, durationMs: ev.duration_ms,
         envelopeId: ev.envelope_id, receipt: ev.receipt || null,
+        ...(ev.card && typeof ev.card === 'object' && Array.isArray(ev.card.rows) ? { card: ev.card } : {}), // HITL-INBOX-BAR: a list answer's rows (toolCards.js)
         ...(Number.isFinite(ev.tools_used) ? { toolsUsed: ev.tools_used } : {})
       });
       if (first && withTool.turn) withTool = { ...withTool, turn: { ...withTool.turn, finishedTools: withTool.turn.finishedTools + 1 } };
@@ -572,7 +621,8 @@ function reduceEvent(s, ev, now) {
         target: ev.target, scope: ev.scope, risk: ev.risk, url: ev.dashboard_url, shownAt: now,
         undescribable: ev.describable === false || !ev.target,
         turnId: s.turn?.id ?? ev.turn_id ?? null, // the turn this card arrived in (a stream event is always this conversation)
-        privileged: isPrivileged({ tool: ev.tool, risk: ev.risk, flag: ev.privileged === true || ev.elevated === true })
+        privileged: isPrivileged({ tool: ev.tool, risk: ev.risk, flag: ev.privileged === true || ev.elevated === true }),
+        destructive: ev.destructive === true || ev.irreversible === true || isDestructiveTool(ev.tool) ? (() => { const v = String(ev.object_name || ev.target || ev.inbox_item_id || ev.tool || 'item').slice(0, 80); return { label: v, name: v }; })() : null
       };
       if (s.approvals.some(x => x.callId === card.callId)) return s;
       const dup = s.approvals.findIndex(x => (card.inboxItemId && x.inboxItemId === card.inboxItemId) || (card.approvalId && x.approvalId === card.approvalId));
@@ -590,6 +640,13 @@ function reduceEvent(s, ev, now) {
       const n = { ...s, approvals: s.approvals.filter(x => x.callId !== ev.call_id) };
       return card || ev.decision ? note(n, `${ev.decision === 'approved' ? '✔ approved by you' : `approval ${ev.decision || 'resolved'}`}${card ? `: ${card.tool} on ${card.target}` : ''}`, ev.decision === 'approved' ? 'ok' : 'warn') : n;
     }
+    // QUOX-ANNOUNCE A2: a Quox effect of this turn (memory saved, approval held, delegation ...), one line, same renderer as the CLI verbs.
+    case 'quox_event': {
+      const text = eventLine(ev);
+      if (!text) return s;
+      if (ev.status === 'fail') return addBlock(s, { kind: 'error', text });
+      return addBlock(s, { kind: 'note', text, tone: ev.status === 'ok' ? 'ok' : ev.status === 'busy' ? 'accent' : 'warn' });
+    }
     case 'steer.accepted': {
       const i = s.steering.findIndex(x => x.text === ev.text);
       const steering = i >= 0 ? s.steering.filter((_, k) => k !== i) : s.steering.slice(1);