@milpa/comal 0.2.2 → 0.2.4

package/src/tui/screen.mjs

@@ -1,4 +1,5 @@
 import { t, formatNumber } from '../i18n/index.mjs';
+import { compactionNotice } from '../compaction-notice.mjs';
 import { VERSION } from '../version.mjs';
 import { workProjection } from '../work-plan.mjs';
 import { Composer } from './composer.mjs';
@@ -8,20 +9,22 @@ import { copyText } from './clipboard.mjs';
 import { tone, createTones, safeText, wrap, width, clip, pad, progressBar, stripANSI, terminalSurface } from './text.mjs';
 import { brandingWelcome, brandingStatus, brandMotionEnabled, BRAND_FRAME_INTERVAL_MS, BRAND_WELCOME_FRAMES } from './brand.mjs';
 import { commandCatalog, commandSuggestions, applySuggestion, contextualTip } from './discovery.mjs';
-import { inboundBlockFromRow, inboundBlockFromEvent, inboundLines } from './inbound-blocks.mjs';
+import { inboundBlockFromRow, inboundBlockFromEvent, inboundLines, queuedNoticeBlock } from './inbound-blocks.mjs';
+import { noticeMailbox } from '../plugin-notices.mjs';
 import { presentResultBlock, presentToolBlock, presentPermission } from './present.mjs';
 import { normalizeSwarmView, swarmPanelLines, swarmStripLines, swarmActions } from './swarm-panel.mjs';
+import { formatTurnTiming, measureHumanWait } from '../turn-timing.mjs';
 
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const MOUSE_ON = '\x1b[?1000h\x1b[?1006h';
 const MOUSE_OFF = '\x1b[?1000l\x1b[?1006l';
