synabun 1.3.0 → 2.0.0

package/neural-interface/public/shared/cp/cp-agents.js

@@ -0,0 +1,186 @@
+// ── Nested subagent cards (Task / Agent tool) ──
+//
+// Every SDK message carries parent_tool_use_id; messages emitted by a subagent
+// reference the Task tool_use that spawned it. ensureAgentScope() returns a
+// prototype-inheriting "scope" object — Object.create(tab) with its OWN
+// messagesEl / currentMsgEl / currentMsgId / _stream — so the monolith's
+// existing renderers (renderAssistant, handleStreamDelta, updateToolResult,
+// buildTool) work unchanged inside the agent's nested feed. Tab-level reads
+// fall through the prototype chain; per-feed writes land on the scope.
+
+import { cpCtx } from './cp-ctx.js';
+
+const AGENT_ICON = '<svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="7" r="3"/><path d="M5 21v-1a5 5 0 0 1 5-5h4a5 5 0 0 1 5 5v1"/><path d="M19 3l1.5 1.5M22 2l-1.5 1.5"/></svg>';
+const MAX_FEED_CHILDREN = 80;
+
+function fmtElapsed(ms) {
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  return `${Math.floor(s / 60)}m ${s % 60}s`;
+}
+
+export function buildAgentCard(block, tab) {
+  const card = document.createElement('div');
+  card.className = 'tool-card cp-agent-card';
+  card.dataset.toolId = block.id || '';
+  card.dataset.toolName = block.name || 'Task';
+
+  const i = block.input || {};
+  const hdr = document.createElement('div');
+  hdr.className = 'tool-hdr cp-agent-hdr';
+  const icon = document.createElement('span'); icon.className = 'tool-icon cp-agent-icon';
+  icon.innerHTML = AGENT_ICON;
+  const type = document.createElement('span');
+  type.className = 'cp-agent-type';
+  type.textContent = i.subagent_type || 'agent';
+  const desc = document.createElement('span');
+  desc.className = 'tool-detail cp-agent-desc';
+  desc.textContent = i.description || (i.prompt || '').slice(0, 60);
+  const todoBadge = document.createElement('span');
+  todoBadge.className = 'cp-agent-todos-badge';
+  todoBadge.hidden = true;
+  const pill = document.createElement('span');
+  pill.className = 'cp-agent-pill cp-agent-running';
+  pill.textContent = '◐';
+  const elapsed = document.createElement('span');
+  elapsed.className = 'cp-agent-elapsed';
+  const chevron = document.createElement('span'); chevron.className = 'tool-chevron'; chevron.innerHTML = '&#x203A;';
+  hdr.append(icon, type, desc, todoBadge, pill, elapsed, chevron);
+  hdr.addEventListener('click', () => card.classList.toggle('open'));
+
+  // One-line live activity shown while collapsed
+  const now = document.createElement('div');
+  now.className = 'cp-agent-now';
+  now.textContent = 'starting…';
+
+  // Nested feed — becomes the scope's messagesEl
+  const feed = document.createElement('div');
+  feed.className = 'cp-agent-feed';
+
+  card.append(hdr, now, feed);
+
+  const startedAt = Date.now();
+  const timer = setInterval(() => {
+    if (!card.isConnected || card.dataset.resolved === '1') { clearInterval(timer); return; }
+    elapsed.textContent = fmtElapsed(Date.now() - startedAt);
+  }, 1000);
+
+  if (tab?.agents) {
+    tab.agents.set(block.id, {
+      cardEl: card,
+      feedEl: feed,
+      pillEl: pill,
+      nowEl: now,
+      todoBadgeEl: todoBadge,
+      startedAt,
+      status: 'running',
+      scope: null, // created lazily by ensureAgentScope
+    });
+  }
+  return card;
+}
+
+// Returns the render scope for a subagent, creating a fallback card when the
+// Task tool_use was missed (e.g. reconnect mid-fan-out).
+export function ensureAgentScope(tab, parentToolUseId) {
+  if (!tab.agents) tab.agents = new Map();
+  let entry = tab.agents.get(parentToolUseId);
+  if (!entry) {
+    // Fallback: synthesize a card at the end of the root feed
+    const card = buildAgentCard({ id: parentToolUseId, name: 'Task', input: { description: 'agent' } }, tab);
+    const { scrollEnd, activeTab } = cpCtx;
+    tab.messagesEl?.appendChild(card);
+    if (tab === activeTab()) { try { scrollEnd(); } catch {} }
+    entry = tab.agents.get(parentToolUseId);
+    if (!entry) return tab; // give up — render into root feed
+  }
+  if (!entry.scope) {
+    const scope = Object.create(tab);
+    scope.messagesEl = entry.feedEl;
+    scope.currentMsgEl = null;
+    scope.currentMsgId = null;
+    scope._stream = null;
+    scope.thinkingEl = null;
+    scope.thinkTimerInterval = null; // own — never clear the root tab's timer
+    scope.thinkStartedAt = null;
+    scope._snapshotTimer = null;     // own — snapshot debounce stays per-feed
+    scope.todos = [];
+    scope.todosVisible = false;
+    // Own usage copy: subagent token usage must not pollute the root gauge
+    scope.usage = { inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheWrite: 0 };
+    scope._agentScope = true;
+    scope._agentEntry = entry;
+    scope._agentToolUseId = parentToolUseId;
+    scope._rootTab = tab; // explicit root reference (prototype is implicit)
+    entry.scope = scope;
+  }
+  return entry.scope;
+}
+
+// Update the collapsed activity line when a tool runs inside the agent feed.
+export function noteAgentActivity(scope, text) {
+  const entry = scope?._agentEntry;
+  if (!entry?.nowEl || !text) return;
+  entry.nowEl.textContent = text;
+  pruneAgentFeed(entry);
+}
+
+function pruneAgentFeed(entry) {
+  const feed = entry.feedEl;
+  if (!feed) return;
+  while (feed.children.length > MAX_FEED_CHILDREN) feed.removeChild(feed.firstChild);
+}
+
+// Subagent todo badge ("2/5") — agent-scope TodoWrite never touches the dock.
+export function updateAgentTodoBadge(scope, todos) {
+  const entry = scope?._agentEntry;
+  if (!entry?.todoBadgeEl || !Array.isArray(todos)) return;
+  const done = todos.filter(t => t.status === 'completed').length;
+  entry.todoBadgeEl.textContent = `${done}/${todos.length}`;
+  entry.todoBadgeEl.hidden = todos.length === 0;
+}
+
+// The agent went to the background: its Task tool_result is only a launch
+// placeholder, and the agent keeps working until a `subagent stop` arrives from
+// its task notification (or from the CLI process ending).
+export function markAgentBackground(tab, toolUseId) {
+  const entry = tab.agents?.get(toolUseId);
+  if (!entry) return false;
+  entry.background = true;
+  entry.status = 'running';
+  delete entry.cardEl.dataset.resolved;
+  entry.pillEl.classList.remove('cp-agent-done', 'cp-agent-error');
+  entry.pillEl.classList.add('cp-agent-running');
+  entry.pillEl.textContent = '◐';
+  entry.nowEl.textContent = 'running in background';
+  return true;
+}
+
+// Called from updateToolResult when the Task tool's own result arrives in the
+// ROOT feed, and from the synthetic `subagent stop` event (force: authoritative).
+// A background agent's tool_result is a placeholder, so only a forced call —
+// its real end — finalizes it.
+export function finalizeAgentCard(tab, toolUseId, { isError = false, resultText = '', status = '', force = false } = {}) {
+  const entry = tab.agents?.get(toolUseId);
+  if (!entry) return false;
+  if (entry.background && !force) return true;
+  // The synthetic `subagent stop` event finalizes the pill first; the Task
+  // tool_result (carrying the summary text) arrives right after — always
+  // append the summary even when the card is already finalized.
+  if (resultText && !entry.feedEl.querySelector('.cp-agent-result')) {
+    const summary = document.createElement('div');
+    summary.className = 'cp-agent-result';
+    summary.textContent = resultText.slice(0, 300) + (resultText.length > 300 ? '…' : '');
+    entry.feedEl.appendChild(summary);
+    pruneAgentFeed(entry);
+  }
+  if (entry.status !== 'running') return true;
+  entry.background = false;
+  entry.status = isError ? 'error' : 'done';
+  entry.cardEl.dataset.resolved = '1';
+  entry.pillEl.classList.remove('cp-agent-running');
+  entry.pillEl.classList.add(isError ? 'cp-agent-error' : 'cp-agent-done');
+  entry.pillEl.textContent = isError ? '✕' : '✓';
+  entry.nowEl.textContent = status === 'stopped' ? 'stopped' : (isError ? 'failed' : 'done');
+  return true;
+}

