quoxcli 0.2.0 → 0.4.0

package/lib/lucid/cards.js

@@ -0,0 +1,86 @@
+/**
+ * LUCID object cards: pure views for the deck, in the Quoxon object-card shape ({ box, rows } of
+ * { text, role } segments, see quoxon/objects/model.js). An area is a tile card; a Needs-you item is a card
+ * that opens in place into who / what / why / when and the actions. Nothing here reads a clock or does I/O.
+ *
+ * Roles are theme roles; the renderer (LucidCard.jsx) also understands 'sel' (the selected action bar).
+ * Text is WRAPPED to the card, never clipped, except for a single action line and the command line.
+ */
+import { seg, fit, padRow } from '../quoxon/objects/model.js';
+import { wrap, whenText, ageOf, GLYPH, clip } from './fmt.js';
+
+export const URGENCY_ROLE = { now: 'error', today: 'warn', 'this week': 'sky', whenever: 'muted', fyi: 'muted' };
+export const URGENCY_LABEL = { now: 'NOW', today: 'TODAY', 'this week': 'THIS WEEK', whenever: 'WHENEVER', fyi: 'FYI' };
+export const STATE_ROLE = { ok: 'ok', attention: 'warn', unknown: 'muted', blind: 'error' };
+export const STATE_WORD = { ok: 'ok', attention: 'attention', unknown: 'no signal', blind: 'blind' };
+
+const nm = (x) => (typeof x === 'string' ? x : (x && (x.label || x.name || x.L0 || x.id)) || '');
+const LW = 8; // label column of the open card
+
+/**
+ * An area tile. d: { area, label, state, L0, last, n (needs), active (filter on), selected, focused,
+ * expanded, now }. A tile is one status row; the selected tile in a focused pane opens to its sentence.
+ */
+export function lucidArea(d, cols) {
+  const w = Math.max(18, cols), inner = w - 4;
+  const all = d.area == null;
+  const glyph = all ? '◉' : (GLYPH[d.state] || '?');
+  const role = all ? 'sky' : (STATE_ROLE[d.state] || 'muted');
+  const right = `${d.active ? '● ' : ''}${d.n ? d.n : '·'}`;
+  const rows = [];
+  const word = all ? 'everything' : (STATE_WORD[d.state] || 'unknown');
+  const age = d.last && d.last.ts != null && d.now != null ? `last ${ageOf(d.last.ts, d.now)}` : '';
+  const line = age && [...`${word} · ${age}`].length <= inner ? `${word} · ${age}` : word;
+  rows.push([seg(line, d.selected ? 'value' : role === 'ok' ? 'muted' : role)]);
+  if (d.expanded && d.L0) for (const ln of wrap(d.L0, inner)) rows.push([seg(ln, 'value')]);
+  const mark = d.selected ? '▶ ' : '';
+  return {
+    box: {
+      width: w, title: `${mark}${glyph} ${fit(d.label || d.area || 'All areas', Math.max(4, inner - 8))}`, titleRole: role,
+      right, rightRole: d.n ? 'warn' : 'muted', border: d.selected ? 'sky' : 'faint', sel: d.selected ? (d.focused ? 'focus' : 'dim') : null,
+    },
+    rows,
+  };
+}
+
+/**
+ * A Needs-you card. d: { item, areaLabel, isNew, selected, focused, open, mSel, now }.
+ * Collapsed: the wrapped sentence. Open: the sentence, who/what/why/when, affects, then the actions with
+ * the highlighted one as a bar and its exact command beneath.
+ */
+export function lucidNeed(d, cols) {
+  const it = d.item, w = Math.max(24, cols), inner = w - 4;
+  const urg = it.urgency || 'whenever';
+  const a = it.L1 || {};
+  const ms = (it.L2 && it.L2.measures) || [];
+  const mark = d.selected ? '▶ ' : '';
+  const rows = [];
+  const text = (d.isNew ? '● ' : '') + (it.L0 || '');
+  wrap(text, inner).forEach((ln, i) => rows.push([seg(ln, d.isNew ? 'ok' : d.selected ? 'value' : 'text', d.selected)]));
+  if (d.open) {
+    const detail = (lbl, v) => wrap(v, inner - LW).forEach((ln, i) => rows.push([seg(i ? ' '.repeat(LW) : lbl.padEnd(LW), i ? 'muted' : 'label'), seg(ln, 'text')]));
+    for (const [lbl, v] of [['Who', a.who], ['What', a.what], ['Why', a.why], ['When', whenText(a.when, d.now)]]) if (v) detail(lbl, v);
+    if ((a.affected || []).length) rows.push([seg('Affects'.padEnd(LW), 'label'), seg(clip(a.affected.map(nm).filter(Boolean).join(', '), inner - LW), 'muted')]);
+    rows.push(ms.length ? [seg('What you can do', 'key', true)] : [seg('No actions to offer here. Esc closes.', 'muted')]);
+    ms.forEach((m, mi) => {
+      const on = mi === d.mSel;
+      const risk = ` ${m.risk}`;
+      const label = fit(m.say || m.label, Math.max(8, inner - 2 - risk.length));
+      if (on) rows.push([seg(`❯ ${label}${risk}`.padEnd(inner, ' '), 'sel', true)]);
+      else rows.push([seg('  ', 'muted'), seg(label, 'text'), seg(risk, m.risk === 'dangerous' ? 'error' : m.risk === 'gated' ? 'warn' : 'muted')]);
+    });
+    const cmd = ms[d.mSel] && ms[d.mSel].command;
+    if (cmd) rows.push([seg('  $ ', 'muted'), seg(clip(cmd, inner - 4), 'code')]);
+    else if (ms.some((m) => m.command)) rows.push([seg(' ', 'muted')]);
+  }
+  return {
+    box: {
+      width: w, title: `${mark}${URGENCY_LABEL[urg] || String(urg).toUpperCase()} · ${it.kind || 'item'}`, titleRole: URGENCY_ROLE[urg] || 'muted',
+      right: d.areaLabel || '', rightRole: 'muted', border: d.selected ? 'sky' : (urg === 'now' ? 'error' : 'faint'), sel: d.selected ? (d.focused ? 'focus' : 'dim') : null,
+    },
+    rows,
+  };
+}
+
+export const cardHeight = (view) => view.rows.length + 2;
+export { padRow };

