@milpa/comal 0.0.0-stage → 0.1.1

package/src/tui/discovery.mjs

@@ -0,0 +1,222 @@
+import { t } from '../i18n/index.mjs';
+// Presentation-only discovery: supplied snapshots in, suggestions out. Never
+// reads a workspace, contacts a provider, executes tools, or changes authority.
+import { graphemes, safeText } from './text.mjs';
+
+const COMMANDS = [
+  ['cloud', '[login|status|logout]', 'Connect your Comal account for Artifacts and Remote Control'],
+  ['remote-control', '[start|status|stop]', 'Open this local session on the web'], ['rc', '[start|status|stop]', 'Remote Control shortcut'],
+  ['help', '', "Help and keyboard"], ['status', '', "Session, provider and budget"],
+  ['tools', '', "Tools available at this time"], ['house', '', "Receipts and interrupted operations"],
+  ['operations', '', "Contracts and effects of operations"], ['sessions', '', "Open the session selector"],
+  ['resume', 'UUID', "Resume a saved session"], ['clear', '', "Create a new conversation"],
+  ['copy', '', "Copy the last complete response"], ['select', '', "Select text with the terminal"],
+  ['compact', '', "Derive ledger state without an LLM"], ['context', '', "Check the context budget"],
+  ['state', '', "Request and current job status"], ['audit', '', "Verify ledger integrity"],
+  ['board', '', "Open the task board"], ['work', 'resume|recover', "Continue work or reconcile a Chrome publication"],
+  ['tasks', '', "Open the task board"], ['model', 'ID', "Check or change the model"],
+  ['models', '', "Check provider models; can make a request"],
+  ['effort', "LEVEL", "Check or change the effort announced by the model"],
+  ['capabilities', '[refresh]', "Support and provenance of capabilities"],
+  ['permissions', "MODE", "Change the permissions mode"], ['goal', "[condition|status|pause|resume|clear]", "Define or control a persistent goal"],
+  ['queue', '[pause|resume|clear|edit N]', "Manage queued messages"],
+  ['rename', "NAME", "Change the visible name of this session"], ['table', "FILE", "Display a CSV, TSV, JSON, or Markdown table"],
+  ['mcp', "[action]", "View or configure MCP servers"], ['plugins', "[action]", "View plugins and control their lifecycle"],
+  ['agent', "[explore|general|background] TASK", "Delegate a task to a subagent"], ['agents', '[UUID|status|wait|stop|resume|background|continue] [RUN]', "View and control child runs"],
+  ['search', "QUERY", "Search the web"], ['list-agents', '', "Discover other live sessions"],
+  ['send', "ID_OR_NAME TEXT", "Send a message to another session"], ['inbox', "[action]", "Control the mailbox between sessions"],
+  ['providers', '', "View profiles and login providers"], ['provider', "PROFILE", "Switch to the configured profile"],
+  ['login', "PROVIDER", "Authenticate a provider without pasting keys"], ['logout', "PROVIDER", "Remove Comal credentials"],
+  ['exit', '', "Save and exit"], ['quit', '', "Save and exit"],
+].map(([name, args, description]) => Object.freeze({ name, args, description }));
+export const COMMAND_CATALOG = Object.freeze(COMMANDS);
+
+// Search vocabulary only: exact registered names select these terms. They never
+// add an operation or replace the host's description/capability contract.
+const TOOL_KEYWORDS = Object.freeze({
+  Read: "read file files text content code code inspect leer archivo archivos texto contenido código codigo inspeccionar",
+  Write: "write create save file files code code escribir crear guardar archivo archivos código codigo",
+  Edit: "edit modify replace file files code code editar modificar reemplazar archivo archivos código codigo",
+  Glob: "search find files paths names pattern pattern buscar encontrar archivos rutas nombres patrón patron",
+  Grep: "search find text content matches regular expression buscar encontrar texto contenido coincidencias expresión regular",
+  Bash: 'terminal shell comandos ejecutar proceso procesos',
+  ListDirectory: "list directory folder folders files explore read-only read-only listar directorio carpeta carpetas archivos explorar sólo lectura solo lectura",
+  FileInfo: "information information file size size format signature header read-only read-only información informacion archivo tamaño tamano formato firma cabecera sólo lectura solo lectura",
+  ReadTable: "read table tables data CSV TSV JSON Markdown leer tabla tablas datos CSV TSV JSON Markdown",
+  WebSearch: "search search web internet sources research buscar búsqueda busqueda web internet fuentes investigar",
+  WebFetch: "read download page page link website internet source leer descargar página pagina enlace sitio web internet fuente",
+  AnalyzeMedia: "image images images vision vision photography photography photo capture multimedia video video analyze imagen imágenes imagenes visión vision fotografía fotografia foto captura multimedia video vídeo analizar",
+  ProviderSearch: "search search search web internet sources provider native investigate buscar búsqueda busqueda web internet fuentes proveedor nativo investigar",
+  ProviderCapabilities: "capabilities support provider model vision vision video video tools reasoning capacidades soporte proveedor modelo visión vision video vídeo herramientas razonamiento",
+  ListAgents: "list discover peers alive other sessions instances agents communication communication listar descubrir pares vivos otras sesiones instancias agentes comunicación comunicacion",
+  SendMessage: "send message messages communicate communication communication sessions peers delegate report response enviar mensaje mensajes comunicar comunicación comunicacion sesiones pares delegar informe respuesta",
+  Agent: "subagent subagents delegate explore investigate task subagente subagentes delegar explorar investigar tarea",
+  AgentBatch: "subagents delegate parallel tasks team batch subagentes delegar paralelo tareas equipo lote",
+  AgentStatus:'estado subagentes ejecuciones pendientes resultado verificado',
+  AgentWait:"wait subagent execution result esperar subagente ejecución resultado",
+  AgentStop:"stop cancel subagent execution detener cancelar subagente ejecución",
+  AgentResume:"resume subagent interrupted checkpoint reanudar subagente interrumpido checkpoint",
+  AgentContinue:"subagent recover delegation invocation interrupted subagente recuperar delegación invocación interrumpida",
+  AgentBackground:'subagente segundo plano background',
+  ToolPack: "load unload tools MCP packages packs temporary schemas discover acquire release cargar descargar herramientas MCP paquetes packs temporales esquemas descubrir adquirir liberar",
+  McpStatus: "MCP servers connections tools status MCP servidores conexiones herramientas estado",
+  McpConfigure: "MCP configure servers add add remove connections MCP configurar servidores añadir agregar quitar conexiones",
+  McpReload: "MCP reload reconnect servers connections tools MCP recargar reconectar servidores conexiones herramientas",
+  PluginStatus: 'plugins extensiones complementos dependencias operaciones estado',
+  PluginRun: "plugins extensions add-ons operation operation execute plugins extensiones complementos operación operacion ejecutar",
+  PluginEnable: 'plugins extensiones complementos activar habilitar',
+  PluginDisable: 'plugins extensiones complementos desactivar retirar',
+  PluginReload: 'plugins extensiones complementos recargar actualizar',
+  WorkBoard: "board kanban tasks work pending progress tablero kanban tareas trabajo pendientes progreso",
+  WorkSnapshot: "request request status work checkpoint memory petición peticion estado trabajo checkpoint memoria",
+  AuditStatus: "audit audit verify evidence ledger integrity auditoría auditoria verificar evidencia libro integridad",
+  EvidenceRead: "read evidence receipts ledger proof proofs leer evidencia recibos libro prueba pruebas",
+  HouseSnapshot: "house judge receipts operations status execution execution casa juez recibos operaciones estado ejecución ejecucion",
+  HouseContext: "house judge context evidence memory casa juez contexto evidencia memoria",
+  OperationCatalog: "catalog catalog operations contracts effects tools catálogo catalogo operaciones contratos efectos herramientas",
+});
+const COMMAND_KEYWORDS = Object.freeze({
+  help: 'ayuda atajos teclado', tools: "catalog catalog discover tools catálogo catalogo descubrir herramientas",
+  operations: "contracts effects tools catalog catalog contratos efectos herramientas catálogo catalogo",
+  sessions: "sessions history resume recover sesiones historial retomar recuperar", resume: "sessions history resume recover continue sesiones historial retomar recuperar continuar",
+  compact: "memory projection projection derive summary context memoria proyección proyeccion derivar resumen contexto",
+  board: "kanban pending tasks progress kanban pendientes tareas progreso", work: "kanban checkpoint continue resume kanban checkpoint continuar retomar",
+  effort: 'esfuerzo razonamiento pensar thinking', capabilities: "capabilities vision vision video images images support capacidades visión vision video imágenes imagenes soporte",
+  permissions: "modes security permissions authorize plan automatic automatic modos seguridad permisos autorizar plan automático automatico",
+  goal: "goal autonomous autonomous continue persistent objetivo autónomo autonomo continuar persistente", queue: "queue messages pending pause reorder cola mensajes pendientes pausar reordenar",
+  mcp: "tools servers connect reload stdio HTTP herramientas servidores conectar recargar stdio HTTP", plugins: "extensions add-ons modules modules extensiones complementos módulos modulos",
+  agent: "subagent delegate task explore subagente delegar tarea explorar", agents: 'subagentes delegados estado',
+  search: "investigate search search internet sources investigar búsqueda busqueda internet fuentes", 'list-agents': "peers alive other instances communicate sessions pares vivos otras instancias comunicar sesiones",
+  send: "communicate message between peer sessions comunicar mensaje sesiones pares", inbox: "mailbox mailbox messages receive sessions buzón buzon mensajes recibir sesiones",
+  login: "log in session authenticate subscription subscription iniciar sesión sesion autenticar suscripción suscripcion", logout: "log out session credentials cerrar sesión sesion credenciales",
+});
+
+const token = value => typeof value === 'string' && value.length <= 256 && value.length > 0 && !/[\s\x00-\x1f\x7f-\x9f]/u.test(value);
+const description = value => safeText(value || '').replace(/\s+/g, ' ').slice(0, 240);
+function entries(values, key = 'name') {
+  return (Array.isArray(values) ? values : []).flatMap(value => {
+    const id = typeof value === 'string' ? value : value?.[key];
+    return token(id) ? [{ label: id, value: id, description: description(value?.description), kind: 'argument' }] : [];
+  });
+}
+const named = (values, descriptionText) => entries(values).map(value => ({ ...value, description: descriptionText }));
+const unique = values => values.filter((item, index) => values.findIndex(other => other.kind === item.kind && other.value === item.value) === index);
+const skills = context => entries(context.skills).filter(skill => /^[\p{L}\p{N}_-]+$/u.test(skill.value) && !COMMANDS.some(command => command.name === skill.value));
+
+/** All items are discoverable UI data, never dispatch instructions. Tools have
+ * inspectOnly because /ToolName is not a Comal command. The host may show their
+ * descriptions or let the human compose a request; it must not execute on open.
+ */
+export function commandCatalog(context = {}) {
+  return [
+    ...COMMANDS.map(command => ({ label: `/${command.name}`, value: `/${command.name}${command.args ? ' ' : ''}`, description: t(command.description), keywords: COMMAND_KEYWORDS[command.name] || '', kind: 'command', syntax: `/${command.name}${command.args ? ` ${t(command.args)}` : ''}` })),
+    ...skills(context).map(skill => ({ ...skill, label: `/${skill.value}`, value: `/${skill.value} `, kind: 'skill' })),
+    ...unique(entries(context.tools)).map(tool => ({ ...tool, keywords: TOOL_KEYWORDS[tool.value] || '', kind: 'tool', inspectOnly: true })),
+  ];
+}
+
+function argumentItems(command, args, context) {
+  const first = args[0] || '', position = args.length - 1;
+  if (position === 0) {
+    if (command === 'rc' || command === 'remote-control')return named(['start','status','stop'],'Remote session projection; local tools and permissions');
+    if (command === 'cloud') return named(['login','status','logout'],'Comal account; separate from the model provider');
+    if (command === 'permissions') return named(['default', 'plan', 'acceptEdits', 'auto'], t("Permissions mode; does not change the model"));
+    if (command === 'effort') return named(context.effortLevels || context.capabilities?.effort?.levels || ['auto'], t("Level announced by the current model"));
+    if (command === 'provider') return [...entries(context.profiles), ...entries(context.authProviders || ['codex', 'kimi', 'minimax', 'grok'], 'id')];
+    if (command === 'model') return entries(context.models, 'id');
+    if (command === 'resume') return entries(context.sessions, 'id');
+    if (command === 'agents') return [...named(['status','wait','stop','resume','background','continue'],t("Child run controls")),...entries(context.agents,'id')];
+    if (command === 'send') return entries(context.peers, 'id').map(peer => ({ ...peer, description: t("Known live session; sending does not equal executing") }));
+    if (command === 'capabilities') return named(['refresh'], 'Volver a consultar capacidades; puede hacer peticiones');
+    if (command === 'work') return named(['resume', 'recover'], t("Continue work or reconcile a Chrome publication"));
+    if (command === 'goal') return named(['status', 'pause', 'resume', 'clear'], t("Target control; you can also write a condition"));
+    if (command === 'queue') return named(['pause', 'resume', 'clear', 'edit'], t("Action on the queue"));
+    if (command === 'mcp') return named(['status', 'list', 'config', 'reload', 'reconnect', 'add', 'remove'], t("Action on MCP servers"));
+    if (command === 'plugins') return named(['status', 'list', 'enable', 'disable', 'reload', 'run'], t("Action on plugins"));
+    if (command === 'agent') return named(['explore', 'general','background'], t("Subagent type; complete the task afterwards"));
+    if (command === 'inbox') return named(['status', 'accept', 'hold', 'refuse', 'release'], t("Mailbox control between sessions"));
+    if (command === 'login' || command === 'logout') return [...(command === 'login' ? named(['status'], t("Check login status")) : []), ...entries(context.authProviders || ['codex', 'kimi', 'minimax', 'grok'], 'id')];
+  }
+  if (position === 1) {
+    if(command==='agents' && ['status','wait','stop','resume','background'].includes(first))return entries(context.agents,'id');
+    if (command === 'mcp' && ['reconnect', 'remove'].includes(first)) return entries(context.mcpServers);
+    if (command === 'plugins' && ['enable', 'disable', 'reload', 'run'].includes(first)) return entries(context.plugins, 'id');
+    if (command === 'inbox' && first === 'release') return named(['all'], t("Release held messages; does not change hold mode"));
+    if (command === 'queue' && first === 'edit') return named((context.queue?.items || []).map((_, index) => String(index + 1)), t("Edit this pending message"));
+    if (command === 'login' && first === 'status') return entries(context.authProviders || ['codex', 'kimi', 'minimax', 'grok'], 'id');
+    if (command === 'login' && first !== 'status') return named(['--api-key-env'], t("Environment variable name, never the key"));
+  }
+  if (position === 2 && command === 'plugins' && first === 'run') {
+    const plugin = (context.plugins || []).find(plugin => plugin.id === args[1]);
+    const prefix = `plugin__${args[1]}__`;
+    return entries(plugin?.operations).map(operation => {
+      const value = !plugin.builtin && operation.value.startsWith(prefix) ? operation.value.slice(prefix.length) : operation.value;
+      return { ...operation, label: value, value, kind: 'operation', description: operation.description || t("Operation registered by this plugin") };
+    });
+  }
+  return [];
+}
+
+function syntaxHint(command, context) {
+  if (command === 'model' && !(context.models || []).length) return t("Use /models to check the catalog; no requests are made when typing.");
+  if (command === 'effort' && !context.effortLevels && !context.capabilities?.effort?.levels) return t("Only auto is confirmed. /capabilities shows the available levels.");
+  if (command === 'plugins') return t("/plugins run ID OPERATION {JSON} · mutations wait their turn.");
+  if (command === 'login') return t("Never paste a key here; use --api-key-env VARIABLE.");
+  if (skills(context).some(skill => skill.value === command)) return t("Local skill: write the task after the name.");
+  const entry = COMMANDS.find(entry => entry.name === command);
+  return entry ? `/${entry.name}${entry.args ? ` ${t(entry.args)}` : ''} · ${t(entry.description)}` : t("F6 opens available commands and tools.");
+}
+
+/** Cursor and replacement ranges use grapheme indices, exactly like Composer.
+ * Suggestions only apply to a slash command at the start of the draft. Ranges
+ * replace the entire token (including text after the cursor), preserving all
+ * other text. No filesystem paths or arbitrary JSON contents are completed.
+ */
+export function commandSuggestions(text, cursor = graphemes(text).length, context = {}) {
+  text = String(text); const buffer = graphemes(text);
+  cursor = Number.isInteger(cursor) ? Math.max(0, Math.min(cursor, buffer.length)) : buffer.length;
+  const empty = { start: cursor, end: cursor, items: [], hint: '', source: text };
+  const first = buffer.findIndex(atom => !/\s/u.test(atom));
+  if (first < 0 || buffer[first] !== '/' || cursor <= first || buffer.slice(first, cursor).some(atom => atom === '\n')) return empty;
+  let start = cursor, end = cursor;
+  while (start > first && !/\s/u.test(buffer[start - 1])) start--;
+  while (end < buffer.length && !/\s/u.test(buffer[end])) end++;
+  const before = buffer.slice(first, start).join(''), prefix = buffer.slice(start, cursor).join('');
+  let candidates, hint;
+  if (!before) {
+    candidates = commandCatalog(context).filter(item => item.kind !== 'tool');
+    hint = 'Tab completa · ↑/↓ elige · Esc cierra';
+  } else {
+    const words = before.trim().split(/\s+/u), command = words.shift().slice(1);
+    candidates = argumentItems(command, [...words, prefix], context);
+    hint = syntaxHint(command, context);
+  }
+  const term = prefix.toLocaleLowerCase('es');
+  const items = unique(candidates).filter(item => token(item.value.trim()) && item.value.toLocaleLowerCase('es').startsWith(term));
+  // Command values include a convenience space, but replacing an existing token
+  // before whitespace must not introduce duplicate separators.
+  return { start, end, source: text, hint, items: items.map(item => ({ ...item, value: end < buffer.length && /\s/u.test(buffer[end]) ? item.value.trimEnd() : item.value })) };
+}
+
+/** Rejects stale/forged ranges and candidates rather than corrupting the draft.
+ * Returns a new value; the caller decides whether to insert it. Never submits.
+ */
+export function applySuggestion(text, result, item) {
+  text = String(text); const buffer = graphemes(text);
+  if (!result || result.source !== text || !Number.isInteger(result.start) || !Number.isInteger(result.end) || result.start < 0 || result.end < result.start || result.end > buffer.length || !result.items?.some(candidate => candidate.value === item?.value) || typeof item?.value !== 'string' || /[\x00-\x1f\x7f-\x9f]/u.test(item.value)) throw new Error(t("The suggestion changed; select it again."));
+  const inserted = graphemes(item.value);
+  return { text: [...buffer.slice(0, result.start), ...inserted, ...buffer.slice(result.end)].join(''), cursor: result.start + inserted.length };
+}
+
+/** One stable, contextual hint; no timed rotation, extra output, or tool calls. */
+export function contextualTip(text = '', context = {}) {
+  if (context.selecting) return t("Select and copy with your terminal · F5 or Esc returns.");
+  if (context.editingQueue) return t("Editing a queued message · Enter saves · Esc keeps the original.");
+  if (context.queue?.paused) return t("Queue paused · F4 to review and resume it.");
+  if (context.queue?.interrupted?.length) return t("Interrupted messages · F4 lets you review them before retrying.");
+  if (String(text).trimStart().startsWith('/')) return commandSuggestions(String(text), graphemes(String(text)).length, context).hint;
+  if (context.busy) return t("You can keep typing · Enter queues · Esc interrupts the turn.");
+  if (String(text).includes('\n')) return t("Multiline message · Enter sends · Ctrl+G opens your editor.");
+  if (context.mode === 'plan') return t("Plan mode: inspection without changes · Shift+Tab switches mode.");
+  return t("F6 discovers commands and tools · / autocompletes · Ctrl+G opens your editor.");
+}

