quoxcli 0.0.0-stage → 0.3.1

package/lib/lucid/sitrep.js

@@ -0,0 +1,173 @@
+/**
+ * `quox lucid --sitrep`: a one-shot, width-aware ANSI snapshot of the LUCID
+ * situation, built to read well in a terminal and when pasted into a chat.
+ * Pure: renderSitrep(situation, opts) -> string. Colour is explicit (opts.color).
+ */
+import {
+  GLYPH, STATE_HEX, URGENCY, PALETTE, wrap, clip, padEnd, vlen, ageOf, meter,
+  clockLondon, firstMeasure, whenText, changedWords, blindSpots,
+} from './fmt.js';
+
+const R = '\x1b[0m';
+
+export function makePainter(color) {
+  const rgb = (hex) => {
+    const n = parseInt(hex.slice(1), 16);
+    return `\x1b[38;2;${(n >> 16) & 255};${(n >> 8) & 255};${n & 255}m`;
+  };
+  const wrapSeq = (seq, s) => (color && s !== '' ? `${seq}${s}${R}` : s);
+  return {
+    color,
+    fg: (hex, s) => wrapSeq(rgb(hex), s),
+    bold: (s) => wrapSeq('\x1b[1m', s),
+    dim: (s) => wrapSeq(rgb(PALETTE.dim), s),
+    muted: (s) => wrapSeq(rgb(PALETTE.muted), s),
+    boldFg: (hex, s) => wrapSeq(`\x1b[1m${rgb(hex)}`, s),
+    pill: (hex, s) => (color ? `\x1b[48;2;${parseInt(hex.slice(1, 3), 16)};${parseInt(hex.slice(3, 5), 16)};${parseInt(hex.slice(5, 7), 16)}m\x1b[38;2;17;24;39m\x1b[1m[${s}]${R}` : `[${s}]`),
+  };
+}
+
+function tile(area, w, p, now) {
+  const inner = w - 4;
+  const hex = STATE_HEX[area.state] || STATE_HEX.unknown;
+  const glyph = GLYPH[area.state] || GLYPH.unknown;
+  const label = clip(area.label || area.area, inner - 3);
+  const topPlain = `─ ${glyph} ${label} `;
+  const top = p.fg(PALETTE.dim, '╭') + p.fg(PALETTE.dim, '─ ') + p.boldFg(hex, glyph) + ' ' + p.bold(label) + ' '
+    + p.fg(PALETTE.dim, '─'.repeat(Math.max(0, w - 2 - [...topPlain].length)) + '╮');
+  let body = wrap(area.L0 || 'No signal yet.', inner);
+  if (body.length > 3) body = [...body.slice(0, 2), clip(body[2] + ' ' + body.slice(3).join(' '), inner)];
+  const rows = body.map((l) => p.fg(area.state === 'ok' ? PALETTE.muted : PALETTE.text, l));
+  const last = area.last;
+  if (last) {
+    const tail = `${last.outcome ? ` (${last.outcome})` : ''} ${ageOf(last.ts, now)} ago`;
+    rows.push(p.dim(`last: ${clip(last.L0, Math.max(6, inner - 6 - [...tail].length))}${tail}`));
+  } else rows.push(p.dim('nothing yet'));
+  const v = p.fg(PALETTE.dim, '│');
+  const mid = rows.map((r) => `${v} ${padEnd(r, inner)} ${v}`);
+  const bot = p.fg(PALETTE.dim, '╰' + '─'.repeat(w - 2) + '╯');
+  return [top, ...mid, bot];
+}
+
+function grid(tiles, width, p, now) {
+  const gap = 1;
+  const tw = Math.floor((width - gap) / 2);
+  const out = [];
+  for (let i = 0; i < tiles.length; i += 2) {
+    const a = tile(tiles[i], tw, p, now);
+    const b = tiles[i + 1] ? tile(tiles[i + 1], tw, p, now) : [];
+    const h = Math.max(a.length, b.length);
+    const fill = (t, idx, wd) => {
+      if (t[idx] !== undefined) return t[idx];
+      // pad short tile with an empty bordered row before its bottom edge
+      return ' '.repeat(wd);
+    };
+    // equalise heights by inserting blank rows before the bottom border
+    const eq = (t) => {
+      if (!t.length) return t;
+      const bottom = t[t.length - 1];
+      const row = `${p.fg(PALETTE.dim, '│')}${' '.repeat(tw - 2)}${p.fg(PALETTE.dim, '│')}`;
+      const body = t.slice(0, -1);
+      while (body.length < h - 1) body.push(row);
+      return [...body, bottom];
+    };
+    const ea = eq(a), eb = eq(b);
+    for (let k = 0; k < h; k++) out.push(`${fill(ea, k, tw)}${' '.repeat(gap)}${eb.length ? fill(eb, k, tw) : ''}`.trimEnd());
+  }
+  return out;
+}
+
+function section(title, width, p, extra = '') {
+  const t = ` ${title}${extra ? ' ' + extra : ''} `;
+  return p.boldFg(PALETTE.accent, title) + (extra ? ' ' + p.dim(extra) : '') + ' ' + p.fg(PALETTE.dim, '─'.repeat(Math.max(2, width - vlen(t))));
+}
+
+export function renderSitrep(data, opts = {}) {
+  const width = Math.max(60, Math.min(opts.width || 100, 140));
+  const now = opts.now ?? Date.now();
+  const p = makePainter(opts.color !== false);
+  const sit = (data && data.situation) || data || {};
+  const cs = sit.cannot_see || {};
+  const cov = cs.coverage || { live: 0, expected: 0 };
+  const lines = [];
+
+  const sep = p.dim('│');
+  const left = `${p.boldFg(PALETTE.brand, '◉ LUCID')} ${sep} ${p.bold('sitrep')} ${sep} ${clockLondon(now)} ${p.dim('·')} `
+    + `${p.fg(cov.live < cov.expected ? STATE_HEX.attention : STATE_HEX.ok, `${cov.live}/${cov.expected}`)} sources`;
+  lines.push(left);
+  lines.push(p.fg(PALETTE.dim, '━'.repeat(width)));
+
+  lines.push('');
+  for (const l of wrap(sit.L0 || 'No briefing available.', width)) lines.push(p.fg(PALETTE.text, l));
+  lines.push('');
+
+  const areas = sit.areas || [];
+  if (areas.length) {
+    lines.push(...grid(areas, width, p, now));
+    lines.push('');
+  }
+
+  const needs = sit.needs_you || [];
+  lines.push(section('NEEDS YOU', width, p, needs.length ? `${needs.length}` : ''));
+  if (!needs.length) {
+    lines.push(p.fg(STATE_HEX.ok, '  Nothing needs you right now.') + (cs.silent && cs.silent.length ? p.dim('  (but see what I can\'t see)') : ''));
+  }
+  const iw = width - 5;
+  needs.forEach((it, i) => {
+    const u = URGENCY[it.urgency] || URGENCY.whenever;
+    const num = String(i + 1).padStart(2);
+    lines.push('');
+    lines.push(`${p.dim(num + '.')} ${p.pill(u.hex, u.label)} ${p.bold(clip(it.L0 || '', width - 8 - u.label.length))}`);
+    const a = it.L1 || {};
+    const field = (k, v) => {
+      if (!v) return;
+      const wl = wrap(v, iw - 6);
+      wl.forEach((l, j) => lines.push(`     ${j === 0 ? p.dim(k.padEnd(5)) : '     '}${p.fg(PALETTE.muted, l)}`));
+    };
+    field('Who', a.who); field('What', a.what); field('Why', a.why); field('When', whenText(a.when, now));
+    const m = firstMeasure(it);
+    if (m) {
+      const say = m.say || m.label;
+      lines.push(`     ${p.boldFg(PALETTE.brand, '→ do:')} ${p.fg(PALETTE.text, clip(say, iw - 8))}`);
+      const cmd = m.command || m.url;
+      if (cmd) lines.push(`          ${p.fg(PALETTE.code, clip(cmd, iw - 5))}`);
+    }
+  });
+  lines.push('');
+
+  const changed = sit.changed || [];
+  lines.push(section('SINCE YOU LOOKED', width, p, changed.length ? `${changed.length}` : ''));
+  if (!changed.length) lines.push(p.dim('  Nothing has changed.'));
+  for (const c of changed.slice(0, 8)) {
+    const o = changedWords(c);
+    const tail = `${o ? o + ' ' : ''}${ageOf(c.ts, now)} ago`;
+    lines.push(`  ${p.dim('•')} ${clip(c.L0 || '', width - 6 - tail.length)} ${p.dim(tail)}`);
+  }
+  if (changed.length > 8) lines.push(p.dim(`  … and ${changed.length - 8} more`));
+  lines.push('');
+
+  const da = sit.doesnt_add_up || [];
+  if (da.length) {
+    lines.push(section("DOESN'T ADD UP", width, p, `${da.length}`));
+    for (const x of da.slice(0, 5)) {
+      lines.push(`  ${p.dim('•')} ${p.bold(clip(x.L0 || '', width - 6))}${x.urgent ? ' ' + p.pill(URGENCY.today.hex, 'TODAY') : ''}`);
+      for (const [k, v] of [['Claimed', x.claimed], ['Observed', x.observed]]) {
+        if (!v) continue;
+        wrap(v, width - 16).forEach((l, j) => lines.push(`     ${j === 0 ? p.dim(k.padEnd(9)) : ' '.repeat(9)}${p.fg(PALETTE.muted, l)}`));
+      }
+    }
+    if (da.length > 5) lines.push(p.dim(`  … and ${da.length - 5} more (quox lucid blind)`));
+    lines.push('');
+  }
+
+  lines.push(section("WHAT I CAN'T SEE", width, p, `${meter(cov.live, cov.expected)} ${cov.live}/${cov.expected}`));
+  const spots = blindSpots(cs);
+  if (!spots.length && cov.live >= cov.expected) lines.push(p.dim('  Every expected source is speaking.'));
+  else if (!spots.length) lines.push(p.fg(STATE_HEX.attention, `  ${cov.expected - cov.live} expected source(s) are not reporting.`));
+  for (const s of spots) {
+    for (const [j, l] of wrap(s.text, width - 4).entries()) {
+      lines.push(`  ${p.fg(s.k === 'failing' ? STATE_HEX.blind : STATE_HEX.attention, l)}`);
+    }
+  }
+  return lines.join('\n') + '\n';
+}