package/lib/lucid/markdown.js

@@ -0,0 +1,81 @@
+/**
+ * The sitrep as chat Markdown (Discord, Matrix, slots): short, scannable, under one Discord message.
+ * Owner 2026-10-17: "Format your sitrep" after the spoken paragraph was posted to Discord as a wall of text.
+ * Pure: data in, string out. No colour codes, no box drawing (chat clients mangle both).
+ */
+
+const URGENCY = { now: '🔴', today: '🟠', this_week: '🟡', week: '🟡', whenever: '⚪', fyi: '⚪' };
+const STATE = { attention: '⚠️', ok: '✅', partial: '🟡', unknown: '❔', blind: '⛔' };
+export const MAX_CHARS = 1900; // Discord's limit is 2000 per message
+
+const clip = (s, n) => {
+  const t = String(s || '').replace(/\s+/g, ' ').trim();
+  return t.length > n ? `${t.slice(0, n - 1)}…` : t;
+};
+
+function age(ms) {
+  if (!(ms > 0)) return '';
+  const m = Math.floor(ms / 60000);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 48) return `${h}h`;
+  return `${Math.floor(h / 24)}d`;
+}
+
+function clockLondon(now) {
+  try {
+    return new Intl.DateTimeFormat('en-GB', { timeZone: 'Europe/London', hour: '2-digit', minute: '2-digit', timeZoneName: 'short' }).format(new Date(now));
+  } catch { return new Date(now).toISOString().slice(11, 16) + ' UTC'; }
+}
+
+/** opts: { now, maxNeeds (default 6), maxChars (default MAX_CHARS) } */
+export function renderSitrepMarkdown(data, opts = {}) {
+  const sit = (data && data.situation) || data || {};
+  const now = opts.now ?? Date.now();
+  const maxNeeds = opts.maxNeeds ?? 6;
+  const maxChars = opts.maxChars ?? MAX_CHARS;
+  const cov = sit.coverage || (sit.cannot_see && sit.cannot_see.coverage) || { live: 0, expected: 0 };
+  const missing = sit.coverage && Array.isArray(sit.coverage.missing) ? sit.coverage.missing : [];
+  const needs = Array.isArray(sit.needs_you) ? sit.needs_you : [];
+  const low = needs.filter((n) => n.urgency === 'whenever' || n.urgency === 'fyi').length;
+
+  const out = [];
+  out.push(`**◉ LUCID sitrep** · ${clockLondon(now)} · ${cov.live}/${cov.expected} sources`);
+  out.push('');
+  if (!needs.length) {
+    out.push('**Needs you:** nothing right now.');
+  } else {
+    out.push(`**Needs you (${needs.length}${low ? `, ${low} low priority` : ''})**`);
+    needs.slice(0, maxNeeds).forEach((n, i) => {
+      const w = n.L1 && n.L1.when && n.L1.when.waited_ms;
+      const tail = [n.area, age(w)].filter(Boolean).join(', ');
+      out.push(`${i + 1}. ${URGENCY[n.urgency] || '•'} ${clip(n.L0, 90)}${tail ? ` _(${tail})_` : ''}`);
+    });
+    if (needs.length > maxNeeds) out.push(`…and ${needs.length - maxNeeds} more: \`quox sitrep\``);
+  }
+
+  const areas = Array.isArray(sit.areas) ? sit.areas : [];
+  if (areas.length) {
+    out.push('');
+    out.push('**At a glance**');
+    for (const a of areas) out.push(`${STATE[a.state] || '•'} **${a.label || a.area}**: ${clip(a.L0, 80)}`);
+  }
+
+  const dau = Array.isArray(sit.doesnt_add_up) ? sit.doesnt_add_up : [];
+  if (dau.length) {
+    out.push('');
+    out.push(`**Doesn't add up (${dau.length}):** ${clip(dau[0].L0, 90)}${dau.length > 1 ? ' …' : ''}`);
+  }
+  out.push('');
+  out.push(missing.length ? `**Can't see:** ${missing.join(', ')}` : `**Can't see:** nothing, every source is reporting.`);
+
+  // Stay inside one chat message: drop "at a glance" rows from the bottom, then needs, never the header.
+  let text = out.join('\n');
+  while (text.length > maxChars && out.length > 3) {
+    const i = out.findLastIndex((l) => /^(✅|⚠️|🟡|❔|⛔|•) \*\*/.test(l));
+    if (i < 0) break;
+    out.splice(i, 1);
+    text = out.join('\n');
+  }
+  return text.length > maxChars ? `${text.slice(0, maxChars - 1)}…` : text;
+}