-const HELP = "# Comal · keyboard\n\n| Action | Key |\n| --- | --- |\n| Discover commands and tools | F6 |\n| Complete command or argument | / and Tab; ↑/↓ chooses; Esc closes |\n| Send / enqueue | Enter (suggestions only complete) |\n| New line | Alt+Enter or Ctrl+J |\n| Switch mode | Shift+Tab |\n| Edit with $VISUAL/$EDITOR | Ctrl+G |\n| Work board | F3 or /board |\n| Swarm panel (open-relay) | /swarm · /swarm strip |\n| Continue from checkpoint | /work resume |\n| Sessions / resume | F2 or Ctrl+S |\n| Message queue | F4 or Ctrl+Q |\n| Expand tool results | Ctrl+O |\n| Scroll history | Mouse wheel / PgUp / PgDn |\n| Select text with mouse | F5 or /select; F5 or Esc returns |\n| Copy last full response | Alt+C or /copy |\n| Go to end | Ctrl+End |\n| Composer history | ↑/↓ on first/last line |\n| Start / end of line | Home / End or Ctrl+A / Ctrl+E |\n| Delete word / start / end | Ctrl+W / Ctrl+U / Ctrl+K |\n| Cancel turn / pause goal | Ctrl+C or Esc while working |\n| Exit | Ctrl+D with empty composer or /exit |\n\nYou can keep typing during streaming. Sent messages run in order when the current turn ends. F4 lets you pause, edit, remove, and reorder the queue.\n\n/context shows the context budget. /compact derives state without LLM and waits its turn if there is active work. /state shows request and state; /audit verifies the ledger. The original history is preserved.\n/house shows execution receipts and interrupted operations; /operations shows contracts and declared effects. Execution success does not certify the human goal.\n/plugins shows plugins, dependencies, and operations; enable/disable/reload wait their turn and only the user can change their lifecycle.\n/model ID and /effort LEVEL change the next call; during work they stay queued. /models lists models and /capabilities shows support, provenance, and levels. E indicates effort; Ctx shows the effective window (k/M tokens); ~ indicates a configured limit, ? unknown/fallback capability. /context shows exact values, reserve, and source. /login PROVIDER authenticates; /logout PROVIDER removes credentials from Comal.\n\n**Help keeps the composer active.** You can type while viewing it; PgUp/PgDn scrolls it and Esc/F1 closes it. Sending returns to the conversation. The wheel scrolls the conversation; the arrows edit the draft. F5 releases the mouse and freezes the view: drag to select and use your terminal's copy action (usually Ctrl+Shift+C). Work continues and the view updates when you return. /copy preserves Markdown and code blocks, without the screen line wrapping. Multi-line paste is not sent automatically.";
+const HELP = "# Comal · keyboard\n\n| Action | Key |\n| --- | --- |\n| Discover commands and tools | F6 |\n| Complete command or argument | / and Tab; ↑/↓ chooses; Esc closes |\n| Send / enqueue | Enter (suggestions only complete) |\n| New line | Alt+Enter or Ctrl+J |\n| Switch mode | Shift+Tab |\n| Edit with $VISUAL/$EDITOR | Ctrl+G |\n| Work board | F3 or /board |\n| Swarm of this repo (open-relay) | /relay |\n| Swarm panel (open-relay) | /swarm · /swarm strip |\n| Continue from checkpoint | /work resume |\n| Sessions / resume | F2 or Ctrl+S |\n| Message queue | F4 or Ctrl+Q |\n| Expand tool results | Ctrl+O |\n| Scroll history | Mouse wheel / PgUp / PgDn |\n| Select text with mouse | F5 or /select; F5 or Esc returns |\n| Copy last full response | Alt+C or /copy |\n| Go to end | Ctrl+End |\n| Composer history | ↑/↓ on first/last line |\n| Start / end of line | Home / End or Ctrl+A / Ctrl+E |\n| Delete word / start / end | Ctrl+W / Ctrl+U / Ctrl+K |\n| Cancel turn / pause goal | Ctrl+C or Esc while working |\n| Exit | Ctrl+D with empty composer or /exit |\n\nYou can keep typing during streaming. Sent messages run in order when the current turn ends. F4 lets you pause, edit, remove, and reorder the queue.\n\n/context shows the context budget. /compact derives state without LLM and waits its turn if there is active work. /state shows request and state; /audit verifies the ledger. The original history is preserved.\n/house shows execution receipts and interrupted operations; /operations shows contracts and declared effects. Execution success does not certify the human goal.\n/plugins shows plugins, dependencies, and operations; enable/disable/reload wait their turn and only the user can change their lifecycle.\n/model ID and /effort LEVEL change the next call; during work they stay queued. /models lists models and /capabilities shows support, provenance, and levels. E indicates effort; Ctx shows the effective window (k/M tokens); ~ indicates a configured limit, ? unknown/fallback capability. /context shows exact values, reserve, and source. /login PROVIDER authenticates; /logout PROVIDER removes credentials from Comal.\n\n**Help keeps the composer active.** You can type while viewing it; PgUp/PgDn scrolls it and Esc/F1 closes it. Sending returns to the conversation. The wheel scrolls the conversation; the arrows edit the draft. F5 releases the mouse and freezes the view: drag to select and use your terminal's copy action (usually Ctrl+Shift+C). Work continues and the view updates when you return. /copy preserves Markdown and code blocks, without the screen line wrapping. Multi-line paste is not sent automatically.";
 
 export class TerminalScreen {
   constructor({ input = process.stdin, output = process.stdout, metadata = {}, clipboard = copyText, env = process.env } = {}) {
     Object.assign(this, { input, output, metadata, env }); this.composer = new Composer(); this.markdown = new MarkdownRenderer(); this.tables = new DataTableParser();
     this.clipboard = clipboard; this.selecting = false;
-    this.blocks = []; this.toolBlocks = new Map(); this.subagentBlocks = new Map(); this.countedChildResults=new Set(); this.queue = { items: [], paused: false, interrupted: [] }; this.busy = false; this.ready = false;
+    this.blocks = []; this.toolBlocks = new Map(); this.subagentBlocks = new Map(); this.noticeBlocks = new Map(); this.countedChildResults=new Set(); this.queue = { items: [], paused: false, interrupted: [] }; this.busy = false; this.ready = false; this.showTiming = true;
     this.mode = metadata.mode || 'default'; this.phase = t("Connecting to the model"); this.frame = 0; this.scroll = 0; this.lastContentLength = 0; this.expandedTools = false;
     this.discovery = {}; this.completionIndex = 0; this.brandStarted = Date.now();
     this.callbacks = {}; this.closed = false; this.suspended = false; this.previous = []; this.goal = null; this.usage = 0; this.turn = 0; this.maxTurns = 12;
@@ -62,9 +65,12 @@ export class TerminalScreen {
     this.setup = state; this.schedule(); return state;
   }
   clearSetup() { this.setup?.finish(null); }
-  setupChoice({ title, description = '', items, signal, searchable = false, selected } = {}) {
+  // keys: atajos de una letra → id de opción (p. ej. {e:'edit', r:'reject'}), sólo sin filtro.
+  // hint: línea de ayuda propia. Una descripción larga (tarjetas de /relay) se desplaza con PgUp/PgDn.
+  setupChoice({ title, description = '', items, signal, searchable = false, selected, keys, hint } = {}) {
     if (!Array.isArray(items) || !items.length || items.length > 1024 || items.some(item => typeof item?.id !== 'string' || !item.id || typeof item.label !== 'string') || new Set(items.map(item => item.id)).size !== items.length) throw new Error(t('Choose between 1 and 1024 distinct options.'));
-    return new Promise(resolve => this.beginSetup({ kind: 'choice', title: safeText(title || t('Choose a connection')), description: safeText(description), items: items.map(item => ({ id: item.id, label: safeText(item.label), description: safeText(item.description || ''), badge: safeText(item.badge || '') })), index: Math.max(0,items.findIndex(item=>item.id===selected)), searchable, query: '' }, signal, resolve));
+    const shortcuts = !searchable && keys && typeof keys === 'object' ? Object.fromEntries(Object.entries(keys).filter(([key, id]) => /^[a-z]$/.test(key) && items.some(item => item.id === id))) : null;
+    return new Promise(resolve => this.beginSetup({ kind: 'choice', title: safeText(title || t('Choose a connection')), description: safeText(description), items: items.map(item => ({ id: item.id, label: safeText(item.label), description: safeText(item.description || ''), badge: safeText(item.badge || '') })), index: Math.max(0,items.findIndex(item=>item.id===selected)), searchable, query: '', keys: shortcuts, hint: hint ? safeText(hint) : null, scroll: 0 }, signal, resolve));
   }
   setupItems() {
     const state=this.setup;
@@ -99,6 +105,8 @@ export class TerminalScreen {
     if (state.kind === 'status' || state.validating) return;
     if (state.kind === 'choice') {
       const items=this.setupItems();
+      if (state.keys && !key.ctrl && !key.meta && text && state.keys[text]) { state.finish(state.keys[text]); return; }
+      if (name === 'pageup' || name === 'pagedown') { state.scroll = Math.max(0, (state.scroll || 0) + (name === 'pageup' ? -5 : 5)); this.schedule(); return; }
       if (name === 'up') state.index = Math.max(0, state.index - 1);
       else if (name === 'down') state.index = Math.max(0,Math.min(items.length - 1, state.index + 1));
       else if (name === 'home') state.index = 0;
@@ -133,7 +141,16 @@ export class TerminalScreen {
     const counter=state.kind==='choice'?t('{index} of {count}',{index:items.length?state.index+1:0,count:items.length}):'';
     const title=wrap(state.title,room).map(value=>line(colors.bold(colors.text(value))));
     if(room>=40 && title.length===1 && counter)title[0]=line(pad(colors.bold(colors.text(state.title)),room-width(counter)-1)+' '+colors.muted(counter));
-    const description=state.description?wrap(state.description,room).map(value=>line(colors.muted(value))):[];
+    let description=state.description?wrap(state.description,room).map(value=>line(colors.muted(value))):[];
+    // Descripción larga (tarjetas): deja sitio a las opciones y se desplaza con PgUp/PgDn.
+    if(state.kind==='choice' && description.length){
+      const choices=Math.min(12,(state.items?.length || 1)*2+1),room2=Math.max(3,rows-header.length-title.length-choices-6);
+      if(description.length>room2){
+        const max=description.length-(room2-1);state.scroll=Math.min(state.scroll || 0,max);
+        const from=state.scroll,shown=description.slice(from,from+room2-1);
+        description=[...shown,line(colors.secondary(t('PgUp/PgDn scrolls · lines {from}–{to} of {count}',{from:from+1,to:from+shown.length,count:description.length})))];
+      }
+    }
     let prefix=[...header,'',...title,...(description.length?['',...description]:[]),''];
     if(state.searchable)prefix.push(line(colors.muted(t('Filter')+': ')+colors.text(state.query || t('Type to search…'))),'');
     // Artwork yields to the actual decision on short terminals and auth screens.
@@ -144,7 +161,7 @@ export class TerminalScreen {
     }
     const budget=Math.max(1,rows-Math.min(prefix.length,rows-4)-2);
     const cancellation=this.ready?t('Ctrl+C cancels'):t('Ctrl+C exits');
-    const hint=(state.kind==='choice'?(state.searchable?t('Type to filter · ↑/↓ choose · Enter selects · Esc returns'):t('↑/↓ choose · Enter continues · Esc back')):state.kind==='input'?t('Enter continues · Esc back'):t('Esc back'))+' · '+cancellation;
+    const hint=state.hint?state.hint+' · '+cancellation:(state.kind==='choice'?(state.searchable?t('Type to filter · ↑/↓ choose · Enter selects · Esc returns'):t('↑/↓ choose · Enter continues · Esc back')):state.kind==='input'?t('Enter continues · Esc back'):t('Esc back'))+' · '+cancellation;
     let body=[],cursor=null;
     if(state.kind==='choice'){
       const cards=items.map((item,index)=>{
@@ -242,8 +259,10 @@ export class TerminalScreen {
   toggleRaw() { this.rawView = !this.rawView; this.notice(this.rawView ? t('Raw view on: results and permissions show the exact JSON. /raw returns to the readable view.') : t('Readable view on. /raw shows the exact JSON again.')); }
   loadSession(session) {
     this.cacheReadTokens=null;
-    this.preparedDraft = null; this.dismissedCompletion = null; this.blocks = []; this.toolBlocks.clear(); this.subagentBlocks.clear(); this.streaming = null; this.scroll = 0; this.lastContentLength = 0; this.goal = session.goal;
+    this.preparedDraft = null; this.dismissedCompletion = null; this.blocks = []; this.toolBlocks.clear(); this.subagentBlocks.clear(); this.noticeBlocks.clear(); this.streaming = null; this.scroll = 0; this.lastContentLength = 0; this.goal = session.goal;
     const rows = session.rows.filter(row => row.type === 'message').slice(-200);
+    const timingAfter = new Map(); let lastMessage;
+    for (const row of session.rows) { if (row.type === 'message') lastMessage = row; else if (row.type === 'result' && row.timing && lastMessage) timingAfter.set(lastMessage, row.timing); }
     for (const [responseId, row] of rows.entries()) {
       const message = row.message, inbound = inboundBlockFromRow(row);
       if (inbound) { this.blocks.push(inbound); continue; }
@@ -254,7 +273,10 @@ export class TerminalScreen {
         if (message.role === 'assistant' && block.type === 'tool_use') { const item = { role: 'tool', id: block.id, name: block.name, input: block.input, state: 'interrupted' }; this.blocks.push(item); this.toolBlocks.set(block.id, item); }
         if (message.role === 'user' && block.type === 'tool_result') { const item = this.toolBlocks.get(block.tool_use_id); if (item) { item.state = block.is_error ? 'error' : 'done'; item.output = block.content; } }
       }
+      if (timingAfter.has(row)) this.blocks.push({ role: 'timing', timing: timingAfter.get(row) });
     }
+    // Avisos recibidos que aún no llegaron al modelo: también se ven al recargar.
+    for (const notice of noticeMailbox(session.rows).ready) { const block = queuedNoticeBlock(notice); this.noticeBlocks.set(block.notice_id, block); this.blocks.push(block); }
     const history = rows.filter(row => row.message.role === 'user' && row.source !== 'goal' && (typeof row.message.content === 'string' || row.source === 'human_composer')).slice(-100);
     this.composer.history = history.map(row => typeof row.message.content === 'string' ? row.message.content : row.message.content.filter(block=>block.type==='text').map(block=>block.text).join('\n'));
     this.composer.historyAttachments = history.map(row=>row.attachments || []);
@@ -268,7 +290,7 @@ export class TerminalScreen {
       if (!child) { child = { role: 'subagent', id: row.session_id }; this.subagentBlocks.set(row.session_id, child); this.blocks.push(child); }
       Object.assign(child, row, { role: 'subagent', state: row.status === 'running' ? 'interrupted' : row.status });
     }
-    this.usage = session.rows.filter(row => row.type === 'result' && !row.usage_includes_subagents).reduce((n, row) => n + (row.usage?.input_tokens || 0) + (row.usage?.output_tokens || 0), 0)
+    this.usage = session.rows.filter(row => (row.type === 'result' && !row.usage_includes_subagents) || (row.type === 'error' && row.usage)).reduce((n, row) => n + (row.usage?.input_tokens || 0) + (row.usage?.output_tokens || 0), 0)
       + childUsage;
     this.schedule();
   }
@@ -283,13 +305,14 @@ export class TerminalScreen {
       if (event.tool_argument_chars) this.phase = t("Preparing tools · {v0} characters", {v0: formatNumber(event.tool_argument_chars)});
       else if (event.reasoning_chars && !event.text_chars) this.phase = t("Model reasoning · {v0} characters", {v0: formatNumber(event.reasoning_chars)});
     }
+    if (event.type === 'model_stream_phase') this.phase = event.phase === 'reasoning' ? t('Reasoning…') : t('Responding…');
     if (event.type === 'context_usage') this.context = event;
     if (event.type === 'vision_status') {
       const stamp = JSON.stringify([event.supported, event.source, event.images, event.references?.map(ref => ref.sha256)]);
       if (stamp !== this.lastVisionStamp) { this.lastVisionStamp = stamp; this.notice(event.images ? t("Vision · {v0} images in the request · reserve ~{v1} tokens.", {v0: event.images, v1: event.token_reserve}) : t("Screenshot saved as a reference · {v0}.", {v0: event.supported ? t("no space for pixels in the context") : t("the provider does not advertise vision")})); }
     }
     if (event.type === 'context_projection_start') this.phase = t("Deriving state from the ledger");
-    if (event.type === 'context_projection') this.notice(t("State derived \u00b7 ~{v0} tokens \u00b7 0 LLM summary calls \u00b7 evidence saved.", {v0: event.after_tokens}));
+    if (event.type === 'context_projection') { const automatic = event.compaction_trigger !== 'manual' && compactionNotice(event); this.notice(automatic || t("State derived \u00b7 ~{v0} tokens \u00b7 0 LLM summary calls \u00b7 evidence saved.", {v0: event.after_tokens})); }
     if (['model_retry', 'response_discarded'].includes(event.type)) {
       if (this.streaming) { this.streaming.text += t("\n\n[Incomplete response discarded; its tools were not executed.]"); this.streaming = null; }
       if (event.type === 'model_retry') this.notice(t("Response discarded ({v0}) · bounded retry · maximum output {v1} tokens.", {v0: event.reason, v1: event.max_tokens}));
@@ -324,7 +347,12 @@ export class TerminalScreen {
       this.schedule(); return;
     }
     if (event.type === 'user' && event.source !== 'goal') this.blocks.push({ role: 'user', text: event.userIntent || event.text });
-    const inbound = inboundBlockFromEvent(event); if (inbound) this.blocks.push(inbound);
+    // Un aviso no urgente no despierta un turno: se pinta al llegar y, cuando por fin se
+    // entrega al modelo, el mismo bloque deja de estar en espera (no se repite).
+    if (event.type === 'plugin_notice_admitted' && event.status === 'accepted' && event.notice?.notice_id && !event.notice.urgent && !this.noticeBlocks.has(event.notice.notice_id)) { const block = queuedNoticeBlock(event.notice); this.noticeBlocks.set(block.notice_id, block); this.blocks.push(block); }
+    const queued = event.type === 'plugin_notice' && this.noticeBlocks.get(event.notice?.notice_id);
+    if (queued) { delete queued.state; queued.cacheKey = null; this.noticeBlocks.delete(event.notice.notice_id); }
+    const inbound = !queued && inboundBlockFromEvent(event); if (inbound) this.blocks.push(inbound);
     if (event.type === 'text_delta' && this.pendingCommand && !this.streaming) { const { command, arg } = this.pendingCommand; this.pendingCommand = null; this.blocks.push({ role: 'result', command, arg, text: String(event.text ?? '') }); }
     else if (event.type === 'text_delta') {
       if (!this.streaming) { this.streaming = { role: 'assistant', text: '' }; this.blocks.push(this.streaming); }
@@ -336,6 +364,8 @@ export class TerminalScreen {
     }
     if (event.type === 'tool_use') { const item = { role: 'tool', id: event.id, name: event.name, input: event.input, state: 'running' }; this.blocks.push(item); this.toolBlocks.set(event.id, item); this.phase = t("Executing {v0}", {v0: event.name}); }
     if (event.type === 'tool_result') { const item = this.toolBlocks.get(event.tool_use_id); if (item) { item.state = event.is_error ? 'error' : 'done'; item.output = event.content; } }
+    if (event.type === 'refusal') this.notice(t("Anthropic declined (category: {v0}).{v1}", {v0: event.category || t('unspecified'), v1: event.fallback_ran ? t(' Fallback also declined.') : ''}), true);
+    if (event.type === 'model_fallback') this.notice(t("Served by fallback model {v0}.", {v0: event.served_by || '—'}));
     if (event.type === 'auto_decision') this.blocks.push({ role: 'notice', text: `Auto · ${event.decision}: ${event.reason}`, error: event.decision === 'deny' });
     if (event.type === 'model_progress') { this.turn = event.turn; this.maxTurns = event.maxTurns; }
     if (event.type === 'phase') {
@@ -347,7 +377,8 @@ export class TerminalScreen {
       if (event.goal.status !== 'active' && key !== this.lastGoalNotice) { this.lastGoalNotice = key; this.notice(`◎ /goal ${event.goal.status}: ${event.goal.lastReason}`, ['failed', 'budget'].includes(event.goal.status)); }
       this.goal = event.goal;
     }
-    if (event.type === 'result' && !event.usage_includes_subagents) this.usage += (event.usage?.input_tokens || 0) + (event.usage?.output_tokens || 0);
+    if (event.type === 'result' && event.timing) this.blocks.push({ role: 'timing', timing: event.timing });
+    if (event.type === 'turn_usage' || (event.type === 'result' && !event.usage_includes_subagents)) this.usage += (event.usage?.input_tokens || 0) + (event.usage?.output_tokens || 0);
     if (event.type === 'work_continuation') this.notice(t("Continues {v0} · {v1}/{v2} calls · checkpoint preserved.", {v0: event.task_id, v1: event.calls, v2: event.limit}));
     if(event.type==='peer_reply')this.notice(event.status==='failed'?t("The house could not send the report: {v0}", {v0: event.error}):t("The house returned the report to mailbox {v0} · {v1}.", {v0: event.to.slice(0,8), v1: event.status}),event.status==='failed');
     if (event.type === 'result' && event.work_stop_reason) this.notice(t("Work: {v0}.", {v0: event.work_stop_reason}));
@@ -367,7 +398,7 @@ export class TerminalScreen {
   async confirm(name, input, signal, { summary, remember, edit } = {}) {
     if (signal?.aborted || this.closed) return false;
     if (this.selecting) this.setSelection(false);
-    return new Promise(resolve => {
+    return measureHumanWait(new Promise(resolve => {
       let settled=false;
       const finish = allowed => { if(settled)return;settled=true;signal?.removeEventListener('abort', abort);if(this.permission===question)this.permission = null;this.schedule();resolve(allowed); };
       const abort = () => finish(false);
@@ -375,7 +406,7 @@ export class TerminalScreen {
       const choices = remember?.rule ? ['once', ...(remember.project ? ['project'] : []), 'user', 'no'] : null;
       const question = { name, input, summary, edit: edit && typeof edit.field === 'string' && typeof edit.text === 'string' ? { field: edit.field, text: edit.text } : null, allowed: false, scroll: 0, finish, ...(choices ? { remember, choices, choice: choices.length - 1 } : {}) };
       this.permission = question;signal?.addEventListener('abort', abort, { once: true });if(signal?.aborted)abort();else this.schedule();
-    });
+    }));
   }
   // Editar antes de enviar: la tarjeta se deniega (no se envía nada) y el texto exacto
   // pasa al composer con una instrucción. El humano lo corrige y lo envía; el modelo
@@ -408,6 +439,8 @@ export class TerminalScreen {
   // sin turnos del modelo. Se limpia al entrar y se vuelve a pintar sola si está a la vista.
   setSwarmView(view) { this.swarmView = normalizeSwarmView(view); if (this.overlay?.kind === 'swarm' || this.swarmStrip) this.schedule(); }
   toggleSwarm() { if (this.overlay?.kind === 'swarm') { this.closeOverlay(); return; } this.overlay = { kind: 'swarm', scroll: 0, swarm: 0, index: 0, follow: true }; this.schedule(); }
+  // /timing: one dim line after each final answer; default on, not saved (like /swarm strip).
+  setTiming(value = !this.showTiming) { this.showTiming = Boolean(value); this.notice(this.showTiming ? t('Response timing on: a dim line after each answer. /timing off hides it.') : t('Response timing off. /timing on shows it again.')); }
   setSwarmStrip(value = !this.swarmStrip) { this.swarmStrip = Boolean(value); this.notice(this.swarmStrip ? t('Swarm strip on: a compact summary next to the conversation (terminals 110+ columns wide). /swarm strip turns it off.') : t('Swarm strip off.')); }
   // Enter en el panel: prepara el pedido en el composer (no lo envía). El humano lo envía y
   // las acciones siguen en sus tarjetas; Esc recupera el borrador anterior.
@@ -586,6 +619,12 @@ export class TerminalScreen {
       else output.push('', tone.accent(t("  COMAL · on the comal one cooks")), '', ...intro);
     }
     for (const block of this.blocks) {
+      if (block.role === 'timing') {
+        // Rendered each frame (language can change); it sits right under the answer.
+        const line = this.showTiming ? formatTurnTiming(block.timing, { width: columns - 3 }) : '';
+        if (line) { if (output.at(-1) === '') output.pop(); output.push(tone.muted(clip('  ' + line, columns - 1)), ''); }
+        continue;
+      }
       const cacheKey = `${columns}:${this.expandedTools}:${Boolean(this.rawView)}:${block.text || ''}:${block.state || ''}:${block.output || ''}`;
       if (block.cacheKey === cacheKey) { output.push(...block.cached); continue; }
       let lines;

package/src/tui/swarm-panel.mjs

@@ -22,7 +22,7 @@ export function normalizeSwarmView(view) {
   if (view.available !== true) return { available: false, reason: text(view.reason || 'unknown', 40), error: view.error ? text(view.error, 600) : null };
   const c = view.connection && typeof view.connection === 'object' ? view.connection : {};
   const connection = {
-    notify: c.notify === 'off' ? 'off' : 'on', state: text(c.state || 'idle', 30), cursor: c.cursor == null ? null : text(c.cursor, 24),
+    notify: c.notify === 'off' ? 'off' : 'on', mode: c.notify === 'off' ? 'off' : ['cards', 'wake'].includes(c.mode) ? c.mode : 'on', state: text(c.state || 'idle', 30), cursor: c.cursor == null ? null : text(c.cursor, 24),
     events_seen: count(c.events_seen), reconnects: count(c.reconnects),
     last_event: c.last_event ? { seq: text(c.last_event.seq, 24), type: text(c.last_event.type, 60) } : null,
     last_error: c.last_error ? { code: text(c.last_error.code, 60), message: text(c.last_error.message, 400) } : null,
@@ -31,30 +31,40 @@ export function normalizeSwarmView(view) {
   };
   const swarms = list(view.swarms, LIMITS.swarms).map(swarm => ({
     id: id(swarm?.id) || '?', objective: swarm?.objective ? text(swarm.objective, 300) : null, root_team: swarm?.root_team ? text(swarm.root_team, 120) : null, truncated: swarm?.truncated === true,
-    tasks: list(swarm?.tasks, LIMITS.tasks).map(task => ({ id: id(task?.id) || '?', title: task?.title ? text(task.title, 160) : null, state: text(task?.state || '?', 40), team: text(task?.team || '', 120), role: text(task?.role || '', 120), role_name: task?.role_name ? text(task.role_name, 60) : null, attempts_used: count(task?.attempts_used), max_attempts: count(task?.max_attempts), since: time(task?.since), since_exact: task?.since_exact === true, infra_exhausted: task?.infra_exhausted === true })),
+    tasks: list(swarm?.tasks, LIMITS.tasks).map(task => ({ id: id(task?.id) || '?', title: task?.title ? text(task.title, 160) : null, state: text(task?.state || '?', 40), team: text(task?.team || '', 120), role: text(task?.role || '', 120), role_name: task?.role_name ? text(task.role_name, 60) : null, attempts_used: count(task?.attempts_used), counted_attempts: count(task?.counted_attempts ?? task?.attempts_used), max_attempts: count(task?.max_attempts), since: time(task?.since), since_exact: task?.since_exact === true, infra_exhausted: task?.infra_exhausted === true, wake_cap: task?.wake_cap === true, review_rounds: count(task?.review_rounds), review_kind: ['task', 'integration', 'final'].includes(task?.review_kind) ? task.review_kind : null })),
     roles: list(swarm?.roles, LIMITS.roles).map(role => ({ id: text(role?.id || '?', 120), name: text(role?.name || role?.id || '?', 60), team: text(role?.team || '', 120), occupied: role?.occupied === true, model: role?.model ? text(role.model, 60) : null })),
     pending: list(swarm?.pending, LIMITS.pending).map(item => ({ delivery_id: text(item?.delivery_id || '', 200), message_id: id(item?.message_id), kind: text(item?.kind || 'message', 30), from: text(item?.from || '?', 120), sent_at: time(item?.sent_at), excerpt: item?.excerpt ? text(item.excerpt, 240) : null, task: id(item?.task), decision: item?.decision ? { question: text(item.decision.question, 200), options: list(item.decision.options, 4).map(option => text(option, 120)), recommended: item.decision.recommended ? text(item.decision.recommended, 120) : null } : null })),
+    // Revisor (open-relay F7): estado de los criterios de éxito del swarm (criteria.get).
+    criteria: swarm?.criteria && typeof swarm.criteria === 'object' ? { status: text(swarm.criteria.status || 'none', 20), version: count(swarm.criteria.version), digest: /^[a-f0-9]{64}$/.test(String(swarm.criteria.digest || '')) ? swarm.criteria.digest : null, rounds: count(swarm.criteria.rounds), renegotiating: Boolean(swarm.criteria.renegotiating), in_force: count(swarm.criteria.in_force) } : null,
     plans: list(swarm?.plans, LIMITS.plans).map(plan => ({ proposal_id: id(plan?.proposal_id), proposer_role: text(plan?.proposer_role || '?', 120), parent_task: id(plan?.parent_task), summary: plan?.summary ? text(plan.summary, 240) : null, proposed_at: time(plan?.proposed_at), tasks: count(plan?.tasks), roles: count(plan?.roles) })),
   }));
   return { available: true, connection, swarms, swarms_total: count(view.swarms_total) || swarms.length, updated_at: time(view.updated_at), generated_at: time(view.generated_at) };
 }
 
 /** Columnas del kanban, en orden. Los estados de relayd caen en una; lo desconocido, en «otros». */
-export const SWARM_COLUMNS = Object.freeze(['pending', 'running', 'verifying', 'blocked', 'done', 'closed', 'other']);
+export const SWARM_COLUMNS = Object.freeze(['pending', 'running', 'verifying', 'reviewing', 'blocked', 'done', 'closed', 'other']);
 export function swarmColumn(state) {
   if (['draft', 'ready'].includes(state)) return 'pending';
   if (['assigned', 'in_progress'].includes(state)) return 'running';
   if (state === 'verifying') return 'verifying';
+  // Revisor (open-relay F4–F6): con los checks en verde, esperando el veredicto del revisor.
+  if (state === 'reviewing') return 'reviewing';
   if (state === 'needs_attention' || String(state).startsWith('blocked')) return 'blocked';
   if (state === 'done') return 'done';
   if (['failed', 'cancelled'].includes(state)) return 'closed';
   return 'other';
 }
-const columnLabel = column => ({ pending: t('PENDING'), running: t('IN PROGRESS'), verifying: t('VERIFYING'), blocked: t('BLOCKED'), done: t('DONE'), closed: t('FAILED · CANCELLED'), other: t('OTHER') })[column];
-const blockLabel = state => {
+// Intentos que cuentan contra el máximo (counted_attempts de relayd); los excusados por
+// infraestructura o reabiertos tras despertar (attempts_used de más) sólo como nota.
+const attemptsLabel = task => {
+  const excused = task.attempts_used - task.counted_attempts;
+  return excused > 0 ? t('{used}/{max} attempts (+{excused} excused)', { used: task.counted_attempts, max: task.max_attempts, excused }) : t('{used}/{max} attempts', { used: task.counted_attempts, max: task.max_attempts });
+};
+const columnLabel = column => ({ pending: t('PENDING'), running: t('IN PROGRESS'), verifying: t('VERIFYING'), reviewing: t('IN REVIEW'), blocked: t('BLOCKED'), done: t('DONE'), closed: t('FAILED · CANCELLED'), other: t('OTHER') })[column];
+export const blockLabel = state => {
   if (state === 'needs_attention') return t('needs attention');
   const cause = String(state).split(':')[1];
-  return { question: t('waiting for your answer'), approval: t('waiting for approval'), dependency: t('waiting for a dependency'), capacity: t('no free role'), budget: t('budget exhausted'), children: t('waiting for subtasks'), config: t('dispatch configuration'), environment: t('environment') }[cause] || cause || '';
+  return { question: t('waiting for your answer'), approval: t('waiting for approval'), dependency: t('waiting for a dependency'), capacity: t('no free role'), budget: t('budget exhausted'), children: t('waiting for subtasks'), config: t('dispatch configuration'), environment: t('environment'), criteria: t('waiting for the success criteria'), review: t('the reviewer is correcting it') }[cause] || cause || '';
 };
 export function formatAge(ms) {
   if (!Number.isFinite(ms) || ms < 0) return '';
@@ -170,7 +180,8 @@ export function swarmPanelLines(raw, state, columns, height, { now = Date.now(),
     for (const task of tasks) {
       lines.push(...wrap(`${task.id}${task.title ? ' · ' + task.title : ''}`, columns - 6).slice(0, 2).map(line => '    ' + line));
       const role = task.role_name || roleNames.get(task.role), age = task.since ? (task.since_exact ? '' : '≥') + formatAge(now - task.since) : '';
-      const detail = [role ? `${role}${role !== task.role && task.role ? ` (${task.role})` : ''}` : task.role, task.state, column === 'blocked' ? blockLabel(task.state) : '', task.max_attempts ? t('{used}/{max} attempts', { used: task.attempts_used, max: task.max_attempts }) : '', task.infra_exhausted ? t('infrastructure streak exhausted') : '', age].filter(Boolean).join(' · ');
+      const review = task.review_kind ? t({ task: 'task review', integration: 'integration review', final: 'final review' }[task.review_kind]) : '';
+      const detail = [role ? `${role}${role !== task.role && task.role ? ` (${task.role})` : ''}` : task.role, task.state, column === 'blocked' ? blockLabel(task.state) : '', review, task.review_rounds ? t('reviewer objections: {n}', { n: task.review_rounds }) : '', task.max_attempts ? attemptsLabel(task) : '', task.infra_exhausted ? t('infrastructure streak exhausted') : '', task.wake_cap ? t('wake cap reached: only you can resume it') : '', age].filter(Boolean).join(' · ');
       lines.push(...wrap(detail, columns - 8).slice(0, 2).map(line => '      ' + (column === 'blocked' ? tone.warning : tone.muted)(line)));
     }
     lines.push('');
@@ -198,7 +209,7 @@ export function swarmStripLines(view, width) {
     const by = column => swarm.tasks.filter(task => swarmColumn(task.state) === column).length;
     const questions = swarm.pending.filter(item => item.kind === 'question').length, plans = swarm.plans.length;
     out.push(clip(' ' + swarm.id, width));
-    out.push(...wrap(t('{run} run · {blocked} blocked · {done} done', { run: by('running') + by('verifying'), blocked: by('blocked'), done: by('done') }), width - 1).slice(0, 2).map(line => tone.muted(' ' + line)));
+    out.push(...wrap(t('{run} run · {blocked} blocked · {done} done', { run: by('running') + by('verifying') + by('reviewing'), blocked: by('blocked'), done: by('done') }), width - 1).slice(0, 2).map(line => tone.muted(' ' + line)));
     if (questions || plans) out.push(...wrap(t('{q} questions · {p} plans', { q: questions, p: plans }), width - 1).slice(0, 2).map(line => tone.warning(' ' + line)));
   }
   out.push(tone.muted(clip(' ' + t('/swarm opens'), width)));

package/src/turn-timing.mjs

@@ -0,0 +1,82 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { performance } from 'node:perf_hooks';
+import { t } from './i18n/index.mjs';
+
+// Per-turn timing on the host's monotonic clock. A turn runs inside its timer's
+// async context, so a permission card shown by any tool of that turn (or of a
+// nested subagent turn) is charged as human wait, never as Comal time.
+const active = new AsyncLocalStorage();
+export const monotonic = () => performance.now();
+export const TURN_TIMING_VERSION = 1;
+const round = value => value == null ? null : Math.round(value * 10) / 10;
+
+export class TurnTimer {
+  constructor({ clock = monotonic, parent = active.getStore() } = {}) {
+    this.clock = clock; this.parent = parent; this.started = clock();
+    this.requests = []; this.toolsMs = 0; this.humanMs = 0; this.open = 0; this.openedAt = 0;
+    this.firstText = null; this.firstOutput = null;
+  }
+  now() { return this.clock(); }
+  run(fn) { return active.run(this, fn); }
+  // Overlapping waits (parallel cards) count once: the union of open intervals.
+  humanStart() { if (this.open++ === 0) this.openedAt = this.clock(); this.parent?.humanStart(); }
+  humanEnd() { if (this.open > 0 && --this.open === 0) this.humanMs += this.clock() - this.openedAt; this.parent?.humanEnd(); }
+  humanTotal() { return this.humanMs + (this.open ? this.clock() - this.openedAt : 0); }
+  // Accepts a promise or a function that starts the wait (so the clock starts first).
+  async humanWait(wait) { this.humanStart(); try { return await (typeof wait === 'function' ? wait() : wait); } finally { this.humanEnd(); } }
+  async tools(run) {
+    const start = this.clock(), human = this.humanTotal();
+    try { return await run(); } finally { this.toolsMs += Math.max(0, this.clock() - start - (this.humanTotal() - human)); }
+  }
+  observeText() { this.firstText ??= this.clock() - this.started; this.observeOutput(); }
+  observeOutput() { this.firstOutput ??= this.clock() - this.started; }
+  record(event) { this.requests.push(event); }
+  summary({ status = 'answered' } = {}) {
+    const total = this.clock() - this.started, human = this.humanTotal();
+    const model = this.requests.reduce((sum, item) => sum + (item.phases?.find(phase => phase.phase === 'provider')?.elapsed_ms || 0), 0);
+    const reasoned = this.requests.filter(item => item.reasoning_ms != null);
+    return {
+      version: TURN_TIMING_VERSION, scope: 'host_monotonic_not_provider_billing', status,
+      total_ms: round(total), comal_ms: round(Math.max(0, total - human)), model_ms: round(model),
+      reasoning_ms: reasoned.length ? round(reasoned.reduce((sum, item) => sum + item.reasoning_ms, 0)) : null,
+      first_text_ms: round(this.firstText), first_output_ms: round(this.firstOutput),
+      tools_ms: round(this.toolsMs), human_wait_ms: round(human),
+      host_ms: round(Math.max(0, total - human - model - this.toolsMs)), requests: this.requests.length,
+      reasoning_requests: reasoned.length,
+      reasoning_tokens: this.requests.some(item => Number.isSafeInteger(item.reasoning_tokens)) ? this.requests.reduce((sum, item) => sum + (item.reasoning_tokens || 0), 0) : null
+    };
+  }
+}
+
+export function currentTurnTimer() { return active.getStore(); }
+/** Wraps a wait for a human answer; outside a turn it is a no-op. */
+export function measureHumanWait(wait) { const timer = active.getStore(); return timer ? timer.humanWait(wait) : typeof wait === 'function' ? wait() : wait; }
+
+export function formatSeconds(ms) {
+  if (ms < 1000) return `${Math.round(ms)} ms`;
+  const seconds = ms / 1000;
+  if (seconds < 60) return `${seconds.toFixed(1)} s`;
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes} min ${String(Math.round(seconds - minutes * 60)).padStart(2, '0')} s`;
+}
+
+/** One dim line for the TUI. Zero or unknown parts are omitted; when `width`
+ * is given, the least important parts are dropped instead of cutting a number. */
+export function formatTurnTiming(timing, { width = Infinity } = {}) {
+  if (!timing || !(Math.round(timing.comal_ms) > 0)) return '';
+  const parts = [];
+  const add = (key, value, label) => { if (Math.round(value) > 0) parts.push({ key, text: t(label, { v0: formatSeconds(value) }) }); };
+  add('reasoning', timing.reasoning_ms, 'reasoned {v0}');
+  add('first', timing.first_output_ms, 'first response {v0}');
+  add('tools', timing.tools_ms, 'tools {v0}');
+  add('human', timing.human_wait_ms, 'waiting for you {v0}');
+  const line = () => [`⏱ ${formatSeconds(timing.comal_ms)}`, ...parts.map(part => part.text)].join(' · ');
+  for (const key of ['first', 'tools', 'reasoning']) { if ([...line()].length <= width) break; const index = parts.findIndex(part => part.key === key); if (index >= 0) parts.splice(index, 1); }
+  return line();
+}
+
+/** Public JSON contract of the final `result` event. */
+export function resultTiming(summary) {
+  const { total_ms, model_ms, reasoning_ms, first_text_ms, tools_ms, human_wait_ms, requests, comal_ms, first_output_ms, host_ms, reasoning_requests, reasoning_tokens } = summary;
+  return { total_ms, model_ms, reasoning_ms, first_text_ms, tools_ms, human_wait_ms, requests, comal_ms, first_output_ms, host_ms, reasoning_requests, reasoning_tokens };
+}

package/src/usage-accounting.mjs

@@ -8,11 +8,22 @@ export function normalizeUsage(protocol, raw) {
   let input=null, fresh=null, read=null, write=null, output=null, reasoning=null, semantics='unknown';
   const fields={};
   const take=(name,value)=>{const n=count(value);if(n!==null)fields[name]=n;return n;};
-  if(protocol==='anthropic') {
+  const anthropicIters=protocol==='anthropic'&&Array.isArray(raw.iterations)?raw.iterations.filter(entry=>entry&&typeof entry==='object'):null;
+  if(protocol==='anthropic'&&anthropicIters&&anthropicIters.length) {
+    // usage.iterations es la verdad de facturación por intento (fallback incluido):
+    // se suma por intento para el costo. El model de nivel superior cubre sólo el
+    // intento que produjo el mensaje; aquí se agrega la cadena entera.
+    const add=(name,pick)=>{const vals=anthropicIters.map(pick).map(count);if(vals.length&&vals.every(value=>value!==null)){fields[name]=vals.reduce((a,b)=>a+b,0);return fields[name];}return null;};
+    fresh=add('input_tokens',entry=>entry.input_tokens);read=add('cache_read_input_tokens',entry=>entry.cache_read_input_tokens);write=add('cache_creation_input_tokens',entry=>entry.cache_creation_input_tokens);
+    output=add('output_tokens',entry=>entry.output_tokens);reasoning=add('thinking_tokens',entry=>entry.output_tokens_details?.thinking_tokens);
+    input=sum([fresh,read,write]);if(fresh!==null && read===null && write===null) input=fresh;semantics='cache_components_separate';
+  } else if(protocol==='anthropic') {
     fresh=take('input_tokens',raw.input_tokens);read=take('cache_read_input_tokens',raw.cache_read_input_tokens);write=take('cache_creation_input_tokens',raw.cache_creation_input_tokens);
     // Anthropic omits absent cache components on uncached responses; omission is
     // not observed zero. The base is exact only if all components are reported.
     input=sum([fresh,read,write]);output=take('output_tokens',raw.output_tokens);semantics='cache_components_separate';
+    // Claude 5.x reports thinking inside output_tokens (output_tokens_details.thinking_tokens).
+    reasoning=take('thinking_tokens',raw.output_tokens_details?.thinking_tokens);
     if(fresh!==null && read===null && write===null) input=fresh;
   } else if(['openai','codex'].includes(protocol)) {
     input=take(protocol==='openai'?'prompt_tokens':'input_tokens',protocol==='openai'?raw.prompt_tokens:raw.input_tokens);

package/src/vision.mjs

@@ -4,10 +4,15 @@ import { workProjection } from './work-plan.mjs';
 import { comalEnvironment } from './compat.mjs';
 import { digest } from './operations.mjs';
 import { humanImageReferences, resolveHumanImage } from './image-attachments.mjs';
+import { VISUAL_IMAGE_OPERATIONS } from './visual/names.mjs';
 
 export const IMAGE_LIMIT = 2 * 1024 * 1024;
 export const IMAGE_COUNT = 2;
-const mcpReceipt = row => row.origin?.kind === 'mcp' || row.origin == null && /^mcp__.+__.+$/.test(row.operation || '');
+// Image-bearing receipts: MCP tools, the native Read of an image file, the native visual
+// acceptance operations, and exactly one plugin receipt (chrome-lab Screenshot), which carries
+// the same structured image block.
+const mcpReceipt = row => row.origin?.plugin === 'chrome-lab' && row.operation === 'plugin__chrome-lab__Screenshot'
+  || row.origin?.kind === 'mcp' || row.origin == null && (/^mcp__.+__.+$/.test(row.operation || '') || row.operation === 'Read' || VISUAL_IMAGE_OPERATIONS.includes(row.operation));
 export function visionSettings(options = {}, env = process.env) {
   env = comalEnvironment(env);
   const vision = options.vision ?? env.COMAL_VISION ?? 'auto';