package/lib/plugins/loader.js

@@ -0,0 +1,93 @@
+/**
+ * Plugin loader for QuoxCLI
+ *
+ * Discovers and loads plugins from:
+ *   1. ~/.quox/plugins/  (user plugins)
+ *   2. QUOX_PLUGIN_DIR env var (custom path)
+ *
+ * Plugin format: each plugin is a directory with an index.js that exports:
+ *   { name, version, description, register(program, context) }
+ */
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { pathToFileURL } from 'node:url';
+
+function getPluginDirs() {
+  const dirs = [join(homedir(), '.quox', 'plugins')];
+  if (process.env.QUOX_PLUGIN_DIR) {
+    dirs.push(process.env.QUOX_PLUGIN_DIR);
+  }
+  return dirs;
+}
+
+export async function discoverPlugins() {
+  const plugins = [];
+
+  for (const dir of getPluginDirs()) {
+    if (!existsSync(dir)) continue;
+
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const pluginPath = join(dir, entry);
+      if (!statSync(pluginPath).isDirectory()) continue;
+
+      const indexPath = join(pluginPath, 'index.js');
+      if (!existsSync(indexPath)) continue;
+
+      plugins.push({
+        name: entry,
+        path: pluginPath,
+        indexPath,
+      });
+    }
+  }
+
+  return plugins;
+}
+
+export async function loadPlugin(pluginInfo) {
+  try {
+    const moduleUrl = pathToFileURL(pluginInfo.indexPath).href;
+    const mod = await import(moduleUrl);
+
+    if (typeof mod.register !== 'function') {
+      throw new Error(`Plugin "${pluginInfo.name}" does not export a register() function`);
+    }
+
+    return {
+      name: mod.name || pluginInfo.name,
+      version: mod.version || '0.0.0',
+      description: mod.description || '',
+      register: mod.register,
+    };
+  } catch (err) {
+    return {
+      name: pluginInfo.name,
+      error: err.message,
+    };
+  }
+}
+
+export async function loadAllPlugins(program, context) {
+  const discovered = await discoverPlugins();
+  const loaded = [];
+  const errors = [];
+
+  for (const pluginInfo of discovered) {
+    const plugin = await loadPlugin(pluginInfo);
+    if (plugin.error) {
+      errors.push({ name: plugin.name, error: plugin.error });
+    } else {
+      try {
+        plugin.register(program, context);
+        loaded.push({ name: plugin.name, version: plugin.version, description: plugin.description });
+      } catch (err) {
+        errors.push({ name: plugin.name, error: err.message });
+      }
+    }
+  }
+
+  return { loaded, errors };
+}