package/lib/lucid/motion.js

@@ -0,0 +1,56 @@
+/**
+ * LUCID deck motion: pure helpers for the deck's ONE clock (quoxon/motion/clock.js).
+ *
+ * Idle is still. The deck declares a demand each render; the clock keeps one timer for the soonest demand and
+ * none at all when nothing asks. Frames (~12 fps) are demanded ONLY while something is visibly moving: a fetch
+ * in flight (the Q works), the Q settling after a state change (a short window, then still colour), or a
+ * card dropping in. Everything else is a one-shot wake (toast expiry, ghost expiry, the minute tick).
+ *
+ * LUCID state -> Q state (qglyph.js): needs you = waiting, fetching = working, unreachable = failing,
+ * quiet = resting. Failing wins over working so an outage never reads as busy.
+ */
+import { FRAME_MS } from '../quoxon/motion/clock.js';
+
+export { FRAME_MS };
+/** After a state change the Q animates this long, then holds a still colour (no timer, no writes). */
+export const SETTLE_MS = 2400;
+/** A card dropping in is revealing for this long from its start (rows decode, then a short afterglow). */
+export const REVEAL_MS = 1500;
+/** Cards of one load start this far apart so the board fills top to bottom. */
+export const STAGGER_MS = 70;
+
+export function glyphStateOf({ err = null, fetching = false, needs = 0 } = {}) {
+  if (err) return 'failing';
+  if (fetching) return 'working';
+  return needs > 0 ? 'waiting' : 'resting';
+}
+
+/** Is the Q moving at `now`? Working moves while it lasts; every other state settles after SETTLE_MS. */
+export function glyphAnimating({ state, since, now, motion }) {
+  if (!motion) return false;
+  if (state === 'working') return true;
+  return since != null && now - since < SETTLE_MS;
+}
+
+/** Seconds into a card's reveal, or Infinity when settled (or motion is off). A future start is negative. */
+export function revealT(startAt, now, motion) {
+  if (!motion || startAt == null) return Infinity;
+  const ms = now - startAt;
+  return ms >= REVEAL_MS ? Infinity : ms / 1000;
+}
+
+/**
+ * The demands for this render. frames: something is moving right now. at: epoch ms of one-shot wakes
+ * (past or null entries are ignored). Without motion there are no frame demands at all.
+ */
+export function deckDemands({ motion = false, frames = false, at = [], now = Date.now() } = {}) {
+  const d = [];
+  if (motion && frames) d.push({ every: FRAME_MS });
+  let soonest = null;
+  for (const a of at) if (Number.isFinite(a) && a > now && (soonest == null || a < soonest)) soonest = a;
+  if (soonest != null) d.push({ at: soonest });
+  return d;
+}
+
+/** Next wall-clock minute boundary for a displayed time (the injected clock, so tests stay deterministic). */
+export const nextMinuteAt = (wall, shown) => wall + (60000 - (shown % 60000));