package/src/tui/input.mjs

@@ -0,0 +1,60 @@
+import { PassThrough } from 'node:stream';
+import { emitKeypressEvents } from 'node:readline';
+import { StringDecoder } from 'node:string_decoder';
+
+// Pasted newlines are text, never Enter or permission answers.
+export class TerminalInput {
+  constructor({ onKey, onPaste, onMouse = () => {}, onError = () => {} }) {
+    this.decoder = new StringDecoder('utf8'); this.buffer = ''; this.pasting = false; this.paste = ''; this.onPaste = onPaste; this.onError = onError;
+    this.mouseBuffer = ''; this.onMouse = onMouse;
+    // Node defaults to 500 ms: Esc followed by Ctrl+U would become an Alt chord.
+    this.keys = new PassThrough(); emitKeypressEvents(this.keys, { escapeCodeTimeout: 35 }); this.keys.on('keypress', onKey);
+  }
+  feed(chunk) {
+    clearTimeout(this.timer); this.buffer += typeof chunk === 'string' ? chunk : this.decoder.write(chunk);
+    const start = '\x1b[200~', end = '\x1b[201~';
+    while (this.buffer) {
+      const marker = this.pasting ? end : start, at = this.buffer.indexOf(marker);
+      if (at >= 0) {
+        const prefix = this.buffer.slice(0, at); this.buffer = this.buffer.slice(at + marker.length);
+        if (this.pasting) { this.paste += prefix; if (this.paste.length <= 1024 * 1024) this.onPaste(this.paste); else this.onError(new Error('Pegado mayor a 1 MiB.')); this.paste = ''; this.pasting = false; }
+        else { if (prefix) this.writeKeys(prefix); this.pasting = true; }
+        continue;
+      }
+      let retained = 0;
+      for (let count = 1; count < marker.length; count++) if (this.buffer.endsWith(marker.slice(0, count))) retained = count;
+      const ready = this.buffer.slice(0, this.buffer.length - retained);
+      this.buffer = retained ? this.buffer.slice(-retained) : '';
+      if (this.pasting) { this.paste += ready; if (this.paste.length > 1024 * 1024) this.paste = this.paste.slice(0, 1024 * 1024 + 1); }
+      else if (ready) this.writeKeys(ready);
+      break;
+    }
+    if (this.buffer && !this.pasting) this.timer = setTimeout(() => { this.writeKeys(this.buffer); this.buffer = ''; }, 30);
+  }
+  // Mouse reports must never become keystrokes or permission answers. Paste is
+  // handled above, so identical bytes inside bracketed paste remain literal text.
+  writeKeys(value) {
+    let text = this.mouseBuffer + value; this.mouseBuffer = '';
+    while (text) {
+      const at = text.indexOf('\x1b[<');
+      if (at < 0) { this.keys.write(text); return; }
+      if (at) this.keys.write(text.slice(0, at));
+      text = text.slice(at);
+      const match = /^\x1b\[<(\d{1,8});(\d{1,8});(\d{1,8})([Mm])/.exec(text);
+      if (!match) {
+        if (/^\x1b\[<[\d;]*$/.test(text) && text.length <= 64) { this.mouseBuffer = text; return; }
+        // Discard malformed reports as a unit; do not insert their coordinates.
+        const end = /^\x1b\[<[^\x1b]*?[Mm]/.exec(text);
+        const next = text.indexOf('\x1b', 3);
+        text = end ? text.slice(end[0].length) : next >= 0 ? text.slice(next) : '';
+        continue;
+      }
+      text = text.slice(match[0].length);
+      const button = Number(match[1]), x = Number(match[2]), y = Number(match[3]);
+      if (button > 255 || x < 1 || y < 1) continue;
+      const wheel = (button & 192) === 64 && !(button & 32) && (button & 3) < 2;
+      if (wheel && match[4] === 'M') this.onMouse({ type: 'wheel', delta: (button & 1) ? 1 : -1, x, y, shift: Boolean(button & 4), meta: Boolean(button & 8), ctrl: Boolean(button & 16) });
+    }
+  }
+  close() { clearTimeout(this.timer); this.keys.destroy(); }
+}

package/src/tui/markdown.mjs

@@ -0,0 +1,127 @@
+import { t } from '../i18n/index.mjs';
+import { Marked } from 'marked';
+import { safeText, tone, wrap, width, pad, clip } from './text.mjs';
+
+const lexer = new Marked({ gfm: true, breaks: false });
+const entities = text => text.replace(/&#x([\da-f]+);|&#(\d+);|&(amp|lt|gt|quot|apos);/gi, (all, hex, dec, name) => {
+  if (hex || dec) { const code = parseInt(hex || dec, hex ? 16 : 10); return code <= 0x10ffff ? String.fromCodePoint(code) : all; }
+  return { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" }[name];
+});
+function inline(tokens = []) {
+  return tokens.map(token => {
+    const text = token.tokens ? inline(token.tokens) : safeText(entities(token.text || token.raw || ''));
+    if (token.type === 'strong') return tone.bold(text);
+    if (token.type === 'em') return `\x1b[3m${text}\x1b[0m`;
+    if (token.type === 'del') return `\x1b[9m${text}\x1b[0m`;
+    if (token.type === 'codespan') return tone.accent(text);
+    if (token.type === 'br') return '\n';
+    if (token.type === 'link') return tone.accent(text) + (token.href && token.href !== token.text ? tone.muted(` (${safeText(token.href)})`) : '');
+    if (token.type === 'image') return t("[image: {v0}]", {v0: text});
+    return text;
+  }).join('');
+}
+
+export class DataTableParser {
+  parse(text, format = 'markdown') {
+    text = safeText(text, { preserveTabs: true });
+    if (format === 'json') {
+      const parsed = JSON.parse(text), data = Array.isArray(parsed) ? parsed : parsed.data;
+      if (!Array.isArray(data) || !data.every(row => row && typeof row === 'object' && !Array.isArray(row))) throw new Error(t("The JSON table requires a list of objects, or {data: [...]}."));
+      const headers = [...new Set(data.flatMap(row => Object.keys(row)))];
+      return { headers, rows: data.map(row => headers.map(key => typeof row[key] === 'object' && row[key] !== null ? JSON.stringify(row[key]) : String(row[key] ?? ''))) };
+    }
+    if (format === 'csv' || format === 'tsv') {
+      const rows = delimited(text, format === 'tsv' ? '\t' : ',');
+      return { headers: rows[0] || [], rows: rows.slice(1) };
+    }
+    const table = lexer.lexer(text).find(token => token.type === 'table');
+    if (!table) throw new Error(t("No Markdown table found."));
+    return { headers: table.header.map(cell => inline(cell.tokens)), rows: table.rows.map(row => row.map(cell => inline(cell.tokens))), align: table.align };
+  }
+  render({ headers, rows, align = [] }, columns) {
+    if (!headers.length) return [tone.muted(t("(empty table)"))];
+    if (headers.length > 24 || rows.length > 10000) throw new Error(t("Table too large: maximum 24 columns and 10000 rows."));
+    const shown = rows.slice(0, 200).map(row => headers.map((_, i) => safeText(row[i] ?? '')));
+    headers = headers.map(safeText);
+    const available = columns - (headers.length + 1) - headers.length * 2;
+    if (available < headers.length * 3) {
+      const output = [];
+      shown.forEach((row, index) => { output.push(tone.muted(t("── Row {v0} ──", {v0: index + 1}))); row.forEach((value, i) => output.push(...wrap(`${tone.bold(headers[i])}: ${value}`, columns))); });
+      if (rows.length > 200) output.push(tone.muted(t("… {v0} additional rows", {v0: rows.length - 200})));
+      return output.map(line => clip(line, columns));
+    }
+    const sizes = headers.map((header, i) => Math.max(3, Math.min(32, width(header), available)));
+    for (let i = 0; i < sizes.length; i++) sizes[i] = Math.max(sizes[i], ...shown.map(row => Math.min(32, Math.max(...row[i].split('\n').map(width)))));
+    while (sizes.reduce((sum, n) => sum + n, 0) > available) { const largest = sizes.indexOf(Math.max(...sizes)); if (sizes[largest] <= 3) break; sizes[largest]--; }
+    const border = (left, middle, right) => tone.muted(left + sizes.map(n => '─'.repeat(n + 2)).join(middle) + right);
+    const output = [border('┌', '┬', '┐')];
+    const renderRow = (row, header = false) => {
+      const cells = row.map((cell, i) => wrap(cell, sizes[i])); const height = Math.max(...cells.map(lines => lines.length));
+      for (let line = 0; line < height; line++) {
+        const values = cells.map((lines, i) => {
+          const cell = lines[line] || '', missing = Math.max(0, sizes[i] - width(cell));
+          const value = align[i] === 'right' ? ' '.repeat(missing) + cell : align[i] === 'center' ? ' '.repeat(Math.floor(missing / 2)) + cell + ' '.repeat(Math.ceil(missing / 2)) : pad(cell, sizes[i]);
+          return ' ' + (header ? tone.bold(value) : value) + ' ';
+        });
+        output.push(tone.muted('│') + values.join(tone.muted('│')) + tone.muted('│'));
+      }
+    };
+    renderRow(headers, true); output.push(border('├', '┼', '┤'));
+    for (const row of shown) renderRow(row);
+    output.push(border('└', '┴', '┘'));
+    if (rows.length > shown.length) output.push(tone.muted(t("… {v0} additional rows", {v0: rows.length - shown.length})));
+    return output.map(line => clip(line, columns));
+  }
+}
+
+function delimited(text, separator) {
+  const rows = []; let row = [], cell = '', quoted = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quoted) {
+      if (c === '"' && text[i + 1] === '"') { cell += '"'; i++; }
+      else if (c === '"') quoted = false;
+      else cell += c;
+    } else if (c === '"' && !cell) quoted = true;
+    else if (c === separator) { row.push(cell); cell = ''; }
+    else if (c === '\n') { row.push(cell); rows.push(row); row = []; cell = ''; }
+    else cell += c;
+  }
+  if (quoted) throw new Error(t("CSV/TSV has an incomplete quoted cell."));
+  if (cell || row.length) { row.push(cell); rows.push(row); }
+  return rows;
+}
+
+export class MarkdownRenderer {
+  constructor() { this.tables = new DataTableParser(); }
+  render(text, columns) {
+    columns = Math.max(8, columns);
+    const tokens = lexer.lexer(safeText(text)); const output = [];
+    const visit = (items, indent = '') => {
+      for (const token of items) {
+        const room = Math.max(4, columns - width(indent));
+        if (token.type === 'space' || token.type === 'def') { if (output.at(-1)) output.push(''); }
+        else if (token.type === 'heading') output.push(...wrap(tone.accent(tone.bold(inline(token.tokens))), room).map(line => indent + line), '');
+        else if (token.type === 'code') {
+          output.push(indent + tone.muted(`╭─ ${token.lang || 'code'}`));
+          for (const line of token.text.split('\n')) output.push(...wrap(safeText(line) || ' ', room - 2).map(row => indent + tone.muted('│ ') + tone.accent(row)));
+          output.push(indent + tone.muted('╰' + '─'.repeat(Math.min(room - 1, 35))), '');
+        } else if (token.type === 'table') {
+          const data = { headers: token.header.map(cell => inline(cell.tokens)), rows: token.rows.map(row => row.map(cell => inline(cell.tokens))), align: token.align };
+          output.push(...this.tables.render(data, room).map(line => indent + line), '');
+        } else if (token.type === 'blockquote') visit(token.tokens, indent + tone.muted('│ '));
+        else if (token.type === 'list') {
+          token.items.forEach((item, i) => {
+            const bullet = item.task ? item.checked ? '☑ ' : '☐ ' : token.ordered ? `${Number(token.start) + i}. ` : '• ';
+            const rendered = this.render(item.text, room - width(bullet));
+            rendered.forEach((line, j) => output.push(indent + (j === 0 ? tone.accent(bullet) : ' '.repeat(width(bullet))) + line));
+          }); output.push('');
+        } else if (token.type === 'hr') output.push(indent + tone.muted('─'.repeat(room)));
+        else output.push(...wrap(token.tokens ? inline(token.tokens) : safeText(entities(token.text || token.raw || '')), room).map(line => indent + line));
+      }
+    };
+    visit(tokens);
+    while (output.at(-1) === '') output.pop();
+    return output.map(line => clip(line, columns));
+  }
+}

package/src/tui/message-queue.mjs

@@ -0,0 +1,74 @@
+import { t } from '../i18n/index.mjs';
+import { randomUUID, createHash } from 'node:crypto';
+import { isRemoteCommand } from '../remote-commands.mjs';
+
+export class MessageQueue {
+  constructor(snapshot, persist = async () => {}) {
+    this.persist = persist; this.items = snapshot?.items || []; this.running = null;
+    this.interrupted = [...(snapshot?.interrupted || []), ...(snapshot?.running ? [snapshot.running] : [])];
+    this.paused = Boolean(snapshot?.paused || this.items.length || this.interrupted.length);
+    this.remoteAdmissions = snapshot?.remoteAdmissions || {};
+    this.remoteWriter = Promise.resolve();
+  }
+  snapshot() { return structuredClone({ items: this.items, running: this.running, interrupted: this.interrupted, paused: this.paused, remoteAdmissions: this.remoteAdmissions }); }
+  async save() { await this.persist(this.snapshot()); }
+  validate(text, excludeId) {
+    if (!text.trim()) throw new Error(t("The message is empty."));
+    if (this.items.length >= 32 && !excludeId) throw new Error(t("The queue supports up to 32 messages."));
+    const bytes = Buffer.byteLength(text) + this.items.filter(i => i.id !== excludeId).reduce((sum, i) => sum + Buffer.byteLength(i.text), 0);
+    if (bytes > 1024 * 1024) throw new Error(t("The queue supports up to 1 MiB of text."));
+  }
+  async enqueue(text, attachments = []) {
+    this.validate(text); if (!Array.isArray(attachments) || attachments.length > 2 || Buffer.byteLength(JSON.stringify(attachments)) > 32768) throw new Error('Invalid image attachment metadata.');
+    const item = { id: randomUUID(), text, ...(attachments.length ? {attachments: structuredClone(attachments)} : {}), createdAt: new Date().toISOString() };
+    this.items.push(item);
+    try { await this.save(); } catch (e) { this.items = this.items.filter(i => i.id !== item.id); throw e; }
+    return item;
+  }
+  enqueueRemote(text, remote) {
+    const action = this.remoteWriter.catch(() => {}).then(async () => {
+      if (!remote || !/^[a-f0-9]{32}$/.test(remote.session) || !/^[A-Za-z0-9_-]{8,128}$/.test(remote.request) || Buffer.byteLength(text)>16384 || text.trimStart().startsWith('/') && !isRemoteCommand(text)) throw new Error('Remote input must be plain text or an admitted remote command.');
+      const key=remote.session+':'+remote.request, digest=createHash('sha256').update(JSON.stringify([remote.session,remote.request,text])).digest('hex'), previous=this.remoteAdmissions[key];
+      if(previous){if(previous.digest!==digest)throw new Error('Remote request ID already names another message.');return {id:previous.id,duplicate:true};}
+      if(Object.keys(this.remoteAdmissions).length>=2048)throw new Error('Remote admission history is full. Start a new local session.');
+      this.validate(text);const item={id:randomUUID(),text,remote:{...remote},createdAt:new Date().toISOString()};
+      this.items.push(item);this.remoteAdmissions[key]={id:item.id,digest};
+      try{await this.save();}catch(error){this.items=this.items.filter(i=>i.id!==item.id);delete this.remoteAdmissions[key];throw error;}
+      return item;
+    });
+    this.remoteWriter=action;return action;
+  }
+  async take() {
+    if (this.paused || !this.items.length || this.running) return null;
+    const item = this.items.shift(); this.running = item;
+    try { await this.save(); } catch (e) { this.items.unshift(item); this.running = null; throw e; }
+    return item;
+  }
+  async finish(error = false) { this.running = null; if (error) this.paused = true; await this.save(); }
+  async defer() { if (this.running) { this.items.unshift(this.running); this.running = null; await this.save(); } }
+  async update(id, text, attachments) { this.validate(text, id); if (attachments !== undefined && (!Array.isArray(attachments) || attachments.length > 2 || Buffer.byteLength(JSON.stringify(attachments)) > 32768)) throw new Error('Invalid image attachment metadata.'); const item = this.items.find(i => i.id === id); if (!item) throw new Error(t("That message is no longer in queue.")); const old = item.text, oldAttachments = item.attachments; item.text = text; if (attachments !== undefined) item.attachments = structuredClone(attachments); try { await this.save(); } catch (e) { item.text = old; item.attachments = oldAttachments; throw e; } }
+  async remove(id) { this.items = this.items.filter(i => i.id !== id); await this.save(); }
+  async move(id, delta) { const index = this.items.findIndex(i => i.id === id), next = index + delta; if (index < 0 || next < 0 || next >= this.items.length) return; const [item] = this.items.splice(index, 1); this.items.splice(next, 0, item); await this.save(); }
+  async setPaused(paused) { this.paused = paused; await this.save(); }
+  async clear() { this.items = []; this.interrupted = []; await this.save(); }
+  async retryInterrupted(id) { const item = this.interrupted.find(i => i.id === id); if (!item) return; await this.enqueue(item.text, item.attachments); this.interrupted = this.interrupted.filter(i => i.id !== id); await this.save(); }
+}
+
+export class QueueRunner {
+  constructor(queue, execute, { blocked = () => false, onChange = () => {}, onError = () => {} } = {}) { Object.assign(this, { queue, execute, blocked, onChange, onError }); this.processing = null; this.stopped = false; }
+  kick() {
+    if (this.processing || this.stopped || this.blocked() || this.queue.paused || !this.queue.items.length) return this.processing;
+    this.processing = (async () => {
+      while (!this.stopped && !this.blocked() && !this.queue.paused && this.queue.items.length) {
+        const item = await this.queue.take(); if (!item) break;
+        // Input can pause/close the app while the pending state is being fsynced.
+        if (this.stopped || this.blocked() || this.queue.paused) { await this.queue.defer(); this.onChange(); break; }
+        this.onChange(); let error = false;
+        try { error = Boolean(await this.execute(item)); } catch (e) { error = true; this.onError(e); }
+        await this.queue.finish(error); this.onChange();
+      }
+    })().catch(error => { this.queue.paused = true; this.onError(error); }).finally(() => { this.processing = null; this.onChange(); });
+    return this.processing;
+  }
+  async stop() { this.stopped = true; await this.processing; }
+}