package/neural-interface/public/shared/cp/cp-bash.js

@@ -0,0 +1,252 @@
+// ── Bash cards: streaming-style output, exit pill, background task tray ──
+
+import { cpCtx } from './cp-ctx.js';
+import { backgroundTaskIdOf } from './cp-tool-results.js';
+
+const ANSI_RE = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07]*(?:\x07|\x1b\\)/g;
+export function stripAnsi(text) { return String(text ?? '').replace(ANSI_RE, ''); }
+
+const MAX_OUT_CHARS = 20000;
+
+function fmtElapsed(ms) {
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  return `${Math.floor(s / 60)}m ${s % 60}s`;
+}
+
+export function buildBashCard(block, tab) {
+  const { toolIconSvg } = cpCtx;
+  const i = block.input || {};
+  const isBg = i.run_in_background === true;
+
+  const card = document.createElement('div');
+  card.className = 'tool-card cp-bash-card';
+  card.dataset.toolId = block.id || '';
+  card.dataset.toolName = 'Bash';
+
+  const hdr = document.createElement('div');
+  hdr.className = 'tool-hdr';
+  const icon = document.createElement('span'); icon.className = 'tool-icon';
+  icon.innerHTML = toolIconSvg('Bash');
+  const name = document.createElement('span'); name.className = 'tool-name'; name.textContent = 'Bash';
+  const detail = document.createElement('span'); detail.className = 'tool-detail';
+  detail.textContent = (i.command || '').slice(0, 60);
+  hdr.append(icon, name, detail);
+  if (isBg) {
+    const bg = document.createElement('span');
+    bg.className = 'cp-bg-badge';
+    bg.textContent = 'bg';
+    hdr.appendChild(bg);
+  }
+  const exitPill = document.createElement('span');
+  exitPill.className = 'cp-exit-pill';
+  exitPill.hidden = true;
+  hdr.appendChild(exitPill);
+  const elapsed = document.createElement('span');
+  elapsed.className = 'cp-bash-elapsed';
+  hdr.appendChild(elapsed);
+  const chevron = document.createElement('span'); chevron.className = 'tool-chevron'; chevron.innerHTML = '&#x203A;';
+  hdr.appendChild(chevron);
+  hdr.addEventListener('click', () => card.classList.toggle('open'));
+
+  const body = document.createElement('div');
+  body.className = 'tool-body';
+  const cmd = document.createElement('pre');
+  cmd.className = 'cp-bash-cmd';
+  cmd.textContent = i.command || '';
+  body.appendChild(cmd);
+  if (i.description) {
+    const desc = document.createElement('div');
+    desc.className = 'cp-bash-desc';
+    desc.textContent = i.description;
+    body.appendChild(desc);
+  }
+  const out = document.createElement('pre');
+  out.className = 'cp-bash-out';
+  out.hidden = true;
+  body.appendChild(out);
+  // Hidden generic RESULT section kept for compatibility with updateToolResult fallback paths
+  const rLbl = document.createElement('div'); rLbl.className = 'tool-section-label tool-result-label'; rLbl.textContent = 'RESULT'; rLbl.hidden = true;
+  const rSec = document.createElement('div'); rSec.className = 'tool-section tool-result-content'; rSec.hidden = true;
+  body.append(rLbl, rSec);
+  card.append(hdr, body);
+
+  // Elapsed ticker while unresolved
+  const startedAt = Date.now();
+  const timer = setInterval(() => {
+    if (!card.isConnected || card.dataset.resolved === '1') { clearInterval(timer); elapsed.textContent = card.dataset.resolved === '1' ? elapsed.textContent : ''; return; }
+    elapsed.textContent = fmtElapsed(Date.now() - startedAt);
+  }, 1000);
+
+  // Background task registration (bgTasks is inherited by agent scopes — root map).
+  // A launch replayed from the transcript is history: it is not registered as
+  // running (nothing would ever end it). What is still alive comes from the
+  // session's own task list (reattach / background_tasks_changed → tab.tasks).
+  if (isBg && tab?.bgTasks && !tab._replaying) {
+    tab.bgTasks.set(block.id, {
+      toolUseId: block.id,
+      label: (i.command || '').slice(0, 40),
+      status: 'running',
+      bashId: null,
+      cardEl: card,
+      startedAt,
+      dismissed: false,           // user-dismissed from the bg-tray chip (hides the pill, keeps the entry so the card still receives its exit pill on completion)
+    });
+    renderBgTray(tab?._rootTab || tab);
+  }
+  return card;
+}
+
+function extractResultText(ev) {
+  let text = '';
+  if (Array.isArray(ev.content)) {
+    text = ev.content.map(b => (b?.type === 'text' ? (b.text || '') : '')).filter(Boolean).join('\n');
+  } else if (typeof ev.content === 'string') {
+    text = ev.content;
+  }
+  return stripAnsi(text);
+}
+
+// `view` is the typed result (cp-tool-results.js describeToolResult) when the
+// SDK delivered one: stdout apart from stderr, interrupted, the background id.
+export function updateBashResult(card, ev, tab, view = null) {
+  card.dataset.resolved = '1';
+  const out = card.querySelector('.cp-bash-out');
+  const exitPill = card.querySelector('.cp-exit-pill');
+  const merged = extractResultText(ev);
+  // stderr has its own section when the typed result split the streams.
+  const text = typeof view?.stdout === 'string' ? stripAnsi(view.stdout) : merged;
+  if (out && text) {
+    out.hidden = false;
+    out.textContent = text.length > MAX_OUT_CHARS ? text.slice(0, MAX_OUT_CHARS) + '\n…(truncated)' : text;
+    out.scrollTop = out.scrollHeight;
+  }
+  if (exitPill) {
+    const m = /exit code:?\s+(\d+)/i.exec(merged);
+    const code = m ? Number(m[1]) : (ev.is_error ? 1 : 0);
+    exitPill.textContent = String(code);
+    exitPill.classList.add(code === 0 ? 'cp-exit-ok' : 'cp-exit-err');
+    exitPill.hidden = false;
+  }
+  card.classList.add(ev.is_error ? 'tool-error' : 'tool-ok');
+
+  // Background tasks: the task id the CLI gave this command (the typed result's
+  // backgroundTaskId, or "…running in background with ID: b46v84ew2"), so a
+  // later TaskStop and the live task list can be tied back to this card. A
+  // command the user or the CLI moved to the background after it started has
+  // no entry yet. A result replayed from the transcript registers nothing, like
+  // its call (buildBashCard): that launch is history, nothing would ever end
+  // the entry, and what still runs comes from the session's live task list.
+  const bgId = backgroundTaskIdOf(view?.bgTaskId ? { backgroundTaskId: view.bgTaskId } : ev.tool_use_result, merged);
+  let task = tab?.bgTasks?.get(ev.tool_use_id);
+  if (!task && bgId && view?.bgTaskId && tab?.bgTasks && !tab._replaying) {
+    task = {
+      toolUseId: ev.tool_use_id,
+      label: (card.querySelector('.cp-bash-cmd')?.textContent || 'background command').slice(0, 40),
+      status: 'running', bashId: null, cardEl: card, startedAt: Date.now(), dismissed: false,
+    };
+    tab.bgTasks.set(ev.tool_use_id, task);
+  }
+  if (task) {
+    if (bgId) task.bashId = bgId;
+    // A bg Bash tool_result just acknowledges the launch — keep status running.
+    renderBgTray(tab?._rootTab || tab);
+  }
+}
+
+// background_tasks_changed carries every live task: a background command whose
+// id is no longer in it has ended.
+export function reconcileBgTasks(tab, liveTasks) {
+  if (!tab?.bgTasks?.size) return false;
+  const live = new Set((Array.isArray(liveTasks) ? liveTasks : []).map(t => t?.task_id).filter(Boolean));
+  let changed = false;
+  for (const task of tab.bgTasks.values()) {
+    if (!task.bashId || task.status !== 'running') continue;
+    if (live.has(task.bashId)) { task.seenLive = true; continue; }
+    // Only a task the list once carried can be told finished by its absence.
+    if (!task.seenLive) continue;
+    task.status = 'done';
+    changed = true;
+  }
+  if (changed) renderBgTray(tab);
+  return changed;
+}
+
+// BashOutput / KillShell / TaskStop awareness: route output to the origin card.
+export function handleBgToolUse(block, tab) {
+  if (!tab?.bgTasks?.size) return;
+  const shellId = block.input?.bash_id || block.input?.shell_id || block.input?.task_id || null;
+  if (!shellId) return;
+  for (const task of tab.bgTasks.values()) {
+    if (task.bashId && (task.bashId === shellId)) {
+      task._awaitingOutputToolId = block.id;
+      if (block.name === 'KillShell' || block.name === 'TaskStop') {
+        task.status = 'stopped';
+        renderBgTray(tab);
+      }
+      return;
+    }
+  }
+}
+
+export function handleBgToolResult(ev, tab) {
+  if (!tab?.bgTasks?.size) return false;
+  for (const task of tab.bgTasks.values()) {
+    if (task._awaitingOutputToolId === ev.tool_use_id) {
+      task._awaitingOutputToolId = null;
+      const text = extractResultText(ev);
+      const out = task.cardEl?.querySelector('.cp-bash-out');
+      if (out && text.trim()) {
+        out.hidden = false;
+        out.textContent = ((out.textContent || '') + '\n' + text).trim().slice(-MAX_OUT_CHARS);
+        out.scrollTop = out.scrollHeight;
+      }
+      if (/\b(completed|exited|killed|failed)\b/i.test(text)) {
+        task.status = /killed|failed/i.test(text) ? 'stopped' : 'done';
+      }
+      renderBgTray(tab?._rootTab || tab);
+      return true;
+    }
+  }
+  return false;
+}
+
+export function renderBgTray(tab) {
+  const { panel, activeTab, scrollEnd } = cpCtx;
+  const $panel = panel();
+  if (!$panel || tab !== activeTab()) return;
+  let tray = $panel.querySelector('#cp-bg-tray');
+  if (!tray) {
+    const bottom = $panel.querySelector('.cp-bottom');
+    if (!bottom) return;
+    tray = document.createElement('div');
+    tray.id = 'cp-bg-tray';
+    tray.className = 'cp-bg-tray';
+    bottom.insertBefore(tray, bottom.firstChild);
+  }
+  const tasks = [...(tab.bgTasks?.values() || [])].filter(t => !t.dismissed);
+  if (!tasks.length) { tray.hidden = true; tray.innerHTML = ''; return; }
+  tray.hidden = false;
+  tray.innerHTML = '';
+  for (const task of tasks) {
+    const chip = document.createElement('button');
+    chip.className = `cp-bg-chip cp-bg-${task.status}`;
+    chip.innerHTML = `<span class="cp-bg-dot"></span><span class="cp-bg-label"></span><span class="cp-bg-close" role="button" aria-label="Dismiss background task" title="Dismiss">&times;</span>`;
+    chip.querySelector('.cp-bg-label').textContent = task.label;
+    chip.title = `${task.label} — ${task.status}`;
+    chip.addEventListener('click', (e) => {
+      // Skip when the close glyph was hit — its own handler dismisses the chip.
+      if (e.target.closest('.cp-bg-close')) return;
+      if (task.cardEl?.isConnected) {
+        task.cardEl.classList.add('open');
+        task.cardEl.scrollIntoView({ behavior: 'smooth', block: 'center' });
+      }
+    });
+    chip.querySelector('.cp-bg-close').addEventListener('click', (e) => {
+      e.stopPropagation();
+      task.dismissed = true;
+      renderBgTray(tab);
+    });
+    tray.appendChild(chip);
+  }
+}