package/lib/quoxon/EXTENSIONS.md

@@ -0,0 +1,23 @@
+# quoxon extensions
+
+Optional npm packages that add a surface to quoxon (a MIDI pad deck, a status bar). Core ships none and knows none by name.
+
+**Loading.** Nothing loads unless the package is installed AND listed in `~/.quox/extensions.json`
+(`quox ext add|remove|list <pkg>`; `/ext list|on|off <name>` inside quoxon). Install with `npm i -g <pkg>`.
+Resolution order: env `QUOX_EXT_<NAME>_MODULE` (name upper-cased, non-alphanumerics to `_`), a local `import(name)`,
+then the global npm root (`dirname(execPath)/../lib/node_modules` first, then `npm root -g` once, cached).
+`/ext list` names where each was found; a miss lists where it looked.
+
+**Module.** Default export (or the module itself):
+`{ name, version, commands?: [{ name: '/deck', help, run(args, ctx) }], create({ emit, log, settings }) -> { update(state), close() } }`.
+Its slash commands exist only while it is loaded. `run` may return a string or `{ text, tone }`.
+
+**State** (`update(state)`, deduped, at most 1/s):
+`{ org:{id,name}, approvals:{count, items:[{n,id,risk:'low'|'high',title,agent,options?:[{key,label}]}]}, health:{<name>:'ok'|'warn'|'down'},
+loops:[{id,title,turn,max,status}], fleet:{total,online,offline,warn,hosts:[{name,state:'ok'|'warn'|'down'}] (max 16)},
+evidence:{chain:'ok'|'broken'|'unknown', checked_at}, sessions:{active}, event?:{kind,text,level} }`.
+`fleet` comes from a 30 s poll of the host list while an extension is loaded. `evidence.chain` is `unknown` until quoxon holds a chain status.
+
+**emit.** `{type:'open_approval', n}` opens approval n; `{type:'pick', n, option}` only fills the composer with the
+answer command (the user presses Enter, high risk still needs the step-up PIN); `{type:'alert_ack'}` clears the event.
+An extension can never resolve an approval. emit is ignored once the extension is unloaded.

