@milpa/comal 0.1.6 → 0.2.0

package/src/tui/present.mjs

@@ -0,0 +1,504 @@
+// Presentación legible de resultados estructurados para la terminal.
+// Solo presenta: nunca cambia el valor recibido, no traduce datos (solo las
+// etiquetas que escribe el host) y sanea todo texto externo antes de pintarlo.
+// El JSON exacto sigue disponible con /raw (o «r» en la tarjeta de permiso).
+import { t, languageInfo, formatNumber, registerMessages } from '../i18n/index.mjs';
+import { DataTableParser } from './markdown.mjs';
+import { safeText, stripANSI, createTones, tone as globalTone, wrap, width, clip, pad, graphemes } from './text.mjs';
+
+registerMessages({
+  'yes': 'sí', 'no': 'no', 'none': 'ninguno', '(empty)': '(vacío)', '(no fields)': '(sin campos)',
+  '… ({v0} more)': '… ({v0} más)', '… ({v0} more lines)': '… ({v0} líneas más)', '… ({v0} more characters)': '… ({v0} caracteres más)',
+  '{v0} fields': '{v0} campos', '{v0} items': '{v0} elementos', 'Other fields: {v0}': 'Otros campos: {v0}',
+  '/raw shows the exact JSON': '/raw muestra el JSON exacto', 'exact JSON': 'JSON exacto',
+  'Raw view on: results and permissions show the exact JSON. /raw returns to the readable view.': 'Vista cruda activada: resultados y permisos muestran el JSON exacto. /raw vuelve a la vista legible.',
+  'Readable view on. /raw shows the exact JSON again.': 'Vista legible activada. /raw vuelve a mostrar el JSON exacto.',
+  'Use /raw without arguments.': 'Usa /raw sin argumentos.',
+  'Toggle the exact JSON of results and permissions': 'Alterna el JSON exacto de resultados y permisos',
+  ' · r shows JSON': ' · r muestra el JSON', ' · r readable view': ' · r vista legible',
+  'Summary declared by the operation (the arguments below are what runs):': 'Resumen declarado por la operación (lo que se ejecuta son los argumentos de abajo):',
+  'Contains control characters, shown as \\u{…}.': 'Contiene caracteres de control, mostrados como \\u{…}.',
+  '{v0} lines · {v1}': '{v0} líneas · {v1}', 'Replace {v0} lines with {v1} lines': 'Reemplaza {v0} líneas por {v1} líneas',
+  'all occurrences': 'todas las apariciones', 'Removed': 'Sale', 'Added': 'Entra',
+  '{v0} tokens': '{v0} tokens', 'levels {v0}': 'niveles {v0}', 'source {v0}': 'origen {v0}', 'announced {v0}': 'anunciada {v0}', 'limit {v0}': 'límite {v0}',
+  '{v0} returned · {v1} failed · {v2} refused': '{v0} devueltas · {v1} fallidas · {v2} rechazadas',
+  'Receipts ({v0})': 'Recibos ({v0})', 'Plugins ({v0})': 'Plugins ({v0})', '{v0} operations': '{v0} operaciones',
+  'Digests and complete receipts: /raw': 'Huellas y recibos completos: /raw', 'built-in': 'integrado', 'local': 'local', 'core': 'núcleo',
+  'F6 → Tab shows each operation with its description and arguments.': 'F6 → Tab muestra cada operación con su descripción y argumentos.',
+  'Ctrl+O expands lists and long texts.': 'Ctrl+O amplía listas y textos largos.',
+});
+
+// Etiquetas frecuentes en español. Solo se aplican a etiquetas derivadas de
+// claves; los valores nunca se traducen.
+const LABELS_ES = Object.freeze({
+  'Status': 'Estado', 'State': 'Estado', 'Version': 'Versión', 'Model': 'Modelo', 'Operations': 'Operaciones', 'Operation': 'Operación',
+  'Services': 'Servicios', 'Browser': 'Navegador', 'Extensions': 'Extensiones', 'Remote root': 'Raíz remota', 'Connection ID': 'ID de conexión',
+  'Protocol version': 'Versión del protocolo', 'Extension commands': 'Comandos de extensión', 'SSH host': 'Host SSH', 'Can deploy': 'Puede desplegar',
+  'Console collection': 'Captura de consola', 'Other extensions count': 'Otras extensiones', 'Extensions truncated': 'Extensiones recortadas',
+  'Browser endpoint ID': 'ID del endpoint del navegador', 'Config path': 'Configuración', 'Context budget': 'Presupuesto de contexto',
+  'Context window': 'Ventana de contexto', 'Announced window': 'Ventana anunciada', 'Configured limit': 'Límite configurado', 'Kind': 'Tipo',
+  'Source': 'Origen', 'Description': 'Descripción', 'Name': 'Nombre', 'Effects': 'Efectos', 'Audience': 'Audiencia', 'Origin': 'Procedencia', 'Trust': 'Confianza',
+  'Counts': 'Conteos', 'Receipts': 'Recibos', 'Unresolved': 'Sin resolver', 'Running': 'En curso', 'Error': 'Error', 'Code': 'Código',
+  'Details': 'Detalles', 'Message': 'Mensaje', 'Path': 'Ruta', 'File path': 'Archivo', 'Command': 'Comando', 'Content': 'Contenido',
+  'Timeout': 'Tiempo límite', 'Verified': 'Verificado', 'Violations': 'Violaciones', 'Returned': 'Devueltas', 'Failed': 'Fallidas',
+  'Refused': 'Rechazadas', 'Label': 'Etiqueta', 'Method': 'Método', 'Protocol': 'Protocolo', 'Subscription': 'Suscripción',
+  'Profiles': 'Perfiles', 'Default profile': 'Perfil por omisión', 'Login providers': 'Proveedores de acceso', 'Documentation': 'Documentación',
+  'Active calls': 'Llamadas activas', 'Tool loading': 'Carga', 'Builtin': 'Integrado', 'Requires': 'Requiere', 'Provides': 'Provee',
+  'External': 'Externo', 'Process': 'Proceso', 'Authority': 'Autoridad', 'Capabilities': 'Capacidades', 'Effort': 'Esfuerzo',
+  'Levels': 'Niveles', 'Selected': 'Elegido', 'Supported': 'Soportado', 'Timestamp': 'Fecha', 'Cards': 'Tarjetas', 'Next action': 'Siguiente acción',
+  'Pattern': 'Patrón', 'Query': 'Consulta', 'Executions': 'Ejecuciones', 'Asked': 'Juicio', 'Permission refusals': 'Permisos rechazados',
+  'Actor': 'Actor', 'Plugin': 'Plugin', 'Calls': 'Llamadas', 'Loading': 'Carga', 'Sources': 'Fuentes', 'Scope': 'Alcance', 'Plan': 'Plan',
+  'Rule': 'Regla', 'List': 'Lista', 'Warning': 'Advertencia', 'Effect': 'Efecto', 'Note': 'Nota', 'Allow': 'Autorizar', 'Still ask': 'Siguen preguntando',
+  'Changed': 'Cambios', 'Module': 'Módulo', 'Project': 'Proyecto', 'Files': 'Archivos', 'Code fingerprint': 'Huella del código', 'Uncovered packages': 'Paquetes sin cubrir',
+  'Replace all': 'Reemplazar todas', 'Offset': 'Desde', 'Limit': 'Límite', 'Recent': 'Recientes', 'Text': 'Texto', 'Result': 'Resultado',
+});
+const ACRONYMS = new Map([['id', 'ID'], ['ids', 'IDs'], ['url', 'URL'], ['uri', 'URI'], ['cdp', 'CDP'], ['ssh', 'SSH'], ['api', 'API'], ['mcp', 'MCP'],
+  ['json', 'JSON'], ['pid', 'PID'], ['uuid', 'UUID'], ['sha256', 'SHA-256'], ['cpu', 'CPU'], ['dom', 'DOM'], ['http', 'HTTP'], ['tui', 'TUI'],
+  ['cli', 'CLI'], ['llm', 'LLM'], ['os', 'OS'], ['ui', 'UI'], ['html', 'HTML'], ['css', 'CSS']]);
+
+const LIMITS = Object.freeze({
+  normal: Object.freeze({ items: 12, rows: 20, lines: 6, chars: 600, depth: 4, fields: 60, textLines: 400 }),
+  expanded: Object.freeze({ items: 500, rows: 500, lines: 200, chars: 20000, depth: 8, fields: 500, textLines: 5000 }),
+});
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})$/;
+const DIGEST = /^(?:sha256:)?[0-9a-f]{40,128}$/i;
+const DURATION_KEY = /(?:_ms|Ms)$|^ms$|^timeout$/;
+const BYTES_KEY = /(?:bytes|Bytes|_size|Size)$|^size$/;
+const EPOCH_KEY = /(?:_at|At|timestamp|Timestamp)$/;
+const PLAIN_NUMBER_KEY = /(?:^|_)(?:pid|port|id|row|sequence|version|year|start)$|(?:Id|Port|Row)$/i;
+const MAX_PARSE = 4_000_000;
+
+// Texto visible: en las tarjetas de permiso un carácter de control no se borra
+// en silencio (cambiaría lo que el humano cree aprobar); se muestra escapado.
+const INVISIBLE = /[\x00-\x08\x0b-\x1f\x7f-\x9f\u200b-\u200f\u2028\u2029\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff]/g;
+export function visibleText(value) {
+  return String(value ?? '').replace(/\t/g, '    ').replace(INVISIBLE, char => `\\u{${char.codePointAt(0).toString(16)}}`);
+}
+const INVISIBLE_TEST = new RegExp(INVISIBLE.source);
+// Recorre claves y valores (acotado) buscando caracteres invisibles o de control.
+function containsInvisible(value, depth = 0, budget = { nodes: 20000 }) {
+  if (--budget.nodes < 0 || depth > 32) return false;
+  if (typeof value === 'string') return INVISIBLE_TEST.test(value);
+  if (Array.isArray(value)) return value.some(item => containsInvisible(item, depth + 1, budget));
+  if (value && typeof value === 'object') return Object.entries(value).some(([key, item]) => INVISIBLE_TEST.test(key) || containsInvisible(item, depth + 1, budget));
+  return false;
+}
+
+function options(input = {}) {
+  const expanded = Boolean(input.expanded), limits = { ...(expanded ? LIMITS.expanded : LIMITS.normal), ...(input.limits || {}) };
+  const tones = input.color === false ? createTones({ colorMode: 'none' }) : globalTone;
+  return { columns: Math.max(4, Math.floor(input.columns || 80)), expanded, limits, tones, color: input.color !== false,
+    sanitize: input.sanitize || safeText, now: input.now ?? Date.now(), timeZone: input.timeZone };
+}
+const plain = value => value !== null && typeof value === 'object' && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+const isScalar = value => value === null || value === undefined || ['string', 'number', 'boolean', 'bigint'].includes(typeof value);
+const more = (n, o) => o.tones.muted(t('… ({v0} more)', { v0: formatNumber(n) }));
+
+export function humanizeKey(key, sanitize = safeText) {
+  const raw = sanitize(String(key)).replace(/\s+/g, ' ').trim();
+  const words = raw.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2').replace(/[_.\-]+/g, ' ').trim().split(/\s+/).filter(Boolean);
+  if (!words.length) return raw || '—';
+  const text = words.map((word, index) => {
+    const known = ACRONYMS.get(word.toLowerCase()); if (known) return known;
+    if (/^[A-Z0-9]{2,}$/.test(word)) return word;
+    const lower = word.toLowerCase(); return index === 0 ? lower.charAt(0).toUpperCase() + lower.slice(1) : lower;
+  }).join(' ');
+  return languageInfo().language === 'es' ? LABELS_ES[text] || text : text;
+}
+
+export function formatDuration(ms) {
+  const value = Math.abs(Number(ms)), sign = ms < 0 ? '-' : '';
+  if (!Number.isFinite(value)) return String(ms);
+  if (value < 1000) return `${sign}${formatNumber(Math.round(value))} ms`;
+  if (value < 60000) return `${sign}${formatNumber(value / 1000, { maximumFractionDigits: 1 })} s`;
+  if (value < 3600000) { const m = Math.floor(value / 60000), s = Math.round((value % 60000) / 1000); return `${sign}${m} min${s ? ` ${s} s` : ''}`; }
+  const h = Math.floor(value / 3600000), m = Math.round((value % 3600000) / 60000); return `${sign}${formatNumber(h)} h${m ? ` ${m} min` : ''}`;
+}
+export function formatBytes(bytes) {
+  const value = Number(bytes); if (!Number.isFinite(value)) return String(bytes);
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']; let size = Math.abs(value), unit = 0;
+  while (size >= 1024 && unit < units.length - 1) { size /= 1024; unit++; }
+  return `${value < 0 ? '-' : ''}${formatNumber(size, { maximumFractionDigits: unit ? 1 : 0 })} ${units[unit]}`;
+}
+export function formatDate(value, { now = Date.now(), timeZone, compact = false } = {}) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) return String(value);
+  const language = languageInfo().language;
+  let absolute;
+  try { absolute = new Intl.DateTimeFormat(language, { dateStyle: 'medium', timeStyle: 'medium', ...(timeZone ? { timeZone } : {}) }).format(date); }
+  catch { absolute = date.toISOString(); }
+  const seconds = Math.round((date.getTime() - now) / 1000), size = Math.abs(seconds);
+  if (compact && (!Number.isFinite(seconds) || size >= 86400)) { try { return new Intl.DateTimeFormat(language, { dateStyle: 'short', timeStyle: 'short', ...(timeZone ? { timeZone } : {}) }).format(date); } catch { return absolute; } }
+  if (!Number.isFinite(seconds) || size > 30 * 86400) return absolute;
+  const [amount, unit] = size < 60 ? [seconds, 'second'] : size < 3600 ? [Math.round(seconds / 60), 'minute'] : size < 86400 ? [Math.round(seconds / 3600), 'hour'] : [Math.round(seconds / 86400), 'day'];
+  const relative = new Intl.RelativeTimeFormat(language, { numeric: 'auto' }).format(amount, unit);
+  return compact ? relative : `${absolute} (${relative})`;
+}
+
+// Escalares en texto plano + un tono semántico; las tablas usan solo el texto.
+function scalar(value, key, o) {
+  key = String(key || '');
+  if (value === null || value === undefined) return { text: '—', kind: 'muted' };
+  if (typeof value === 'boolean') return { text: value ? t('yes') : t('no'), kind: value ? 'good' : 'muted' };
+  if (typeof value === 'bigint') return { text: value.toString(), kind: 'text' };
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) return { text: String(value), kind: 'text' };
+    if (DURATION_KEY.test(key)) return { text: formatDuration(value), kind: 'text' };
+    if (BYTES_KEY.test(key)) return { text: formatBytes(value), kind: 'text' };
+    if (EPOCH_KEY.test(key) && value > 1e11 && value < 1e14) return { text: formatDate(value, o), kind: 'text' };
+    return { text: PLAIN_NUMBER_KEY.test(key) || !Number.isInteger(value) && Math.abs(value) < 1 ? String(value) : formatNumber(value), kind: 'text' };
+  }
+  const text = o.sanitize(value);
+  if (!text) return { text: t('(empty)'), kind: 'muted' };
+  if (ISO_DATE.test(text)) return { text: formatDate(text, o), kind: 'text' };
+  if (DIGEST.test(text) && !o.expanded) return { text: text.replace(/^sha256:/, '').slice(0, 12) + '…', kind: 'muted' };
+  return { text, kind: 'text' };
+}
+const paint = (item, o) => item.kind === 'text' ? item.text : o.tones[item.kind](item.text);
+
+// Recorta por caracteres y por líneas con indicador «… (N más)».
+function textBlock(item, columns, o) {
+  let text = item.text; const glyphs = graphemes(text), extra = glyphs.length - o.limits.chars;
+  if (extra > 0) text = glyphs.slice(0, o.limits.chars).join('');
+  let lines = wrap(text, Math.max(1, columns));
+  const hidden = lines.length - o.limits.lines;
+  if (hidden > 0) lines = lines.slice(0, o.limits.lines);
+  lines = lines.map(line => paint({ ...item, text: line }, o));
+  if (hidden > 0) lines.push(o.tones.muted(t('… ({v0} more lines)', { v0: formatNumber(hidden) })));
+  else if (extra > 0) lines.push(o.tones.muted(t('… ({v0} more characters)', { v0: formatNumber(extra) })));
+  return lines;
+}
+
+function inlineList(values, key, o) {
+  const shown = values.slice(0, o.limits.items).map(value => scalar(value, key, o).text);
+  return shown.join(', ') + (values.length > shown.length ? ' ' + t('… ({v0} more)', { v0: formatNumber(values.length - shown.length) }) : '');
+}
+// Un valor cabe en línea si es escalar, vacío o una lista corta de escalares.
+function inline(value, key, o, depth, room) {
+  if (isScalar(value)) return scalar(value, key, o);
+  if (Array.isArray(value)) {
+    if (!value.length) return { text: t('none'), kind: 'muted' };
+    if (value.every(isScalar)) { const text = inlineList(value, key, o); if (!text.includes('\n') && width(text) <= room * 3) return { text, kind: 'text' }; }
+    if (depth >= o.limits.depth) return { text: t('{v0} items', { v0: formatNumber(value.length) }), kind: 'muted' };
+    return null;
+  }
+  if (plain(value) || typeof value === 'object') {
+    const keys = Object.keys(value);
+    if (!keys.length) return { text: '—', kind: 'muted' };
+    if (depth >= o.limits.depth) return { text: t('{v0} fields', { v0: formatNumber(keys.length) }), kind: 'muted' };
+    return null;
+  }
+  return { text: o.sanitize(String(value)), kind: 'text' };
+}
+
+function errorShaped(value) {
+  return plain(value) && (typeof value.error === 'string' && value.error || typeof value.message === 'string' && (value.code !== undefined || value.is_error === true || value.details !== undefined));
+}
+export function presentError(error, input = {}) {
+  const o = options(input), message = typeof error === 'string' ? error : error?.message || (typeof error?.error === 'string' ? error.error : '') || String(error);
+  const lines = wrap(o.tones.bad('✗ ' + o.sanitize(message)), o.columns);
+  const rest = {};
+  if (error && typeof error === 'object') {
+    if (error.code !== undefined) rest.code = error.code;
+    if (error.details !== undefined) rest.details = error.details;
+    for (const [key, value] of Object.entries(error)) if (!['message', 'error', 'code', 'details', 'stack', 'is_error'].includes(key) && value !== undefined) rest[key] = value;
+  }
+  if (Object.keys(rest).length) lines.push(...objectLines(rest, o, 0));
+  return lines.map(line => clip(line, o.columns));
+}
+
+function objectLines(object, o, depth) {
+  const entries = Object.entries(object).filter(([, value]) => value !== undefined);
+  if (!entries.length) return [o.tones.muted(t('(no fields)'))];
+  const shown = entries.slice(0, o.limits.fields), labels = shown.map(([key]) => humanizeKey(key, o.sanitize));
+  const labelWidth = Math.max(4, Math.min(Math.max(...labels.map(width)) + 1, 28, Math.floor(o.columns * 0.4)));
+  const valueColumn = labelWidth + 2, room = o.columns - valueColumn, narrow = room < 16, output = [];
+  shown.forEach(([key, value], index) => {
+    const label = width(labels[index]) + 1 > labelWidth ? clip(labels[index], labelWidth - 1, '…') + ':' : labels[index] + ':';
+    const item = inline(value, key, o, depth, narrow ? o.columns - 2 : room);
+    if (!item) {
+      output.push(o.tones.bold(label));
+      output.push(...valueLines(value, key, { ...o, columns: o.columns - 2 }, depth + 1).map(line => '  ' + line));
+      return;
+    }
+    if (narrow) { output.push(label, ...textBlock(item, o.columns - 2, o).map(line => '  ' + line)); return; }
+    const parts = textBlock(item, room, o);
+    output.push(pad(label, valueColumn) + parts[0], ...parts.slice(1).map(line => ' '.repeat(valueColumn) + line));
+  });
+  if (entries.length > shown.length) output.push(more(entries.length - shown.length, o));
+  return output;
+}
+
+function cell(value, key, o) {
+  let text;
+  if (isScalar(value)) text = scalar(value, key, { ...o, compact: true }).text;
+  else if (Array.isArray(value)) text = !value.length ? '—' : value.every(isScalar) ? (value.slice(0, 5).map(item => scalar(item, key, o).text).join(', ') + (value.length > 5 ? ` +${value.length - 5}` : '')) : t('{v0} items', { v0: formatNumber(value.length) });
+  else if (value && typeof value === 'object') {
+    const parts = Object.entries(value).filter(([, item]) => isScalar(item) && item !== null && item !== 'none' && item !== false).map(([name, item]) => `${o.sanitize(name)}=${scalar(item, name, o).text}`);
+    text = parts.length ? parts.join(' ') : '—';
+  } else text = o.sanitize(String(value));
+  return clip(text.replace(/\s*\n\s*/g, ' ⏎ '), 60, '…');
+}
+const PRIORITY = ['name', 'id', 'operation', 'label', 'title', 'type', 'kind', 'status', 'state'];
+const rank = key => { const index = PRIORITY.indexOf(String(key).toLowerCase()); return index < 0 ? PRIORITY.length : index; };
+
+function tableLines(rows, o, { keys: wanted } = {}) {
+  const order = [], frequency = new Map();
+  for (const row of rows) for (const key of Object.keys(row)) { if (!frequency.has(key)) order.push(key); frequency.set(key, (frequency.get(key) || 0) + 1); }
+  const shared = wanted || order.filter(key => frequency.get(key) >= Math.ceil(rows.length / 2));
+  const coverage = rows.reduce((sum, row) => { const keys = Object.keys(row); return sum + (keys.length ? keys.filter(key => shared.includes(key)).length / keys.length : 1); }, 0) / rows.length;
+  if (!shared.length || !wanted && coverage < 0.5) return null;
+  const tableable = key => rows.some(row => row[key] !== undefined && (isScalar(row[key]) || Array.isArray(row[key]) && row[key].every(isScalar) || plain(row[key])));
+  let candidates = shared.filter(tableable);
+  if (!wanted) {
+    const nonDigest = candidates.filter(key => !/digest|sha256|hash$/i.test(key) && !rows.every(row => typeof row[key] === 'string' && DIGEST.test(row[key])));
+    if (nonDigest.length) candidates = nonDigest;
+    candidates = [...candidates].sort((a, b) => rank(a) - rank(b) || order.indexOf(a) - order.indexOf(b));
+  }
+  if (!candidates.length) return null;
+  const maxColumns = Math.max(1, Math.min(6, Math.floor((o.columns - 1) / 11)));
+  const chosen = candidates.slice(0, maxColumns), shownRows = rows.slice(0, o.limits.rows);
+  if (chosen.length === 1) {
+    const key = chosen[0], lines = shownRows.map(row => '• ' + cell(row[key], key, o));
+    if (rows.length > shownRows.length) lines.push(more(rows.length - shownRows.length, o));
+    const others = order.filter(item => item !== key);
+    if (others.length) lines.push(...wrap(o.tones.muted(t('Other fields: {v0}', { v0: others.map(item => humanizeKey(item, o.sanitize)).join(', ') })), o.columns));
+    return lines;
+  }
+  const data = { headers: chosen.map(key => humanizeKey(key, o.sanitize)), rows: shownRows.map(row => chosen.map(key => cell(row[key], key, o))) };
+  const lines = new DataTableParser().render(data, o.columns);
+  if (rows.length > shownRows.length) lines.push(more(rows.length - shownRows.length, o));
+  const hidden = order.filter(key => !chosen.includes(key));
+  if (hidden.length) lines.push(...wrap(o.tones.muted(t('Other fields: {v0}', { v0: hidden.map(key => humanizeKey(key, o.sanitize)).join(', ') })), o.columns));
+  return lines;
+}
+
+function arrayLines(array, key, o, depth) {
+  if (!array.length) return [o.tones.muted(t('none'))];
+  if (array.every(isScalar)) {
+    const shown = array.slice(0, o.limits.items), output = [];
+    for (const value of shown) { const parts = textBlock(scalar(value, key, o), o.columns - 2, o); output.push('• ' + parts[0], ...parts.slice(1).map(line => '  ' + line)); }
+    if (array.length > shown.length) output.push(more(array.length - shown.length, o));
+    return output;
+  }
+  if (array.every(plain)) { const table = tableLines(array, o); if (table) return table; }
+  const shown = array.slice(0, o.limits.rows), output = [];
+  shown.forEach((value, index) => {
+    const marker = `${index + 1}.`, indent = ' '.repeat(width(marker) + 1);
+    if (isScalar(value)) { const parts = textBlock(scalar(value, key, o), o.columns - indent.length, o); output.push(o.tones.muted(marker) + ' ' + parts[0], ...parts.slice(1).map(line => indent + line)); return; }
+    const lines = valueLines(value, key, { ...o, columns: o.columns - indent.length }, depth + 1);
+    output.push(o.tones.muted(marker) + ' ' + (lines[0] ?? ''), ...lines.slice(1).map(line => indent + line));
+  });
+  if (array.length > shown.length) output.push(more(array.length - shown.length, o));
+  return output;
+}
+
+function valueLines(value, key, o, depth = 0) {
+  if (isScalar(value)) return textBlock(scalar(value, key, o), o.columns, o);
+  if (Array.isArray(value)) return depth > o.limits.depth ? [o.tones.muted(t('{v0} items', { v0: formatNumber(value.length) }))] : arrayLines(value, key, o, depth);
+  if (depth > o.limits.depth) return [o.tones.muted(t('{v0} fields', { v0: formatNumber(Object.keys(value).length) }))];
+  if (depth === 0 && errorShaped(value)) return presentError(value, { ...o, color: o.color });
+  return objectLines(value, o, depth);
+}
+
+const finish = (lines, o) => lines.map(line => clip(o.color ? line : stripANSI(line), o.columns));
+
+/** Valor estructurado → líneas de terminal, todas de ancho ≤ columns. */
+export function presentValue(value, input = {}) {
+  const o = options(input);
+  return finish(valueLines(value, '', o, 0), o);
+}
+
+export function parseStructured(text) {
+  if (typeof text !== 'string') return text !== null && typeof text === 'object' ? { ok: true, value: text } : { ok: false };
+  const trimmed = text.trim();
+  if (trimmed.length > MAX_PARSE || !/^[[{]/.test(trimmed)) return { ok: false };
+  try { const value = JSON.parse(trimmed); return value !== null && typeof value === 'object' ? { ok: true, value } : { ok: false }; } catch { return { ok: false }; }
+}
+
+// Texto que ya viene en «Etiqueta: valor» (p. ej. /status) se alinea; lo que
+// ya está alineado a mano (/config) o es prosa se deja tal cual.
+const LABEL_LINE = /^([^\s:][^:]{0,31}): (\S.*)$/;
+function textLines(text, o) {
+  const clean = o.sanitize(text), source = clean.split('\n');
+  const nonEmpty = source.filter(line => line.trim()), matched = source.filter(line => LABEL_LINE.test(line));
+  const align = matched.length >= 2 && matched.length >= nonEmpty.length * 0.6;
+  const labelWidth = align ? Math.min(28, Math.floor(o.columns * 0.4), Math.max(...matched.map(line => width(LABEL_LINE.exec(line)[1]) + 1))) : 0;
+  const output = [];
+  for (const line of source) {
+    const match = align && LABEL_LINE.exec(line);
+    if (match && width(match[1]) + 1 <= labelWidth && o.columns - labelWidth - 2 >= 16) {
+      const parts = wrap(match[2], o.columns - labelWidth - 2);
+      output.push(pad(match[1] + ':', labelWidth + 2) + parts[0], ...parts.slice(1).map(part => ' '.repeat(labelWidth + 2) + part));
+    } else output.push(...wrap(line, o.columns));
+  }
+  if (output.length > o.limits.textLines) { const hidden = output.length - o.limits.textLines; output.length = o.limits.textLines; output.push(o.tones.muted(t('… ({v0} more lines)', { v0: formatNumber(hidden) }))); }
+  return output;
+}
+
+/** Texto de salida (JSON o no) → { lines, structured }. */
+export function presentOutput(text, input = {}) {
+  const o = options(input), parsed = parseStructured(text);
+  if (parsed.ok) return { lines: finish(valueLines(parsed.value, '', o, 0), o), structured: true, value: parsed.value };
+  return { lines: finish(textLines(String(text ?? ''), o), o), structured: false };
+}
+
+// ── Presentadores específicos de comandos ──────────────────────────────────
+function section(title, o) { return o.tones.bold(o.sanitize(title)); }
+
+function presentCapabilities(value, o) {
+  if (!plain(value) || !('model' in value)) return null;
+  const { model, contextBudget, capabilities, provenance = {}, effort, source, ...rest } = value, summary = { model };
+  if (plain(contextBudget)) {
+    const window = contextBudget.contextWindow, parts = [Number.isFinite(window) ? t('{v0} tokens', { v0: formatNumber(window) }) : '—'];
+    if (contextBudget.source || contextBudget.kind) parts.push(o.sanitize(contextBudget.source || contextBudget.kind));
+    if (contextBudget.announcedWindow != null) parts.push(t('announced {v0}', { v0: formatNumber(contextBudget.announcedWindow) }));
+    if (contextBudget.configuredLimit != null) parts.push(t('limit {v0}', { v0: formatNumber(contextBudget.configuredLimit) }));
+    summary.context_window = parts.join(' · ');
+  }
+  if (plain(capabilities)) summary.capabilities = Object.entries(capabilities).map(([name, supported]) => `${supported === true ? '✓' : supported === false ? '✗' : '?'} ${humanizeKey(name, o.sanitize).toLowerCase()}${provenance?.[name]?.kind ? ` (${o.sanitize(provenance[name].kind)})` : ''}`).join(' · ');
+  if (plain(effort)) summary.effort = [o.sanitize(effort.selected || 'auto'), Array.isArray(effort.levels) ? t('levels {v0}', { v0: effort.levels.map(item => o.sanitize(item)).join(', ') }) : null, effort.source ? t('source {v0}', { v0: o.sanitize(effort.source) }) : null].filter(Boolean).join(' · ');
+  if (Array.isArray(source)) summary.sources = source;
+  if (!plain(contextBudget) && contextBudget !== undefined) rest.context_budget = contextBudget;
+  return objectLines({ ...summary, ...rest }, o, 0);
+}
+
+function presentPlugins(value, o) {
+  if (!plain(value) || !Array.isArray(value.plugins)) return null;
+  const { plugins, ...rest } = value, output = Object.keys(rest).length ? [...objectLines(rest, o, 1), ''] : [];
+  output.push(section(t('Plugins ({v0})', { v0: plugins.length }), o));
+  if (!plugins.length) { output.push(o.tones.muted(t('none'))); return output; }
+  const rows = plugins.map(item => plain(item) ? {
+    plugin: item.id, version: item.version, state: item.state, operations: Array.isArray(item.operations) ? item.operations.length : item.operations,
+    loading: item.tool_loading, calls: item.active_calls, origin: item.builtin ? t('built-in') : t('local'),
+    trust: item.builtin ? undefined : item.trust?.status ?? item.trust,
+  } : { plugin: item });
+  output.push(...(tableLines(rows, o, { keys: ['plugin', 'state', 'version', 'operations', 'origin', 'trust', 'loading', 'calls'] }) || arrayLines(plugins, 'plugins', o, 1)));
+  for (const item of plugins) if (plain(item) && (item.error || item.warning)) output.push(...wrap(o.tones[item.error ? 'bad' : 'warning'](`${item.error ? '✗' : '!'} ${o.sanitize(item.id)}: ${o.sanitize(item.error || item.warning)}`), o.columns));
+  return output;
+}
+
+function presentHouse(value, o) {
+  if (!plain(value) || !Array.isArray(value.receipts)) return null;
+  const { counts, receipts, scope, ...rest } = value, summary = {};
+  for (const key of ['status', 'asked']) if (rest[key] !== undefined) { summary[key] = rest[key]; delete rest[key]; }
+  if (plain(counts)) summary.executions = t('{v0} returned · {v1} failed · {v2} refused', { v0: formatNumber(counts.returned || 0), v1: formatNumber(counts.failed || 0), v2: formatNumber(counts.refused || 0) });
+  const output = objectLines({ ...summary, ...rest }, o, 1);
+  output.push('', section(t('Receipts ({v0})', { v0: receipts.length }), o));
+  if (!receipts.length) output.push(o.tones.muted(t('none')));
+  else {
+    const rows = receipts.map(item => plain(item) ? { operation: item.operation, status: item.status, authority: item.authority, actor: item.actor?.kind || item.actor?.id, timestamp: item.timestamp } : { operation: item });
+    output.push(...(tableLines(rows, o, { keys: ['operation', 'status', 'authority', 'actor', 'timestamp'] }) || []));
+  }
+  output.push(o.tones.muted(t('Digests and complete receipts: /raw')));
+  return output;
+}
+
+function presentOperations(value, o) {
+  if (!Array.isArray(value) || !value.every(item => plain(item) && typeof item.name === 'string')) return null;
+  const rows = value.map(item => ({ name: item.name, effects: item.effects, audience: item.audience, origin: item.origin?.plugin || item.origin?.server || item.origin?.kind || t('core') }));
+  const wide = { ...o, limits: { ...o.limits, rows: Math.max(o.limits.rows, 100) } };
+  return [section(t('{v0} operations', { v0: value.length }), o), ...(tableLines(rows, wide, { keys: ['name', 'effects', 'audience', 'origin'] }) || []), o.tones.muted(t('F6 → Tab shows each operation with its description and arguments.'))];
+}
+
+const COMMAND_PRESENTERS = Object.freeze({
+  capabilities: presentCapabilities,
+  plugins: (value, o, arg) => /^(?:status|list)?$/.test(arg.trim()) ? presentPlugins(value, o) : null,
+  house: presentHouse,
+  operations: presentOperations,
+});
+
+/** Salida de un comando de barra → { lines, structured }. Nunca lanza. */
+export function presentCommand(command, arg, output, input = {}) {
+  const o = options(input), parsed = parseStructured(output);
+  if (parsed.ok) {
+    const specific = COMMAND_PRESENTERS[command];
+    if (specific) { try { const lines = specific(parsed.value, o, String(arg || '')); if (lines) return { lines: finish(lines, o), structured: true }; } catch { /* cae al genérico */ } }
+  }
+  return presentOutput(output, input);
+}
+/** Para -p con salida texto en una terminal: texto sin ANSI. */
+export function presentCommandText(command, arg, output, input = {}) {
+  return presentCommand(command, arg, output, { ...input, color: false }).lines.join('\n');
+}
+
+// Vista cruda: el texto original, sin perder nada; si es JSON, con sangría.
+export function rawLines(text, columns, sanitize = safeText) {
+  const parsed = parseStructured(text);
+  const source = parsed.ok && typeof text === 'string' ? JSON.stringify(parsed.value, null, 2) : typeof text === 'string' ? text : JSON.stringify(text, null, 2) ?? String(text);
+  return wrap(sanitize(source), Math.max(1, columns));
+}
+
+/** Bloque de resultado de comando en la TUI: encabezado, cuerpo y pista /raw. */
+export function presentResultBlock(block, { columns = 80, raw = false, expanded = false } = {}) {
+  const o = options({ columns, expanded }), title = `▸ /${safeText(block.command)}${block.arg ? ' ' + safeText(block.arg) : ''}`;
+  if (raw) return [o.tones.accent(clip(title, columns - 14)) + o.tones.muted(' · ' + t('exact JSON')), ...rawLines(block.text, columns - 2).map(line => '  ' + line)];
+  const presented = presentCommand(block.command, block.arg || '', block.text, { columns: columns - 2, expanded });
+  const lines = [o.tones.accent(clip(title, columns)), ...presented.lines.map(line => '  ' + line)];
+  if (presented.structured) lines.push('  ' + o.tones.muted(clip(t('/raw shows the exact JSON') + (expanded ? '' : ' · ' + t('Ctrl+O expands lists and long texts.')), columns - 2)));
+  return lines;
+}
+
+function toolOutputText(output) {
+  if (typeof output === 'string') return output;
+  if (Array.isArray(output)) return output.map(part => part?.type === 'text' ? String(part.text ?? '') : `[${safeText(part?.type || '?')}]`).join('\n');
+  return JSON.stringify(output) ?? String(output);
+}
+/** Detalle de un bloque de herramienta (Ctrl+O o error). */
+export function presentToolBlock(block, { columns = 80, raw = false, expanded = true } = {}) {
+  const hasOutput = block.output !== undefined && block.output !== null && block.output !== '';
+  const o = options({ columns, expanded });
+  if (raw || !hasOutput && !plain(block.input)) {
+    const text = hasOutput ? toolOutputText(block.output) : JSON.stringify(block.input) ?? '';
+    return wrap(safeText(text).slice(0, 6000), columns).map(line => o.tones.muted(line));
+  }
+  if (!hasOutput) return presentValue(block.input, { columns, expanded });
+  const text = toolOutputText(block.output), parsed = parseStructured(text);
+  if (parsed.ok) return presentValue(parsed.value, { columns, expanded });
+  const clean = safeText(text), cut = clean.length > 6000;
+  const lines = wrap(cut ? clean.slice(0, 6000) : clean, columns).map(line => o.tones.muted(line));
+  if (cut) lines.push(o.tones.muted(t('… ({v0} more characters)', { v0: formatNumber(clean.length - 6000) })));
+  return lines;
+}
+
+// ── Tarjeta de permiso ─────────────────────────────────────────────────────
+const PREVIEW_LINES = 12;
+const lineCount = text => text ? String(text).split('\n').length : 0;
+function preview(text, prefix, o, toneName) {
+  const lines = String(text ?? '').split('\n'), shown = lines.slice(0, PREVIEW_LINES), output = [];
+  for (const line of shown) output.push(...wrap(prefix + visibleText(line), o.columns).map(row => toneName ? o.tones[toneName](row) : row));
+  if (lines.length > shown.length) output.push(o.tones.muted(t('… ({v0} more lines)', { v0: formatNumber(lines.length - shown.length) })));
+  return output;
+}
+const baseName = name => String(name || '').split('__').at(-1);
+
+/**
+ * Argumentos de una confirmación en legible. `summary` es opcional y debe venir
+ * del host o de la definición de la operación (p. ej. un futuro
+ * `confirm_summary(input)` de plugin), nunca de la entrada del modelo; aun con
+ * resumen, los argumentos reales se muestran debajo.
+ */
+export function presentPermission(name, input, { summary, columns = 80, raw = false } = {}) {
+  const o = options({ columns, expanded: true, sanitize: visibleText });
+  if (raw) return wrap(visibleText(JSON.stringify(input, null, 2) ?? String(input)), o.columns);
+  const output = [];
+  if (typeof summary === 'string' && summary.trim()) output.push(o.tones.accent(t('Summary declared by the operation (the arguments below are what runs):')), ...wrap(visibleText(summary.trim()), o.columns - 2).map(line => '  ' + line), '');
+  if (containsInvisible(input) || typeof summary === 'string' && INVISIBLE_TEST.test(summary)) output.push(o.tones.warning('! ' + t('Contains control characters, shown as \\u{…}.')));
+  const tool = baseName(name);
+  if (plain(input) && tool === 'Write' && typeof input.content === 'string') {
+    const { file_path, content, ...rest } = input;
+    output.push(...objectLines({ ...(file_path !== undefined ? { file_path } : {}), content: t('{v0} lines · {v1}', { v0: formatNumber(lineCount(content)), v1: formatBytes(Buffer.byteLength(content)) }), ...rest }, o, 1));
+    output.push('', ...preview(content, '│ ', o));
+  } else if (plain(input) && tool === 'Edit' && typeof input.old_string === 'string' && typeof input.new_string === 'string') {
+    const { file_path, old_string, new_string, replace_all, ...rest } = input;
+    output.push(...objectLines({ ...(file_path !== undefined ? { file_path } : {}), change: t('Replace {v0} lines with {v1} lines', { v0: formatNumber(lineCount(old_string)), v1: formatNumber(lineCount(new_string)) }) + (replace_all ? ' · ' + t('all occurrences') : ''), ...rest }, o, 1));
+    output.push('', o.tones.muted(t('Removed')), ...preview(old_string, '- ', o, 'bad'), o.tones.muted(t('Added')), ...preview(new_string, '+ ', o, 'good'));
+  } else if (plain(input) && tool === 'Bash' && typeof input.command === 'string') {
+    // El comando completo, siempre: es exactamente lo que se aprueba.
+    const { command, ...rest } = input;
+    output.push(o.tones.bold(humanizeKey('command') + ':'), ...command.split('\n').flatMap((line, index) => wrap((index ? '  ' : '$ ') + visibleText(line), o.columns)));
+    if (Object.keys(rest).length) output.push(...objectLines(rest, o, 1));
+  } else if (plain(input)) output.push(...(Object.keys(input).length ? objectLines(input, o, 0) : [o.tones.muted(t('(no fields)'))]));
+  else output.push(...valueLines(input, '', o, 0));
+  return output.map(line => clip(line, o.columns));
+}