package/neural-interface/public/shared/cp/cp-compose.js

@@ -0,0 +1,159 @@
+// ── The composer while a Compact is under way (DOM-free) ──
+// A turn the user sent shows as running: a prompt sent meanwhile waits in the
+// queue, and Compact is refused. A Compact the user started is a turn too, but
+// one the tab does not show as running: until it ends, a second Compact does
+// nothing and a prompt waits in the same queue, instead of both reaching a
+// session that is still switching to the compacted conversation.
+// The tab notes when it sent a Compact (`_compactSentAt`); the note is dropped
+// when the turn ends (done, stopped, error), when the socket closes and when the
+// tab starts another conversation. Should none of those ever come, the hold
+// lapses once the session has been silent for as long as the panel waits on a
+// running turn that says nothing.
+// A hold that ends with its turn's `done` or `aborted` has the queue advanced by
+// that message. Every other end goes through compactQueue() below, so a prompt
+// queued behind a Compact is either sent or stopped where the user sees it.
+
+export const COMPACT_HOLD_MS = 10 * 60 * 1000;
+// How long a turn end waits for the `done` that advances the queue before the queue is moved without it.
+export const COMPACT_SETTLE_MS = 3000;
+
+/** True while a Compact the user started holds the composer of a tab that is not running a turn. */
+export function compactHolds(tab, now = Date.now()) {
+  if (!tab || tab.running) return false;
+  const sentAt = Number(tab._compactSentAt) || 0;
+  if (!sentAt) return false;
+  const heardAt = Math.max(sentAt, Number(tab._lastWsActivity) || 0);
+  return now - heardAt < COMPACT_HOLD_MS;
+}
+
+/** Milliseconds until a hold nothing ends lapses; 0 when nothing is held. */
+export function compactHoldLeft(tab, now = Date.now()) {
+  if (!compactHolds(tab, now)) return 0;
+  const heardAt = Math.max(Number(tab._compactSentAt) || 0, Number(tab._lastWsActivity) || 0);
+  return heardAt + COMPACT_HOLD_MS - now;
+}
+
+/** `/compact`, with or without arguments: what the slash router runs as Compact. */
+export function isCompactCommand(text) {
+  return /^\/compact(\s|$)/i.test(String(text || '').trim());
+}
+
+// ── Whose a queued prompt is ──
+// A tab holds one conversation at a time, and the page can move it to another
+// (New chat, a session picked from the menu). `tab.conversation` names the one
+// it holds: a new value each time the page moves the tab, the same value while
+// the session only changes its id (its first start, a resume, a reattach, a
+// reset). A queued prompt keeps the value it was typed under and is sent only
+// while the tab still has that value: after a move it stays in the tray, marked
+// as not sent.
+
+export function newConversation() {
+  return globalThis.crypto.randomUUID();
+}
+
+/** True when the prompt was typed for the conversation the tab holds now. */
+export function ownsQueued(tab, item) {
+  return !!tab && !!item && item.conversation === tab.conversation;
+}
+
+/** Index of the prompt the queue sends next: the first one typed for this conversation. -1: none. */
+export function nextQueued(tab) {
+  return (tab?.queue || []).findIndex((item) => ownsQueued(tab, item));
+}
+
+/** A queue read from storage: a prompt saved before prompts carried a conversation is the tab's own. */
+export function restoredQueue(tab, queue) {
+  return (Array.isArray(queue) ? queue : []).filter(Boolean).map((item) => (item.conversation ? item : { ...item, conversation: tab.conversation }));
+}
+
+/** Why a prompt taken off the queue is not sent after all: '' (send it), 'conversation' or 'closed'. */
+export function queuedRefusal(tab, item, { connected }) {
+  if (!ownsQueued(tab, item)) return 'conversation';
+  if (!connected) return 'closed';
+  return '';
+}
+
+export const QUEUED_REFUSAL_LINES = {
+  conversation: 'A queued prompt was typed for another conversation and was not sent here. It stays in the queue, marked.',
+  closed: 'Not connected: the queued prompt was not sent. Resume the queue when the session is back.',
+};
+
+// ── The queue when a Compact ends without the `done` that advances it ──
+
+/**
+ * What happens to the prompts queued behind a Compact.
+ * `how`: 'lapsed' (the session stayed silent), 'ended' (its turn ended and no
+ * `done` followed), 'failed' (it ended with an error), 'closed' (the socket
+ * closed under it), 'reattached' (the reconnect found the session), 'lost' (it
+ * did not).
+ * Returns `action`: 'send' (the next prompt goes out), 'reconnect' (they wait
+ * for the reconnect's answer), 'stop' (the queue is paused; Resume sends them)
+ * or 'none' (nothing of this conversation waits, the user paused the queue, or
+ * a running turn's end advances it), and `line`: what the transcript says.
+ */
+export function queueAfterCompact(tab, { how, connected }) {
+  const n = (tab?.queue || []).filter((item) => ownsQueued(tab, item)).length;
+  if (!n || tab.queuePaused) return { action: 'none', line: '' };
+  const prompts = n === 1 ? '1 queued prompt' : `${n} queued prompts`;
+  const kept = `${prompts} ${n === 1 ? 'was' : 'were'} not sent: resume the queue to send ${n === 1 ? 'it' : 'them'}.`;
+  if (how === 'failed') return { action: 'stop', line: `The Compact ended with an error. ${kept}` };
+  if (how === 'lost') return { action: 'stop', line: `The session did not come back after the disconnect, so the Compact may not have finished. ${kept}` };
+  if (how === 'closed' || !connected) return { action: 'reconnect', line: `Connection lost during the Compact. ${prompts} will be sent when the session is back.` };
+  if (tab.running) return { action: 'none', line: '' };
+  const going = `Sending the queued prompt${n === 1 ? '' : 's'}.`;
+  if (how === 'lapsed') return { action: 'send', line: `The Compact did not report back. ${going}` };
+  if (how === 'reattached') return { action: 'send', line: `Reconnected. ${going}` };
+  return { action: 'send', line: '' };
+}
+
+/**
+ * The same, carried out. `io` is the panel's side: `connected(tab)`,
+ * `advance(tab)` (advanceQueue), `stop(tab)` (pause the queue and show it),
+ * `say(tab, line)` (a status line) and `unlabel(tab)` (the "compacting" label off).
+ * `tab._queueWaits` is 'compact' while prompts wait behind a hold, 'session'
+ * while they wait for a reconnect to say whether the session is still there.
+ */
+export function compactQueue(io) {
+  const after = (tab, how) => {
+    clearTimeout(tab._compactTimer);
+    tab._compactTimer = null;
+    const { action, line } = queueAfterCompact(tab, { how, connected: !!io.connected(tab) });
+    tab._queueWaits = action === 'reconnect' ? 'session' : '';
+    if (line) io.say(tab, line);
+    if (action === 'stop') io.stop(tab);
+    else if (action === 'send') io.advance(tab);
+  };
+  // Prompts wait behind a hold: should the session stay silent until it lapses, the queue is moved then.
+  const watch = (tab) => {
+    if (!tab.queue?.length || !compactHolds(tab)) return;
+    tab._queueWaits = 'compact';
+    if (tab._compactTimer) return;
+    tab._compactTimer = setTimeout(() => {
+      tab._compactTimer = null;
+      if (tab.closed || tab._queueWaits !== 'compact') return;
+      if (compactHolds(tab)) { watch(tab); return; } // the session spoke meanwhile: still held
+      if (tab.running) return; // a turn started by itself: its end comes through ended()
+      tab._compactSentAt = 0;
+      io.unlabel(tab);
+      after(tab, 'lapsed');
+    }, compactHoldLeft(tab));
+  };
+  // A turn ended (finishTab). Its `done` or `aborted` advances the queue and an
+  // `error` stops it; should none of them follow, the queue is moved from here.
+  const ended = (tab) => {
+    if (tab._queueWaits !== 'compact') return;
+    clearTimeout(tab._compactTimer);
+    tab._compactTimer = setTimeout(() => {
+      tab._compactTimer = null;
+      if (tab.closed || tab._queueWaits !== 'compact') return;
+      after(tab, 'ended');
+    }, COMPACT_SETTLE_MS);
+  };
+  // The tab moved to another conversation: nothing of the old one is waited on.
+  const drop = (tab) => {
+    clearTimeout(tab._compactTimer);
+    tab._compactTimer = null;
+    tab._queueWaits = '';
+  };
+  return { after, watch, ended, drop };
+}