package/lib/quoxon/activity.js

@@ -37,6 +37,13 @@ const TOOL_TABLE = [
   [/(^|_)(list|get|status)$|^contacts_/, 'Looking up'],
 ];
 
+/** QUOXON-FW3: "Delegating <Agent> · <task gist>" instead of an anonymous delegate_to_agent. */
+function delegateTarget(ev) {
+  const id = ev.agent_id || (String(ev.summary || '').match(/\bagent_id=(\S+)/) || [])[1] || '';
+  const name = ev.agent_name || id;
+  return { ...ev, target: [name, ev.task_gist].filter(Boolean).join(' \u00b7 ') };
+}
+
 /** { word, detail } for a tool call. Unknown tools are "Working" with the tool name, never a guess. */
 export function toolWord(tool, ev = {}) {
   const name = String(tool || '').toLowerCase();
@@ -46,7 +53,7 @@ export function toolWord(tool, ev = {}) {
   return { word: 'Working', detail: name || null };
 }
 
-const mk = (word, detail = null, now = 0, tone = 'work', flash = null) => ({ word, detail: detail ? clipD(detail) : null, tone, flash, since: now });
+const mk = (word, detail = null, now = 0, tone = 'work', flash = null, tool = null) => ({ word, detail: detail ? clipD(detail) : null, tone, flash, since: now, ...(tool ? { tool: clipD(tool, 40) } : {}) });
 export const initialActivity = (now = 0) => mk('Sending', null, now); // the request was dispatched: true from turn.begin
 
 /** Trace lines from the governance chain. Labels as the server sends them. */
@@ -82,7 +89,12 @@ export function nextActivity(prev, ev, now = 0, ctx = {}) {
       return p;
     }
     case 'trace': { const t = traceWord(ev); return t ? mk(t[0], t[1], now) : p; }
-    case 'tool.started': { const t = toolWord(ev.tool, ev); return mk(t.word, t.detail, now); }
+    case 'tool.started': { const t = toolWord(ev.tool, ev.tool === 'delegate_to_agent' ? delegateTarget(ev) : ev); return mk(t.word, t.detail, now, 'work', null, ev.tool || null); }
+    case 'delegation.progress': { // QUOXON 2026-10-17: a specialist's real tool call, forwarded by the server
+      if (!ev.tool) return p;
+      const who = ev.agent_name || ev.agent_id || 'specialist';
+      return mk('Delegating', `${who} \u00b7 ${ev.tool}${ev.detail ? ` (${ev.detail})` : ''}`, now, 'work', null, ev.tool);
+    }
     case 'tool.finished': return ev.status === 'failed' ? { ...p, flash: now } : p; // keep the word, flash the Q only
     case 'approval.requested': return mk('Waiting', 'for your approval', now, 'wait');
     case 'approval.resolved': return mk('Resuming', null, now);

package/lib/quoxon/aocl.js

@@ -0,0 +1,117 @@
+/**
+ * QUOXON-AOCL: one compact AOCL line per turn, and the full per-layer table on demand (/aocl).
+ *
+ * The server sends ONE `aocl.summary` per streamed turn ({ layers:[{id,outcome,ms,reason}],
+ * total, accounted, passed, bypassed, rejected, rejected_at, ms, verdict? }) and an
+ * `aocl.verdict` when L8 flags text that was already on screen. Older servers send only
+ * per-layer `trace` rows (protocol aocl, label "L1 identity complete"); those are folded
+ * into the same line so nothing is lost, and the line says how many layers were reported.
+ */
+
+export const LAYER_NAMES = {
+  L0: 'ingress', L1: 'identity', L2: 'router', L3: 'policy', L4: 'planner', L5: 'context',
+  L6: 'shape', L7: 'delegate', L8: 'verify', L9: 'assemble', L10: 'audit'
+};
+const ORDER = Object.keys(LAYER_NAMES);
+const OUTCOME_WORD = { complete: 'passed', bypass: 'bypassed', reject: 'rejected', not_run: 'not run' };
+const OUTCOME_GLYPH = { complete: '✔', bypass: '○', reject: '✖', not_run: '?' };
+
+/** A per-layer AOCL trace row (folded into the one-line summary instead of a row per layer). */
+export const isLayerTrace = (ev) => ev?.protocol === 'aocl' && /^L(?:10|[0-9])\b/.test(String(ev.label || ''));
+
+const fmtMs = (ms) => {
+  const n = Number(ms);
+  if (!Number.isFinite(n)) return '';
+  return n < 10 ? `${Math.round(n * 10) / 10} ms` : n < 1000 ? `${Math.round(n)} ms` : `${(n / 1000).toFixed(1)} s`;
+};
+
+/** Normalise a server summary (tolerant of missing fields). */
+export function normaliseSummary(ev) {
+  const layers = Array.isArray(ev?.layers) ? ev.layers.filter(l => l && l.id).map(l => ({ id: String(l.id), outcome: String(l.outcome || 'not_run'), ms: Number(l.ms) || 0, ...(l.reason ? { reason: String(l.reason) } : {}) })) : [];
+  const count = (o) => layers.filter(l => l.outcome === o).length;
+  const rejected = layers.filter(l => l.outcome === 'reject');
+  return {
+    layers,
+    total: Number(ev?.total) || 11,
+    accounted: Number.isFinite(Number(ev?.accounted)) ? Number(ev.accounted) : layers.filter(l => l.outcome !== 'not_run').length,
+    passed: Number.isFinite(Number(ev?.passed)) ? Number(ev.passed) : count('complete'),
+    bypassed: Number.isFinite(Number(ev?.bypassed)) ? Number(ev.bypassed) : count('bypass'),
+    rejected: Number.isFinite(Number(ev?.rejected)) ? Number(ev.rejected) : rejected.length,
+    rejectedAt: ev?.rejected_at || (rejected[0] && rejected[0].id) || null,
+    ms: Number.isFinite(Number(ev?.ms)) ? Number(ev.ms) : null,
+    verdict: ev?.verdict || null,
+    legacy: Boolean(ev?.legacy)
+  };
+}
+
+/** Build a summary from legacy per-layer trace rows (a server without aocl.summary). */
+export function summaryFromTraces(traces) {
+  const layers = [];
+  for (const t of traces || []) {
+    const m = String(t.label || '').match(/^(L(?:10|[0-9]))\b.*?\b(complete|bypass|reject)\b/);
+    if (!m || layers.some(l => l.id === m[1])) continue;
+    const ms = String(t.detail || '').match(/(\d+(?:\.\d+)?)\s*ms/);
+    layers.push({ id: m[1], outcome: m[2], ms: ms ? Number(ms[1]) : 0 });
+  }
+  layers.sort((a, b) => ORDER.indexOf(a.id) - ORDER.indexOf(b.id));
+  const ms = layers.reduce((n, l) => n + l.ms, 0);
+  return normaliseSummary({ layers, total: 11, accounted: layers.length, ms, legacy: true });
+}
+
+/**
+ * The one line: "AOCL 11/11 ✔ · 9 passed · 2 bypassed · 34 ms" (the caller draws the ▤ icon).
+ * -> { segs: [{ t, tone }] } where tone is 'ok' | 'fail' | 'warn' | 'text'.
+ */
+export function aoclLineSegs(sum) {
+  const s = sum || normaliseSummary({});
+  const segs = [{ t: `${s.accounted}/${s.total} `, tone: 'text' }];
+  if (s.rejected > 0) {
+    const rl = s.layers.find(l => l.id === s.rejectedAt);
+    segs.push({ t: '✖', tone: 'fail' }, { t: ` ${[s.rejectedAt || 'a layer', LAYER_NAMES[s.rejectedAt]].filter(Boolean).join(' ')} rejected${rl && rl.reason ? `: ${rl.reason}` : ''}`, tone: 'fail' });
+  } else if (s.accounted < s.total) {
+    segs.push({ t: '⚠', tone: 'warn' }, { t: ` only ${s.accounted} of ${s.total} reported`, tone: 'warn' });
+  } else {
+    segs.push({ t: '✔', tone: 'ok' });
+  }
+  segs.push({ t: ` · ${s.passed} passed`, tone: 'text' });
+  if (s.bypassed) segs.push({ t: ` · ${s.bypassed} bypassed`, tone: 'text' });
+  if (s.verdict && s.verdict.verdict === 'warned') segs.push({ t: ` · ${s.verdict.layer || 'L8'} warned`, tone: 'warn' });
+  if (s.toolsOffered != null) segs.push({ t: ` · ${s.toolsOffered} tool${s.toolsOffered === 1 ? '' : 's'}`, tone: 'text' });
+  if (s.ms != null) segs.push({ t: ` · ${fmtMs(s.ms)}`, tone: 'text' });
+  if (s.legacy) segs.push({ t: ' · server sent no summary', tone: 'warn' });
+  return { segs };
+}
+
+export const aoclLineText = (sum) => 'AOCL ' + aoclLineSegs(sum).segs.map(x => x.t).join('');
+
+/** The /aocl table: [text, tone] rows, one per layer, for the last turn. */
+export function aoclTableLines(sum) {
+  if (!sum) return [['No AOCL record yet. Send a message, then /aocl shows every layer of that turn.', 'warn']];
+  const out = [[`▤ AOCL last turn │ ${aoclLineText(sum).slice(5)}`, sum.rejected ? 'error' : 'accent']];
+  const byId = Object.fromEntries(sum.layers.map(l => [l.id, l]));
+  for (const id of ORDER) {
+    const l = byId[id] || { id, outcome: 'not_run', ms: 0 };
+    const word = OUTCOME_WORD[l.outcome] || l.outcome;
+    const line = `${OUTCOME_GLYPH[l.outcome] || '·'} ${id.padEnd(4)}${LAYER_NAMES[id].padEnd(10)}${word.padEnd(10)}${fmtMs(l.ms).padStart(8)}${l.reason ? `   ${l.reason}` : ''}`;
+    out.push([line, l.outcome === 'reject' ? 'error' : l.outcome === 'not_run' ? 'warn' : l.outcome === 'complete' ? 'ok' : 'accent']);
+  }
+  if (sum.toolsOffered != null) { // the VOLT "tools offered" list, on demand instead of opening every turn
+    out.push([`tools offered to the model: ${sum.toolsOffered}${sum.toolsTotal != null ? ` of ${sum.toolsTotal}` : ''}`, 'accent']);
+    let row = '  ';
+    for (const t of String(sum.toolsList || '').split(/,\s*/).filter(Boolean)) {
+      if (row.length + t.length + 2 > 76 && row.trim()) { out.push([row.replace(/,?\s*$/, ''), 'text']); row = '  '; }
+      row += t + ', ';
+    }
+    if (row.trim()) out.push([row.replace(/,?\s*$/, ''), 'text']);
+  }
+  if (sum.verdict) out.push([`${sum.verdict.layer || 'L8'} ${sum.verdict.verdict}: ${sum.verdict.reason || ''}${sum.verdict.delivered ? ' (the text was already shown)' : ''}`, sum.verdict.verdict === 'blocked' ? 'error' : 'warn']);
+  if (sum.legacy) out.push(['This server sent per-layer traces only, no aocl.summary: layers it did not report are shown as not run.', 'warn']);
+  return out;
+}
+
+/** The note shown when L8 flags an answer that is already on screen. */
+export function verdictNote(v) {
+  const reason = v?.reason ? `: ${v.reason}` : '';
+  if (v?.verdict === 'blocked') return { text: `✖ AOCL ${v.layer || 'L8'} blocked this answer after it was shown${reason}. Do not act on it.`, tone: 'error' };
+  return { text: `⚠ AOCL ${v?.layer || 'L8'} flagged this answer${reason}.`, tone: 'warn' };
+}