package/lib/quoxon/activity.js

@@ -0,0 +1,116 @@
+/**
+ * What is actually happening right now, as one honest word (CLI-QUOX indicator).
+ * Pure: the reducer feeds every real event through nextActivity and keeps the result on the turn.
+ * Rules: a word exists only because an event said so; between events the last true word stays (never
+ * invented, never rotated); unknown tools fall back to "Working" plus the tool name as detail.
+ * Words are capitalised present participles; the indicator appends the ellipsis.
+ *
+ * State: { word, detail, tone: 'work' | 'wait', flash: ms | null, since: ms }
+ */
+
+const clipD = (s, n = 40) => { const t = String(s ?? '').replace(/\s+/g, ' ').trim(); return t.length > n ? t.slice(0, n - 1) + '…' : t; };
+
+// Ordered: first match wins, so specific families come before generic ones. [regex, word, detail?]
+// Tool names are the real registry names (memory_search, bastion_ssh, quoxplan_set_status, ...).
+const TOOL_TABLE = [
+  [/^(memory_(save|update)|brain_save|brain_garden_apply)/, 'Remembering'],
+  [/^memory_forget/, 'Forgetting'],
+  [/^(memory_|brain_|search_wisdom)/, 'Recalling'],
+  [/^(fleet_|bastion_).*(exec|ssh|run|restart|command)|^(bastion_ssh|fleet_exec)/, 'Running', 'host'],
+  [/^(fleet_|bastion_)/, 'Looking up'],
+  [/^(email_send|contacts_send)/, 'Sending'],
+  [/^contacts_dial/, 'Dialling'],
+  [/^(email_draft|inbox_propose|email_reply)/, 'Drafting'],
+  [/^(email_|inbox_)/, 'Checking mail'],
+  [/^(qlarity_|browser_(screenshot|lighthouse|pdf|find_element|list_tabs|monitor))/, 'Inspecting'],
+  [/^(browser_|http_|fetch_|web_)/, 'Fetching'],
+  [/^(seo_|quoxseo)/, 'Analysing'],
+  [/^(delegate|agent_handoff|agent_delegate|ask_agent|agent_call)|handoff/, 'Delegating', 'target'],
+  [/^(quoxflow_|workflow_)/, 'Orchestrating'],
+  [/^(quoxplan_|plan_)/, 'Planning'],
+  [/^(ward_|volt_|receipt|verify)/, 'Verifying'],
+  [/^approval/, 'Checking approvals'],
+  [/^calendar_/, 'Scheduling'],
+  [/^(search_|query_)|_search$|_find$/, 'Searching'],
+  [/(^|_)(write|edit|create)_(file|doc)|^file_(write|save)|^plan_doc/, 'Writing'],
+  [/(^|_)read(_|$)|^file_(read|get|open)/, 'Reading'],
+  [/(^|_)(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();
+  for (const [re, word, d] of TOOL_TABLE) {
+    if (re.test(name)) return { word, detail: d ? (clipD(ev[d] ?? ev.target ?? ev.host) || null) : null };
+  }
+  return { word: 'Working', detail: name || null };
+}
+
+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. */
+function traceWord(ev) {
+  const label = String(ev.label || '').toLowerCase();
+  if (ev.protocol === 'aee' && /envelope opened/.test(label)) return ['Recording', 'envelope'];
+  if (ev.protocol === 'aocl') {
+    if (/\bl1\b|identity/.test(label)) return ['Verifying', 'L1 identity'];
+    if (/\bl3\b|policy/.test(label)) return ['Governing', 'L3 policy'];
+    return null;
+  }
+  if (ev.protocol === 'ward' && /witness/.test(label)) return ['Witnessing', null];
+  return null;
+}
+
+/**
+ * Next activity for a stream event. ctx = { hasText } (has any answer text arrived yet).
+ * Returns prev unchanged for events that say nothing new.
+ */
+export function nextActivity(prev, ev, now = 0, ctx = {}) {
+  const p = prev || initialActivity(now);
+  switch (ev?.type) {
+    case 'thinking': {
+      const stage = String(ev.stage || ''), msg = String(ev.message || '').replace(/[.…\s]+$/u, '');
+      if (stage === 'routing') return mk('Routing', (msg.match(/\bto\s+(.+)$/i) || [])[1] || null, now);
+      if (stage === 'routing_detail') return mk('Routing', msg || p.detail, now);
+      if (stage === 'processing') return mk('Reading', null, now);
+      if (stage === 'api_call') {
+        if (ctx.hasText) return p;
+        return mk('Thinking', (msg.match(/Calling (.+?) API/i) || [])[1] || null, now);
+      }
+      if (stage.includes('tool') && msg) { const t = toolWord(msg); return mk(t.word, t.detail, now); }
+      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.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);
+    case 'steer.accepted': return mk('Adjusting', null, now);
+    case 'text.delta': case 'chunk': return p.word === 'Writing' && p.tone === 'work' ? p : mk('Writing', null, now);
+    case 'retry': case 'reconnecting': return mk('Reconnecting', null, now);
+    case 'resumed': return mk('Resuming', 'reattached', now);
+    case 'done': return mk('Confirming', 'waiting for the server', now);
+    case 'error': return { ...p, flash: now };
+    default: return p;
+  }
+}
+
+/** Client-side actions that are also true events (the human pressed Esc). */
+export function actionActivity(prev, action, now = 0) {
+  if (action?.type === 'turn.begin') return initialActivity(action.now ?? now);
+  if (action?.type === 'interrupt.requested') return mk('Stopping', null, action.now ?? now);
+  return prev;
+}

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