@milpa/comal 0.2.2 → 0.2.3

package/src/relay/cards.mjs

@@ -0,0 +1,702 @@
+import { t, registerMessages, formatNumber } from '../i18n/index.mjs';
+
+// Tarjetas de /relay: funciones puras que convierten datos (del hub, de relayd y del repo)
+// en {title, description, items, keys, hint} para TerminalScreen.setupChoice. Son del
+// HUMANO: el modelo no las ve ni las puede contestar. Todo texto que viene de los agentes
+// (resúmenes, títulos, preguntas) se marca como no confiable y se acota; la pantalla vuelve
+// a limpiarlo (safeText) al pintarlo.
+// Revisor de open-relay (F7): criterios de éxito, escalaciones, plan revisado y veredicto final.
+registerMessages({
+  'Success criteria · {swarm}': 'Criterios de éxito · {swarm}',
+  // open-relay v2.33: criterios con su cita del enunciado.
+  'Review before accepting ({n})': 'Revisa antes de aceptar ({n})',
+  '  ⚠ {id}: asks more than the statement: «{beyond}»': '  ⚠ {id}: exige más que el enunciado: «{beyond}»',
+  '  ⚠ {id}: the quote is not in {source}: «{quote}»': '  ⚠ {id}: la cita no aparece en {source}: «{quote}»',
+  '  ○ {id}: no quote from the statement': '  ○ {id}: sin cita del enunciado',
+  '     quote ({source}): «{quote}»': '     cita ({source}): «{quote}»',
+  '     quote ({source}, not found): «{quote}»': '     cita ({source}, no aparece): «{quote}»',
+  '     beyond the statement: «{beyond}»': '     además del enunciado: «{beyond}»',
+  'asks more than the statement': 'exige más que el enunciado',
+  'quote not found': 'cita que no aparece',
+  'no quote': 'sin cita',
+  'Accept with {n} warnings': 'Aceptar con {n} avisos',
+  'criteria.accept with this digest despite the warnings above.': 'criteria.accept con este digest pese a los avisos de arriba.',
+  'Enter rejects with a reason · accepting asks for confirmation · PgUp/PgDn · Esc later': 'Enter rechaza con un motivo · aceptar pide confirmación · PgUp/PgDn · Esc más tarde',
+  'Asks for confirmation first.': 'Antes pide confirmación.',
+  'Accept with {n} warnings? · {swarm}': '¿Aceptar con {n} avisos? · {swarm}',
+  'The lead plans against these criteria and the reviewer judges with them, warnings included.': 'El líder planea contra estos criterios y el revisor juzga con ellos, avisos incluidos.',
+  'Go back without accepting': 'Volver sin aceptar',
+  '/relay shows the criteria again.': '/relay vuelve a mostrar los criterios.',
+  'Accept anyway': 'Aceptar de todos modos',
+  'Enter goes back · ↓ then Enter accepts': 'Enter vuelve · ↓ y Enter acepta',
+  'Reviewer     {runtime} · {model} · eyes {eyes} · {share} % of the budget (if you start with it)': 'Revisor      {runtime} · {model} · ojos {eyes} · {share} % del presupuesto (si arrancas con él)',
+  'Start with an independent reviewer': 'Arrancar con revisor independiente',
+  'A second agent writes the success criteria, reviews the plan and judges each result with evidence before it closes. You accept the criteria and the plan.': 'Un segundo agente redacta los criterios de éxito, revisa el plan y juzga cada resultado con evidencia antes de cerrarlo. Tú aceptas los criterios y el plan.',
+  'Start without reviewer': 'Arrancar sin revisor',
+  'Version {version} by {author} · agent text, untrusted': 'Versión {version} de {author} · texto de agentes, no confiable',
+  'Mid-swarm renegotiation: v{version} stays in force until you accept this one; reviews in progress then restart with it and approved tasks stay done.': 'Renegociación a medio swarm: la v{version} sigue vigente hasta que aceptes esta; las revisiones en curso se repiten entonces con ella y las tareas aprobadas siguen hechas.',
+  'Reopen the success criteria of {swarm}': 'Reabrir los criterios de éxito de {swarm}',
+  'Why reopen the criteria': 'Por qué reabrir los criterios',
+  'The reviewer is woken up with exactly this text and proposes a new version; v{version} stays in force until you accept the new one.': 'El revisor despierta con este texto exacto y propone otra versión; la v{version} sigue vigente hasta que aceptes la nueva.',
+  'Success criteria of {swarm} reopened ({status}); the reviewer got your reason.': 'Criterios de éxito de {swarm} reabiertos ({status}); el revisor recibió tu motivo.',
+  'The lead endorses it: the reviewer wrote it, the lead agrees it is feasible.': 'El líder la respalda: la redactó el revisor y el líder la considera viable.',
+  'The lead objected {n} times (rounds exhausted): you decide over the objection.': 'El líder objetó {n} veces (rondas agotadas): decides tú sobre la objeción.',
+  'Lead objection (v{version}): «{reasons}»': 'Objeción del líder (v{version}): «{reasons}»',
+  'Automatic (a check proves them)': 'Automáticos (los prueba un check)',
+  'Judgment (the reviewer decides with evidence)': 'De juicio (los decide el revisor con evidencia)',
+  '     evidence: {evidence}{viewports}': '     evidencia: {evidence}{viewports}',
+  ' · viewports {viewports}': ' · viewports {viewports}',
+  'Out of scope': 'Fuera de alcance',
+  'Design: {files}': 'Diseño: {files}',
+  'Accepting fixes this version (digest {digest}…): the lead plans against it and the reviewer judges with it.': 'Aceptar fija esta versión (digest {digest}…): el líder planea con ella y el revisor juzga con ella.',
+  'Accept': 'Aceptar',
+  'criteria.accept with this digest; the lead can propose the plan.': 'criteria.accept con este digest; el líder ya puede proponer el plan.',
+  'The reviewer is woken up with your reason and proposes a new version.': 'El revisor despierta con tu motivo y propone una versión nueva.',
+  'Enter accepts · r rejects with a reason · PgUp/PgDn · Esc later': 'Enter acepta · r rechaza con un motivo · PgUp/PgDn · Esc más tarde',
+  'Reason for the reviewer': 'Motivo para el revisor',
+  'The reviewer is woken up with exactly this text and proposes again.': 'El revisor despierta con exactamente este texto y vuelve a proponer.',
+  'Review escalated · {task}': 'Revisión escalada · {task}',
+  'Task {task}{title} · {kind}': 'Tarea {task}{title} · {kind}',
+  'task review': 'revisión de tarea', 'integration review': 'revisión de integración', 'final review': 'revisión final',
+  'The reviewer objected {n} times (rounds exhausted): the candidate waits for you.': 'El revisor objetó {n} veces (rondas agotadas): el candidato te espera.',
+  'The review ended without a verdict (reviewer unavailable): the candidate waits for you.': 'La revisión terminó sin veredicto (revisor no disponible): el candidato te espera.',
+  'Last verdict (reviewer text, untrusted):': 'Último veredicto (texto del revisor, no confiable):',
+  '  · {id} FAIL: {why}': '  · {id} FAIL: {why}',
+  '  · correction {id} [{severity}{fixBy}]: {what}{where}': '  · corrección {id} [{severity}{fixBy}]: {what}{where}',
+  ' (in {where})': ' (en {where})',
+  'Notes: «{notes}»': 'Notas: «{notes}»',
+  'Accepting over the reviewer is recorded in relayd as your decision, with your reason. An integration is then applied to the branch; the final review closes the swarm.': 'Aceptar sobre el revisor queda en relayd como tu decisión, con tu motivo. Una integración se aplica entonces a la rama; la revisión final cierra el enjambre.',
+  'To cancel or revise the task: relay task cancel --task {task} (or task revise), in your terminal.': 'Para cancelar o revisar la tarea: relay task cancel --task {task} (o task revise), en tu terminal.',
+  'Accept over the objection': 'Aceptar sobre la objeción',
+  'review.override with your reason (recorded in relayd).': 'review.override con tu motivo (queda en relayd).',
+  'Enter accepts over the objection · Esc later': 'Enter acepta sobre la objeción · Esc más tarde',
+  'Ask for another review': 'Pedir otra revisión',
+  'One more round': 'Una ronda más',
+  'review.retry: the same candidate goes back to the reviewer, with your reason (recorded in relayd).': 'review.retry: el mismo candidato vuelve al revisor, con tu motivo (queda en relayd).',
+  'Enter chooses · ↑/↓ · Esc later': 'Enter elige · ↑/↓ · Esc más tarde',
+  'Why you accept over the reviewer': 'Por qué aceptas sobre el revisor',
+  'Recorded in relayd as your decision (review.override) with exactly this text.': 'Queda en relayd como tu decisión (review.override) con exactamente este texto.',
+  'Reviewer: endorses the plan.': 'Revisor: respalda el plan.',
+  'Reviewer: objected twice (rounds exhausted), you decide over it: «{reasons}»': 'Revisor: lo objetó dos veces (rondas agotadas), decides tú sobre la objeción: «{reasons}»',
+  'Reviewer: has not reviewed it yet.': 'Revisor: aún no lo revisó.',
+  'Correction plan of the reviewer for {task}: relayd approves it on its own.': 'Plan de corrección del revisor para {task}: relayd lo aprueba solo.',
+  '     covers: {criteria}': '     cubre: {criteria}',
+  '     corrects: {objections}': '     corrige: {objections}',
+  'Final review: approved by the reviewer ({n} criteria pass).': 'Revisión final: aprobada por el revisor ({n} criterios en pass).',
+  'Final review: accepted by you over the reviewer («{reason}»).': 'Revisión final: aceptada por ti sobre el revisor («{reason}»).',
+  'Reviewer evidence (metadata; the files stay in relayd):': 'Evidencia del revisor (metadatos; los archivos quedan en relayd):',
+  '  · {path} · {media} · {kib} KiB · b3 {hash}…': '  · {path} · {media} · {kib} KiB · b3 {hash}…',
+});
+
+registerMessages({
+  'New swarm project · {repo}': 'Proyecto de enjambre nuevo · {repo}',
+  'Project      {name} · {repo}': 'Proyecto     {name} · {repo}',
+  'Work branch  {branch} from {base} ({commit}) · created now; your working tree is not touched': 'Rama         {branch} desde {base} ({commit}) · se crea ahora; tu árbol de trabajo no se toca',
+  'Work branch  {branch} (already exists, it is used as is)': 'Rama         {branch} (ya existe: se usa tal cual)',
+  'Agents       {runtime} · {model} (lead: the same)': 'Agentes      {runtime} · {model} (líder: el mismo)',
+  // Ojos (host remoto con Chrome, evidencia del verificador)
+  'Eyes         {eyes}': 'Ojos         {eyes}',
+  'Eyes {eyes}': 'Ojos {eyes}',
+  '{host} · {chrome} · available': '{host} · {chrome} · disponible',
+  '{host} · {chrome} · not responding ({reason}, {time})': '{host} · {chrome} · no responde ({reason}, {time})',
+  'Chrome {version} (CDP {port} over ssh)': 'Chrome {version} (CDP {port} por ssh)',
+  '{host} · none': '{host} · ninguno',
+  '{host} · free': '{host} · libre',
+  '{host} · in use by {task}': '{host} · en uso por {task}',
+  '{host} · in use by {task} ({n} queued)': '{host} · en uso por {task} ({n} en cola)',
+  '{host} · not responding': '{host} · no responde',
+  'Eyes (verifier evidence):': 'Ojos (evidencia del verificador):',
+  '  · {task} · {check} {outcome} · capture {kib} KiB saved in {path}': '  · {task} · {check} {outcome} · captura {kib} KiB guardada en {path}',
+  '  · {task} · {check} {outcome}': '  · {task} · {check} {outcome}',
+  'Task blocked · {task}': 'Tarea bloqueada · {task}',
+  'Task {task} «{title}»': 'Tarea {task} «{title}»',
+  'The verifier could not run the check: the task stays blocked and nothing is retried on its own.': 'El verificador no pudo correr el check: la tarea sigue bloqueada y nada se reintenta solo.',
+  'Reason: {reason}': 'Motivo: {reason}',
+  'Check: {check}': 'Check: {check}',
+  'Blocked at {time}': 'Bloqueada a las {time}',
+  'Retry': 'Reintentar',
+  'The task stays blocked until the operator resumes it: nothing is retried on its own.': 'La tarea sigue bloqueada hasta que el operador la reanude: nada se reintenta solo.',
+  'Blocked: {why}': 'Bloqueo: {why}',
+  'Retry is the operator\'s (task.resume is never delegated to Comal): run it yourself, exactly: {command}': 'Reintentar es del operador (task.resume nunca se delega a Comal): ejecútalo tú, exactamente: {command}',
+  'Enter shows the exact command · Esc: later': 'Enter muestra el comando exacto · Esc: más tarde',
+  'Run it yourself, exactly: {command}': 'Ejecútalo tú, exactamente: {command}',
+  // Diseño de referencia (tarjeta de arranque, open-relay >= 2.12)
+  'Attach a reference design (image)': 'Adjuntar un diseño (imagen)',
+  'project.attach with the path of a local image; the lead and the agents read it in _relay/design/.': 'project.attach con la ruta de una imagen local; el líder y los agentes lo leen en _relay/design/.',
+  'Design       {file} ({size}) · the lead and the agents read it in `{mirror}`': 'Diseño       {file} ({size}) · el líder y los agentes lo leen en `{mirror}`',
+  'Checks       {checks}': 'Checks       {checks}',
+  'Budget       {budget} per swarm': 'Presupuesto  {budget} por enjambre',
+  'Excludes     {list}': 'Excluye      {list}',
+  'Web UI       http://127.0.0.1:{port}': 'UI web       http://127.0.0.1:{port}',
+  'The result always lands on {branch}; merging it is your decision.': 'El resultado siempre llega a {branch}; fusionarlo es tu decisión.',
+  'Notes: {notes}': 'Notas: {notes}',
+  'Create and start': 'Crear y arrancar',
+  'Creates the project in relay-hub and starts its relayd (systemd user unit).': 'Crea el proyecto en relay-hub y arranca su relayd (unidad de systemd de usuario).',
+  'Edit a field': 'Editar un campo',
+  'Name, base, model, checks, budget or excludes.': 'Nombre, base, modelo, checks, presupuesto o exclusiones.',
+  'Use the existing project {name}': 'Usar el proyecto existente {name}',
+  'Already in relay-hub for this repo ({state}).': 'Ya está en relay-hub para este repo ({state}).',
+  'Cancel': 'Cancelar',
+  'Nothing is created.': 'No se crea nada.',
+  'Enter creates and starts · e edits · ↑/↓ choose · Esc cancels': 'Enter crea y arranca · e edita · ↑/↓ elige · Esc cancela',
+  '{calls} calls · {tokens} tokens · {wall}': '{calls} llamadas · {tokens} tokens · {wall}',
+  '{n} h': '{n} h', '{n} min': '{n} min',
+  '(none)': '(ninguno)',
+  '… and {count} more': '… y {count} más',
+  // Confianza
+  'Connect Comal to the project {project}': 'Conectar Comal con el proyecto {project}',
+  'What you trust': 'Qué confías',
+  '  · The open-relay plugin bundled with Comal {version}, in this repo. It is asked again once per Comal version.': '  · El plugin open-relay incluido en Comal {version}, en este repo. Se vuelve a preguntar una vez por versión de Comal.',
+  '    Installed package {name}@{version} · integrity {integrity} (sha256 of its files).': '    Paquete instalado {name}@{version} · integridad {integrity} (sha256 de sus archivos).',
+  '    Development copy (not an installed package): code fingerprint {fingerprint}; asked again if the code changes.': '    Copia de desarrollo (no es un paquete instalado): huella del código {fingerprint}; se vuelve a preguntar si el código cambia.',
+  '  · The relayd of the project: {dir}': '  · El relayd del proyecto: {dir}',
+  'What Comal may do (relayd delegate session, {days} days, signed «operator via comal»)': 'Qué puede hacer Comal (sesión delegada de relayd, {days} días, firmada «operador vía comal»)',
+  '  · read      read the swarm: tasks, plans, messages, events (without asking)': '  · read      leer el enjambre: tareas, planes, mensajes, eventos (sin preguntar)',
+  '  · converse  answer the swarm questions (on a card of yours)': '  · converse  responder las preguntas del enjambre (en una tarjeta tuya)',
+  '  · plans     approve or reject plans (on a card of yours)': '  · plans     aprobar o rechazar planes (en una tarjeta tuya)',
+  '  · decide    record your decisions as ADRs (on a card of yours)': '  · decide    registrar tus decisiones como ADR (en una tarjeta tuya)',
+  'Never: starting swarms, creating projects, grants or budgets. Only you do that, with /relay; the model gets no tool for it.': 'Nunca: arrancar enjambres, crear proyectos, grants ni presupuestos. Eso sólo lo haces tú, con /relay; el modelo no recibe ninguna herramienta para ello.',
+  'The token stays in {file} (0600), outside the repo; Comal never uses admin.token.': 'El token queda en {file} (0600), fuera del repo; Comal nunca usa admin.token.',
+  'The previous delegation is no longer valid ({reason}): a new one is issued.': 'La delegación anterior ya no vale ({reason}): se emite una nueva.',
+  'Trust and connect': 'Confiar y conectar',
+  'Issues the delegation and enables the plugin for this repo.': 'Emite la delegación y activa el plugin para este repo.',
+  'Not now': 'Ahora no',
+  'Nothing is issued or enabled.': 'No se emite ni se activa nada.',
+  'Enter trusts and connects · Esc: not now': 'Enter confía y conecta · Esc: ahora no',
+  // Objetivo y arranque
+  'Swarm objective · {project}': 'Objetivo del enjambre · {project}',
+  'Say it in plain language: what should change and how you will know it is right. The lead ({lead}) turns it into a plan that you approve; nothing runs before that.': 'Dilo en lenguaje natural: qué debe cambiar y cómo sabrás que está bien. El líder ({lead}) lo convierte en un plan que tú apruebas; nada corre antes.',
+  'Start the swarm': 'Arrancar el enjambre',
+  'Objective    «{objective}»': 'Objetivo     «{objective}»',
+  '             (drafted by the model in the conversation: review it)': '             (lo redactó el modelo en la conversación: revísalo)',
+  'Lead         {runtime} · {model}': 'Líder        {runtime} · {model}',
+  'Budget       {budget}': 'Presupuesto  {budget}',
+  'Project      {project} · the result lands on {branch}': 'Proyecto     {project} · el resultado llega a {branch}',
+  'The lead reads the repo and proposes a plan: it shows up here as a card.': 'El líder lee el repo y propone un plan: aparecerá aquí como tarjeta.',
+  'Start': 'Arrancar',
+  'swarm.start in the relayd of the project, with this objective and budget.': 'swarm.start en el relayd del proyecto, con este objetivo y presupuesto.',
+  'Edit the objective': 'Editar el objetivo',
+  'Enter starts · e edits the objective · Esc cancels': 'Enter arranca · e edita el objetivo · Esc cancela',
+  // Plan
+  'Plan proposed · {swarm}': 'Plan propuesto · {swarm}',
+  'From {role} · {tasks} tasks · {roles} new roles · agent text, untrusted': 'De {role} · {tasks} tareas · {roles} roles nuevos · texto del agente, no confiable',
+  'Summary  «{summary}»': 'Resumen  «{summary}»',
+  'Roles': 'Roles',
+  'Tasks and how each one is checked': 'Tareas y cómo se comprueba cada una',
+  'Retires (cancels and stops requiring) {count}': 'Retira (cancela y deja de exigir) {count}',
+  ' · ⚠ retires {count} tasks': ' · ⚠ retira {count} tareas',
+  'On approval relayd cancels these {count} tasks and stops requiring them.': 'Al aprobar, relayd cancela estas {count} tareas y deja de exigirlas.',
+  '     files: {paths}': '     archivos: {paths}',
+  '     checked by: {checks}': '     se comprueba con: {checks}',
+  '     checked by: nothing declared (the task is not verified by a check)': '     se comprueba con: nada declarado (ningún check verifica la tarea)',
+  '     after: {deps}': '     después de: {deps}',
+  ' → {role} · up to {n} attempts': ' → {role} · hasta {n} intentos',
+  'On approval relayd creates the roles, grants and tasks at once (digest {digest}…).': 'Al aprobar, relayd crea los roles, grants y tareas en el acto (digest {digest}…).',
+  '⚠ relayd: {problem}': '⚠ relayd: {problem}',
+  'Approve': 'Aprobar',
+  'plan.approve with this digest; the swarm starts working.': 'plan.approve con este digest; el enjambre se pone a trabajar.',
+  'Reject with a reason': 'Rechazar con un motivo',
+  'The lead is woken up with your reason and proposes again.': 'El líder despierta con tu motivo y vuelve a proponer.',
+  'Later': 'Más tarde',
+  '/relay shows it again.': '/relay la vuelve a mostrar.',
+  'Enter approves · r rejects with a reason · PgUp/PgDn · Esc later': 'Enter aprueba · r rechaza con motivo · PgUp/PgDn · Esc más tarde',
+  // Pregunta
+  'Question from the swarm · {from}': 'Pregunta del enjambre · {from}',
+  'Question (agent text, untrusted): «{question}»': 'Pregunta (texto del agente, no confiable): «{question}»',
+  'Message (agent text, untrusted): «{body}»': 'Mensaje (texto del agente, no confiable): «{body}»',
+  'Blocks task {task}{title}': 'Bloquea la tarea {task}{title}',
+  'Agent recommendation: «{option}» — {why}': 'Recomendación del agente: «{option}» — {why}',
+  'Scope {scope} · reversible: {reversible} · cost of waiting: {cost}': 'Alcance {scope} · reversible: {reversible} · coste de esperar: {cost}',
+  'Your choice is recorded as an ADR in relayd and sent as the answer.': 'Tu elección queda como ADR en relayd y se envía como respuesta.',
+  'yes': 'sí', 'no': 'no', 'not stated': 'no indicado',
+  'recommended by the agent': 'la recomienda el agente',
+  'Answer with my own text': 'Responder con mi texto',
+  'msg.reply with the exact text you write.': 'msg.reply con el texto exacto que escribas.',
+  'Answer': 'Responder',
+  'Mark as read': 'Dar por leído',
+  'msg.ack: it stops being pending; nothing is answered.': 'msg.ack: deja de estar pendiente; no se responde nada.',
+  '↑/↓ choose an option · Enter answers · Esc later': '↑/↓ elige una opción · Enter responde · Esc más tarde',
+  // Final
+  'Result ready on {branch}': 'Resultado listo en {branch}',
+  'The swarm finished with problems · {branch}': 'El enjambre terminó con problemas · {branch}',
+  'Swarm {swarm} · «{objective}»': 'Enjambre {swarm} · «{objective}»',
+  'Tasks: {done} done · {failed} failed · {other} other': 'Tareas: {done} hechas · {failed} fallidas · {other} otras',
+  'Changes ({command}):': 'Cambios ({command}):',
+  '  (no changes on the branch yet)': '  (la rama aún no tiene cambios)',
+  'Merging is your decision: git merge {branch} (review it first with git diff {base}..{branch}).': 'Fusionarlo es tu decisión: git merge {branch} (revísalo antes con git diff {base}..{branch}).',
+  'Show the diff in the conversation': 'Ver el diff en la conversación',
+  'git diff of the branch, read-only.': 'git diff de la rama, sólo lectura.',
+  'Got it': 'Entendido',
+  'Nothing is merged.': 'No se fusiona nada.',
+  // Estado
+  'open-relay · {project}': 'open-relay · {project}',
+  'relayd {state} (unit {unit}) · UI {web}': 'relayd {state} (unidad {unit}) · UI {web}',
+  'Branch {branch} · repo {repo}': 'Rama {branch} · repo {repo}',
+  'Comal connected · delegation of {principal} · caps {caps}': 'Comal conectado · delegación de {principal} · caps {caps}',
+  'Comal is not connected to this project: {reason}': 'Comal no está conectado a este proyecto: {reason}',
+  'Swarms': 'Enjambres',
+  '  · {id} «{objective}» · {done}/{total} tasks done{waiting}': '  · {id} «{objective}» · {done}/{total} tareas hechas{waiting}',
+  ' · {n} waiting for you': ' · {n} para ti',
+  '  (no swarms yet)': '  (todavía no hay enjambres)',
+  'Review the plan {id}': 'Revisar el plan {id}',
+  'Answer {from}': 'Responder a {from}',
+  'New swarm': 'Nuevo enjambre',
+  'Write an objective and start it (start card).': 'Escribe un objetivo y arráncalo (tarjeta de arranque).',
+  'Live board (/swarm)': 'Tablero en vivo (/swarm)',
+  'Tasks, questions and plans, updated by events.wait.': 'Tareas, preguntas y planes, al día con events.wait.',
+  'Connect Comal': 'Conectar Comal',
+  'Trust card: plugin and delegation for this project.': 'Tarjeta de confianza: plugin y delegación para este proyecto.',
+  'Stop the project': 'Parar el proyecto',
+  'Stops its relayd (the unit); swarms and branch stay.': 'Para su relayd (la unidad); los enjambres y la rama se quedan.',
+  'Start the project': 'Arrancar el proyecto',
+  'Starts its relayd again.': 'Vuelve a arrancar su relayd.',
+  'Another project for this repo': 'Otro proyecto para este repo',
+  'Proposal card for a new project.': 'Tarjeta de propuesta de un proyecto nuevo.',
+  'Close': 'Cerrar',
+  'relayd running': 'en marcha', 'relayd stopped': 'parado',
+});
+
+const ONE = 160;
+const control = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f​-‏‪-‮⁦-⁩]/g;
+/** Una línea de texto ajeno, limpia y acotada. */
+export const line = (value, limit = ONE) => { const text = String(value ?? '').replace(control, ' ').replace(/\s+/g, ' ').trim(); const chars = [...text]; return chars.length > limit ? chars.slice(0, limit).join('') + '…' : text; };
+const short = (value, n = 12) => String(value || '').slice(0, n);
+const num = value => { const n = Number(value); return Number.isFinite(n) ? n : 0; };
+const tokens = value => { const n = num(value); return n >= 1e6 ? `${formatNumber(Math.round(n / 1e5) / 10)} M` : n >= 1e3 ? `${formatNumber(Math.round(n / 100) / 10)} k` : formatNumber(n); };
+const wall = ms => { const minutes = Math.round(num(ms) / 60000); return minutes >= 60 && minutes % 60 === 0 ? t('{n} h', { n: minutes / 60 }) : minutes >= 90 ? t('{n} h', { n: formatNumber(Math.round(minutes / 6) / 10) }) : t('{n} min', { n: minutes }); };
+export const budgetText = budget => t('{calls} calls · {tokens} tokens · {wall}', { calls: formatNumber(num(budget?.calls)), tokens: tokens(budget?.tokens), wall: wall(budget?.wall_time_ms ?? budget?.wall_ms) });
+const listText = (items, limit = 6) => items.length > limit ? `${items.slice(0, limit).join(', ')} ${t('… and {count} more', { count: items.length - limit })}` : items.join(', ') || t('(none)');
+const checkText = check => `${line(check.id, 40)}: ${line(String(check.description || '').replace(/`/g, ''), 90)}`;
+
+// Formas de datos que el flujo (flow.mjs) pasa a estas tarjetas; solo metadatos, nunca píxeles:
+//   proposal.eyes   contrato de relay-hub (open-relay v2.12, project.detect):
+//                     { host:'win11', product:'Chrome/156.0.8078.73', available:true|false,
+//                       checked_at:<ms>, error?:'ssh: …' }                 → línea «Ojos …»
+//                   (también la forma previa { state:'available'|'down'|'none', version,
+//                     port, reason, at }; si vienen las dos, gana state/version/reason/at)
+//   status.eyes     igual, más task:'t-x' y queued:N; status.remote_hosts:['win11'] da el host
+//   design          { name:'home.png', width:1440, height:900, bytes:131072 }  (metadato de project.attach)
+//   canAttachDesign true si el hub admite project.attach (open-relay >= 2.12; si no, no se ofrece)
+//   evidence        [{ task:'t-x', check:'c-web', outcome:'PASS', capture:{ bytes, path } }]
+//   blockedCard     { task:{ id, title }, reason, check, at, retry:{ delegated:true } | { command:'…' } }
+const pad2 = value => String(value).padStart(2, '0');
+/** hh:mm local de un instante (ms, ISO o Date); el motivo de la línea de ojos va acotado. */
+export const hhmm = value => {
+  const raw = typeof value === 'string' && /^\d+$/.test(value.trim()) ? Number(value) : value;
+  const date = raw instanceof Date ? raw : new Date(raw ?? Date.now());
+  return Number.isFinite(date.getTime()) ? `${pad2(date.getHours())}:${pad2(date.getMinutes())}` : '--:--';
+};
+const EYES_NONE = new Set(['', 'none', 'absent', 'missing', 'off', 'disabled']);
+const EYES_DOWN = new Set(['down', 'error', 'unavailable', 'no-response', 'no_response', 'not-responding', 'not_responding', 'timeout', 'failed']);
+const EYES_BUSY = new Set(['busy', 'in-use', 'in_use', 'used', 'locked', 'leased']);
+/** Estado de los ojos: state/status si vienen; si no, el booleano `available` de relay-hub. */
+export const eyesState = eyes => String(eyes?.state ?? eyes?.status ?? (typeof eyes?.available === 'boolean' ? (eyes.available ? 'available' : 'down') : '')).trim().toLowerCase();
+const eyesReason = eyes => eyes?.reason || eyes?.error || '';
+const eyesVersion = eyes => eyes?.version || eyes?.chrome || String(eyes?.product || '').replace(/^[A-Za-z ]*Chrome\//, '') || '?';
+const eyesHost = eyes => line(eyes?.host || eyes?.remote_host || eyes?.name || 'win11', 24);
+const eyesDown = eyes => Boolean(eyesReason(eyes)) || EYES_DOWN.has(eyesState(eyes));
+const chromeText = eyes => t('Chrome {version} (CDP {port} over ssh)', { version: line(eyesVersion(eyes), 40), port: num(eyes?.port) || 9222 });
+
+/** Línea de ojos de la propuesta (proposal.eyes de project.detect): disponible, no responde o ninguno. */
+export function eyesText(eyes) {
+  const host = eyesHost(eyes);
+  if (!eyes || EYES_NONE.has(eyesState(eyes))) return t('{host} · none', { host });
+  if (eyesDown(eyes)) return t('{host} · {chrome} · not responding ({reason}, {time})', { host, chrome: chromeText(eyes), reason: line(eyesReason(eyes) || '?', 80), time: hhmm(eyes.at ?? eyes.checked_at) });
+  return t('{host} · {chrome} · available', { host, chrome: chromeText(eyes) });
+}
+
+const firstHost = hosts => {
+  const list = Array.isArray(hosts) ? hosts : hosts ? [hosts] : [];
+  const first = list[0];
+  return typeof first === 'string' ? first : first?.host || first?.name || first?.id || '';
+};
+/** status.eyes (+ status.remote_hosts como host por omisión); null si el hub no informa de ojos. */
+export const statusEyes = status => {
+  const eyes = status?.eyes;
+  if (!eyes) return null;
+  const host = firstHost(status?.remote_hosts);
+  return eyes.host || !host ? eyes : { ...eyes, host };
+};
+
+/** Línea de ojos del estado: libre, en uso por una tarea (N en cola) o no responde. */
+export function eyesStatus(eyes) {
+  const host = eyesHost(eyes);
+  const state = eyesState(eyes), task = eyes?.task || eyes?.in_use_by || eyes?.lease;
+  if (EYES_NONE.has(state) && !task) return t('{host} · none', { host });
+  if (eyesDown(eyes)) return t('{host} · not responding', { host });
+  if (task || EYES_BUSY.has(state)) {
+    const queued = num(eyes?.queued);
+    return queued > 0 ? t('{host} · in use by {task} ({n} queued)', { host, task: line(task || '?', 60), n: queued }) : t('{host} · in use by {task}', { host, task: line(task || '?', 60) });
+  }
+  return t('{host} · free', { host });
+}
+
+/** Metadatos del diseño adjunto: archivo en el repo, espejo legible por los agentes y tamaño. */
+export const designText = design => {
+  const name = line(design?.name || design?.file || '?', 80);
+  const width = num(design?.width), height = num(design?.height), kib = Math.round(num(design?.bytes ?? design?.size) / 1024);
+  return { file: `design/${name}`, mirror: `_relay/design/${name}`, size: `${width && height ? `${width}×${height}` : '?'}, ${kib > 0 ? `${kib} KiB` : '?'}` };
+};
+
+/** Propuesta de proyecto (project.detect) con todo resuelto. */
+export function proposalCard({ proposal, existing = [], repoLabel }) {
+  const runtime = proposal.runtimes?.[0] || {};
+  const lines = [
+    t('Project      {name} · {repo}', { name: proposal.name, repo: proposal.repo }),
+    proposal.branch_exists ? t('Work branch  {branch} (already exists, it is used as is)', { branch: proposal.branch }) : t('Work branch  {branch} from {base} ({commit}) · created now; your working tree is not touched', { branch: proposal.branch, base: proposal.base || 'HEAD', commit: short(proposal.base_commit, 8) }),
+    t('Agents       {runtime} · {model} (lead: the same)', { runtime: runtime.runtime || 'comal', model: runtime.model || '?' }),
+    t('Eyes         {eyes}', { eyes: eyesText(proposal.eyes) }),
+    t('Checks       {checks}', { checks: (proposal.checks || []).map(checkText).join(' · ') || t('(none)') }),
+    t('Budget       {budget} per swarm', { budget: budgetText(proposal.budget) }),
+    t('Excludes     {list}', { list: listText((proposal.excludes || []).map(item => line(item, 60))) }),
+    ...(proposal.port ? [t('Web UI       http://127.0.0.1:{port}', { port: proposal.port })] : []),
+    '',
+    t('The result always lands on {branch}; merging it is your decision.', { branch: proposal.branch }),
+  ];
+  const items = [
+    { id: 'create', label: t('Create and start'), description: t('Creates the project in relay-hub and starts its relayd (systemd user unit).') },
+    { id: 'edit', label: t('Edit a field'), description: t('Name, base, model, checks, budget or excludes.'), badge: 'e' },
+    ...existing.slice(0, 8).map(item => ({ id: `existing:${item.name}`, label: t('Use the existing project {name}', { name: item.name }), description: t('Already in relay-hub for this repo ({state}).', { state: t(item.active === 'active' ? 'relayd running' : 'relayd stopped') }) })),
+    { id: 'cancel', label: t('Cancel'), description: t('Nothing is created.') },
+  ];
+  return { title: t('New swarm project · {repo}', { repo: repoLabel || proposal.name }), description: lines.join('\n'), items, keys: { e: 'edit' }, hint: t('Enter creates and starts · e edits · ↑/↓ choose · Esc cancels') };
+}
+
+/** Confianza: plugin de esta versión de Comal + delegación con la que opera en el proyecto. */
+export function trustCard({ project, controlDir, tokenFile, version, pkg, fingerprint, ttlDays = 30, reissue }) {
+  const lines = [
+    t('What you trust'),
+    t('  · The open-relay plugin bundled with Comal {version}, in this repo. It is asked again once per Comal version.', { version }),
+    pkg ? t('    Installed package {name}@{version} · integrity {integrity} (sha256 of its files).', { name: line(pkg.name, 60), version: line(pkg.version, 40), integrity: short(pkg.integrity, 16) }) : t('    Development copy (not an installed package): code fingerprint {fingerprint}; asked again if the code changes.', { fingerprint: short(fingerprint, 16) || '?' }),
+    t('  · The relayd of the project: {dir}', { dir: controlDir }),
+    '',
+    t('What Comal may do (relayd delegate session, {days} days, signed «operator via comal»)', { days: ttlDays }),
+    t('  · read      read the swarm: tasks, plans, messages, events (without asking)'),
+    t('  · converse  answer the swarm questions (on a card of yours)'),
+    t('  · plans     approve or reject plans (on a card of yours)'),
+    t('  · decide    record your decisions as ADRs (on a card of yours)'),
+    t('Never: starting swarms, creating projects, grants or budgets. Only you do that, with /relay; the model gets no tool for it.'),
+    '',
+    t('The token stays in {file} (0600), outside the repo; Comal never uses admin.token.', { file: tokenFile }),
+    ...(reissue ? [t('The previous delegation is no longer valid ({reason}): a new one is issued.', { reason: line(reissue, 120) })] : []),
+  ];
+  return { title: t('Connect Comal to the project {project}', { project }), description: lines.join('\n'), items: [
+    { id: 'trust', label: t('Trust and connect'), description: t('Issues the delegation and enables the plugin for this repo.') },
+    { id: 'cancel', label: t('Not now'), description: t('Nothing is issued or enabled.') },
+  ], hint: t('Enter trusts and connects · Esc: not now') };
+}
+
+export function objectiveInput({ project, lead }) {
+  return { title: t('Swarm objective · {project}', { project }), description: t('Say it in plain language: what should change and how you will know it is right. The lead ({lead}) turns it into a plan that you approve; nothing runs before that.', { lead }) };
+}
+
+export function startCard({ project, objective, lead, budget, branch, drafted = false, design, canAttachDesign = false, reviewer = null }) {
+  const attached = design ? designText(design) : null;
+  const lines = [
+    t('Objective    «{objective}»', { objective: line(objective, 600) }),
+    ...(drafted ? [t('             (drafted by the model in the conversation: review it)')] : []),
+    t('Lead         {runtime} · {model}', { runtime: lead.runtime || 'comal', model: lead.model || '?' }),
+    t('Budget       {budget}', { budget: budgetText(budget) }),
+    t('Project      {project} · the result lands on {branch}', { project, branch }),
+    ...(attached ? [t('Design       {file} ({size}) · the lead and the agents read it in `{mirror}`', attached)] : []),
+    // Revisor de open-relay (F1–F8): mismo runtime y modelo que el líder, con los ojos del proyecto.
+    ...(reviewer ? [t('Reviewer     {runtime} · {model} · eyes {eyes} · {share} % of the budget (if you start with it)', { runtime: line(reviewer.runtime || lead.runtime || 'comal', 20), model: line(reviewer.model || lead.model || '?', 40), eyes: line(reviewer.eyes || '—', 40), share: num(reviewer.share) || 40 })] : []),
+    '',
+    t('The lead reads the repo and proposes a plan: it shows up here as a card.'),
+  ];
+  return { title: t('Start the swarm'), description: lines.join('\n'), items: [
+    ...(reviewer ? [{ id: 'start-review', label: t('Start with an independent reviewer'), description: t('A second agent writes the success criteria, reviews the plan and judges each result with evidence before it closes. You accept the criteria and the plan.') }] : []),
+    { id: 'start', label: reviewer ? t('Start without reviewer') : t('Start'), description: t('swarm.start in the relayd of the project, with this objective and budget.') },
+    ...(canAttachDesign ? [{ id: 'design', label: t('Attach a reference design (image)'), description: t('project.attach with the path of a local image; the lead and the agents read it in _relay/design/.') }] : []),
+    { id: 'edit', label: t('Edit the objective'), badge: 'e' },
+    { id: 'cancel', label: t('Cancel') },
+  ], keys: { e: 'edit' }, hint: t('Enter starts · e edits the objective · Esc cancels') };
+}
+
+const criteriaOf = task => (Array.isArray(task?.criteria) ? task.criteria : []).map(item => typeof item === 'string' ? item : item?.id).filter(Boolean);
+/** Plan del líder (plan.get) legible: roles, tareas y con qué check se comprueba cada una. */
+export function planCard({ got, checks = [] }) {
+  const proposal = got?.proposal || {}, plan = proposal.plan || {}, tasks = Array.isArray(plan.tasks) ? plan.tasks : [], roles = Array.isArray(plan.roles) ? plan.roles : [];
+  const catalog = new Map((Array.isArray(checks) ? checks : []).map(check => [check?.id, check]));
+  // open-relay `plan.retire`: hijas de la tarea descompuesta que el plan cancela y deja de exigir.
+  // Va en la cabecera y antes de roles y tareas: la descripción se lee desde arriba con scroll.
+  const retire = (Array.isArray(plan.retire) ? plan.retire : []).filter(id => typeof id === 'string');
+  const lines = [t('From {role} · {tasks} tasks · {roles} new roles · agent text, untrusted', { role: line(proposal.proposer_role || '?', 60), tasks: tasks.length, roles: roles.length }) + (retire.length ? t(' · ⚠ retires {count} tasks', { count: retire.length }) : '')];
+  const summary = proposal.summary || plan.summary; if (summary) lines.push(t('Summary  «{summary}»', { summary: line(summary, 400) }));
+  // Revisor (open-relay F3/F7): su respaldo u objeción, y los planes de corrección suyos.
+  const review = proposal.review;
+  if (review?.status === 'endorsed') lines.push(t('Reviewer: endorses the plan.'));
+  else if (review?.status === 'escalated') lines.push(t('Reviewer: objected twice (rounds exhausted), you decide over it: «{reasons}»', { reasons: line((review.reasons || []).join('; '), 400) }));
+  else if (review?.status === 'awaiting') lines.push(t('Reviewer: has not reviewed it yet.'));
+  if (plan.correction_of) lines.push(t('Correction plan of the reviewer for {task}: relayd approves it on its own.', { task: line(plan.correction_of, 60) }));
+  if (retire.length) {
+    lines.push('', t('Retires (cancels and stops requiring) {count}', { count: retire.length }));
+    for (const id of retire.slice(0, 20)) lines.push(`  · ${line(id, 60)}`);
+    if (retire.length > 20) lines.push('  ' + t('… and {count} more', { count: retire.length - 20 }));
+  }
+  if (roles.length) {
+    lines.push('', t('Roles'));
+    for (const role of roles.slice(0, 12)) lines.push(`  · ${line(role.id, 60)}${role.name && role.name !== role.id ? ` (${line(role.name, 40)})` : ''} · ${line(role.runtime || role.bind?.runtime || 'comal', 20)}${role.model || role.bind?.model ? ` · ${line(role.model || role.bind.model, 40)}` : ''}`);
+    if (roles.length > 12) lines.push('  ' + t('… and {count} more', { count: roles.length - 12 }));
+  }
+  lines.push('', t('Tasks and how each one is checked'));
+  tasks.slice(0, 20).forEach((task, index) => {
+    lines.push(`  ${index + 1}. ${line(task.id, 60)}${task.title ? ` «${line(task.title, 120)}»` : ''}${t(' → {role} · up to {n} attempts', { role: line(task.role || '?', 60), n: num(task.max_attempts) || 1 })}`);
+    const paths = Array.isArray(task.paths) ? task.paths.map(item => line(typeof item === 'string' ? item : item?.path, 80)).filter(Boolean) : [];
+    if (paths.length) lines.push(t('     files: {paths}', { paths: listText(paths, 6) }));
+    const criteria = criteriaOf(task);
+    lines.push(criteria.length ? t('     checked by: {checks}', { checks: criteria.map(id => catalog.get(id)?.description ? `${line(id, 40)} (${line(String(catalog.get(id).description).replace(/`/g, ''), 70)})` : line(id, 40)).join(', ') }) : t('     checked by: nothing declared (the task is not verified by a check)'));
+    if (Array.isArray(task.deps) && task.deps.length) lines.push(t('     after: {deps}', { deps: task.deps.map(dep => line(dep, 40)).join(', ') }));
+    if (Array.isArray(task.covers) && task.covers.length) lines.push(t('     covers: {criteria}', { criteria: listText(task.covers.map(id => line(id, 40)), 8) }));
+    if (Array.isArray(task.corrects) && task.corrects.length) lines.push(t('     corrects: {objections}', { objections: listText(task.corrects.map(id => line(id, 40)), 8) }));
+  });
+  if (tasks.length > 20) lines.push('  ' + t('… and {count} more', { count: tasks.length - 20 }));
+  lines.push('', t('On approval relayd creates the roles, grants and tasks at once (digest {digest}…).', { digest: short(proposal.digest, 12) }));
+  if (retire.length) lines.push(t('On approval relayd cancels these {count} tasks and stops requiring them.', { count: retire.length }));
+  for (const problem of (Array.isArray(got?.problems) ? got.problems : []).slice(0, 6)) lines.push(t('⚠ relayd: {problem}', { problem: line(problem, 200) }));
+  return { title: t('Plan proposed · {swarm}', { swarm: line(proposal.swarm_id || '?', 60) }), description: lines.join('\n'), items: [
+    { id: 'approve', label: t('Approve'), description: t('plan.approve with this digest; the swarm starts working.') },
+    { id: 'reject', label: t('Reject with a reason'), description: t('The lead is woken up with your reason and proposes again.'), badge: 'r' },
+    { id: 'later', label: t('Later'), description: t('/relay shows it again.') },
+  ], keys: { r: 'reject' }, hint: t('Enter approves · r rejects with a reason · PgUp/PgDn · Esc later') };
+}
+
+/** Pregunta del enjambre: opciones con flechas (estructurada → ADR) o respuesta libre. */
+export function questionCard({ message, block, task }) {
+  const from = message?.from?.role ? line(message.from.role, 60) : line(message?.from?.kind || '?', 40);
+  const lines = [];
+  if (block) {
+    lines.push(t('Question (agent text, untrusted): «{question}»', { question: line(block.question, 300) }));
+    if (message?.body && line(message.body, 300) !== line(block.question, 300)) lines.push(t('Message (agent text, untrusted): «{body}»', { body: line(message.body, 500) }));
+  } else lines.push(t('Message (agent text, untrusted): «{body}»', { body: line(message?.body || '', 900) }));
+  if (task) lines.push(t('Blocks task {task}{title}', { task: line(task.id, 60), title: task.title ? ` «${line(task.title, 100)}»` : '' }));
+  if (block?.recommendation) lines.push(t('Agent recommendation: «{option}» — {why}', { option: line(block.recommendation.option, 120), why: line(block.recommendation.why, 300) }));
+  if (block) lines.push(t('Scope {scope} · reversible: {reversible} · cost of waiting: {cost}', { scope: line(block.scope, 20), reversible: t(block.reversible ? 'yes' : 'no'), cost: block.cost_of_waiting ? line(block.cost_of_waiting, 200) : t('not stated') }), '', t('Your choice is recorded as an ADR in relayd and sent as the answer.'));
+  const items = block ? block.options.map((option, index) => ({ id: `option:${index}`, label: line(option.label, 120), description: option.consequences ? line(option.consequences, 240) : '', badge: option.label === block.recommendation?.option ? t('recommended by the agent') : '' })) : [];
+  items.push({ id: 'reply', label: block ? t('Answer with my own text') : t('Answer'), description: t('msg.reply with the exact text you write.') });
+  if (!block) items.push({ id: 'ack', label: t('Mark as read'), description: t('msg.ack: it stops being pending; nothing is answered.') });
+  items.push({ id: 'later', label: t('Later'), description: t('/relay shows it again.') });
+  return { title: t('Question from the swarm · {from}', { from }), description: lines.join('\n'), items, hint: t('↑/↓ choose an option · Enter answers · Esc later') };
+}
+
+/** ¿Esperan al humano estos criterios? La versión respaldada por el líder o escalada tras sus
+ *  objeciones y, a medio swarm (open-relay v2.31), el borrador del revisor mientras otra versión
+ *  aceptada sigue vigente (`accepted` en criteria.get; `renegotiating` en la foto del panel). */
+export function criteriaWaiting(got) {
+  const status = got?.status;
+  return status === 'endorsed' || status === 'escalated' || (status === 'draft' && Boolean(got?.accepted || got?.renegotiating));
+}
+
+/** open-relay v2.33: avisos por criterio, en el orden de la versión. `beyond` (pide más que el
+ *  enunciado, declarado), `unfound` (una cita que relayd no encontró en su fuente) y `uncited`
+ *  (un criterio de juicio sin cita). `uncited` avisa si relayd comprueba citas (`checked`, de
+ *  `criteria.get.basis_checked`) o si la versión usa alguna: un relayd anterior a v2.33 no las
+ *  manda y la tarjeta queda como siempre. Un criterio `check` sin cita no avisa. */
+export function criteriaWarnings(items = [], { checked = false } = {}) {
+  const list = Array.isArray(items) ? items : [], usesBasis = checked === true || list.some(item => Array.isArray(item?.basis) && item.basis.length);
+  const out = new Map();
+  for (const item of list) {
+    const basis = Array.isArray(item?.basis) ? item.basis : [], found = [];
+    if (typeof item?.beyond === 'string' && item.beyond.trim()) found.push({ kind: 'beyond', text: item.beyond });
+    for (const quote of basis) if (quote?.found === false) found.push({ kind: 'unfound', source: quote.source, quote: quote.quote });
+    if (usesBasis && !basis.length && item?.kind === 'judgment') found.push({ kind: 'uncited' });
+    if (found.length) out.set(item?.id || '?', found);
+  }
+  return out;
+}
+
+function warningLines(id, warnings) {
+  return warnings.map(warning => warning.kind === 'beyond' ? t('  ⚠ {id}: asks more than the statement: «{beyond}»', { id: line(id, 40), beyond: line(warning.text || '', 300) })
+    : warning.kind === 'unfound' ? t('  ⚠ {id}: the quote is not in {source}: «{quote}»', { id: line(id, 40), source: line(warning.source || '?', 80), quote: line(warning.quote || '', 200) })
+      : t('  ○ {id}: no quote from the statement', { id: line(id, 40) }));
+}
+
+/** Resumen corto de los avisos de un criterio (texto de la tarjeta remota). */
+export function warningSummary(warnings = []) {
+  return warnings.map(warning => warning.kind === 'beyond' ? `${t('asks more than the statement')}: ${warning.text || ''}` : warning.kind === 'unfound' ? t('quote not found') : t('no quote')).join('; ');
+}
+
+/** Confirmación de aceptar una versión con avisos: por omisión vuelve sin aceptar y ninguna letra
+ *  confirma (la tarjeta de criterios se abre sola y se puede estar escribiendo). */
+export function criteriaConfirmCard({ got, swarm, warnings }) {
+  const list = warnings instanceof Map ? warnings : criteriaWarnings(got?.current?.items, { checked: got?.basis_checked === true });
+  return {
+    title: t('Accept with {n} warnings? · {swarm}', { n: list.size, swarm: line(swarm || got?.swarm_id || '?', 60) }),
+    description: [...[...list].slice(0, 24).flatMap(([id, items]) => warningLines(id, items)), '', t('The lead plans against these criteria and the reviewer judges with them, warnings included.')].join('\n'),
+    items: [
+      { id: 'back', label: t('Go back without accepting'), description: t('/relay shows the criteria again.') },
+      { id: 'accept', label: t('Accept anyway'), description: t('criteria.accept with this digest despite the warnings above.') },
+    ],
+    hint: t('Enter goes back · ↓ then Enter accepts'),
+  };
+}
+
+/** Criterios de éxito del swarm (criteria.get) que esperan al humano (criteriaWaiting). Se
+ *  acepta el digest exacto que se muestra. */
+export function criteriaCard({ got, swarm }) {
+  const current = got?.current || {}, items = Array.isArray(current.items) ? current.items : [];
+  const lines = [t('Version {version} by {author} · agent text, untrusted', { version: num(current.version), author: line(current.author || '?', 60) })];
+  if (got?.accepted) lines.push(t('Mid-swarm renegotiation: v{version} stays in force until you accept this one; reviews in progress then restart with it and approved tasks stay done.', { version: num(got.accepted.version) }));
+  if (got?.status === 'endorsed') lines.push(t('The lead endorses it: the reviewer wrote it, the lead agrees it is feasible.'));
+  if (got?.status === 'escalated') {
+    lines.push(t('The lead objected {n} times (rounds exhausted): you decide over the objection.', { n: num(got.rounds) }));
+    for (const objection of (Array.isArray(got.objections) ? got.objections : []).slice(-2)) lines.push(t('Lead objection (v{version}): «{reasons}»', { version: num(objection?.version), reasons: line((objection?.reasons || []).join('; '), 400) }));
+  }
+  const show = item => {
+    const stages = (Array.isArray(item?.stage) ? item.stage : []).map(stage => line(stage, 12)).join(',');
+    const out = [`  · ${line(item?.id || '?', 40)}${item?.check ? ` (${line(item.check, 40)})` : ''}${stages ? ` [${stages}]` : ''}: ${line(item?.statement || '', 240)}`];
+    const evidence = (Array.isArray(item?.evidence_required) ? item.evidence_required : []).map(value => line(value, 30));
+    const viewports = (Array.isArray(item?.viewports) ? item.viewports : []).map(value => line(typeof value === 'string' ? value : `${num(value?.width)}×${num(value?.height)}`, 20));
+    if (evidence.length || viewports.length) out.push(t('     evidence: {evidence}{viewports}', { evidence: evidence.join(', ') || '—', viewports: viewports.length ? t(' · viewports {viewports}', { viewports: viewports.join(', ') }) : '' }));
+    for (const quote of (Array.isArray(item?.basis) ? item.basis : []).slice(0, 3)) out.push(t(quote?.found === false ? '     quote ({source}, not found): «{quote}»' : '     quote ({source}): «{quote}»', { source: line(quote?.source || '?', 80), quote: line(quote?.quote || '', 200) }));
+    if (typeof item?.beyond === 'string' && item.beyond.trim()) out.push(t('     beyond the statement: «{beyond}»', { beyond: line(item.beyond, 300) }));
+    return out;
+  };
+  const warnings = criteriaWarnings(items, { checked: got?.basis_checked === true });
+  if (warnings.size) lines.push('', t('Review before accepting ({n})', { n: warnings.size }), ...[...warnings].slice(0, 24).flatMap(([id, list]) => warningLines(id, list)));
+  const checks = items.filter(item => item?.kind !== 'judgment'), judged = items.filter(item => item?.kind === 'judgment');
+  if (checks.length) lines.push('', t('Automatic (a check proves them)'), ...checks.slice(0, 24).flatMap(show));
+  if (judged.length) lines.push('', t('Judgment (the reviewer decides with evidence)'), ...judged.slice(0, 24).flatMap(show));
+  const out = (Array.isArray(current.out_of_scope) ? current.out_of_scope : []).slice(0, 12).map(value => `  · ${line(value, 200)}`);
+  if (out.length) lines.push('', t('Out of scope'), ...out);
+  lines.push('', t('Accepting fixes this version (digest {digest}…): the lead plans against it and the reviewer judges with it.', { digest: short(current.digest, 12) }));
+  const title = t('Success criteria · {swarm}', { swarm: line(swarm || got?.swarm_id || '?', 60) });
+  const reject = { id: 'reject', label: t('Reject with a reason'), description: t('The reviewer is woken up with your reason and proposes a new version.'), badge: 'r' };
+  const later = { id: 'later', label: t('Later'), description: t('/relay shows it again.') };
+  // Con avisos, Enter rechaza y ninguna letra acepta: aceptar es bajar a esa opción y confirmar.
+  if (warnings.size) return { title, description: lines.join('\n'), items: [
+    reject,
+    { id: 'accept', label: t('Accept with {n} warnings', { n: warnings.size }), description: t('Asks for confirmation first.') },
+    later,
+  ], keys: { r: 'reject' }, hint: t('Enter rejects with a reason · accepting asks for confirmation · PgUp/PgDn · Esc later') };
+  return { title, description: lines.join('\n'), items: [
+    { id: 'accept', label: t('Accept'), description: t('criteria.accept with this digest; the lead can propose the plan.') },
+    reject,
+    later,
+  ], keys: { r: 'reject' }, hint: t('Enter accepts · r rejects with a reason · PgUp/PgDn · Esc later') };
+}
+
+/** Revisión escalada (task.get): rondas agotadas o revisión sin veredicto, con el candidato
+ *  esperando. Aceptar sobre la objeción (review.override) es decisión del humano, con motivo. */
+export function escalationCard({ task }) {
+  const review = task?.review || {}, last = review.last || null, pending = review.pending || {};
+  const id = line(task?.id || '?', 60), kind = t({ task: 'task review', integration: 'integration review', final: 'final review' }[pending.kind] || 'task review');
+  const lines = [t('Task {task}{title} · {kind}', { task: id, title: task?.title ? ` «${line(task.title, 120)}»` : '', kind })];
+  lines.push(last?.effective === 'object' ? t('The reviewer objected {n} times (rounds exhausted): the candidate waits for you.', { n: num(review.rounds) }) : t('The review ended without a verdict (reviewer unavailable): the candidate waits for you.'));
+  if (last) {
+    lines.push('', t('Last verdict (reviewer text, untrusted):'));
+    for (const item of (Array.isArray(last.criteria) ? last.criteria : []).filter(item => item?.result === 'fail').slice(0, 8)) lines.push(t('  · {id} FAIL: {why}', { id: line(item.id, 40), why: line(item.rationale || '?', 240) }));
+    for (const item of (Array.isArray(last.corrections) ? last.corrections : []).slice(0, 8)) lines.push(t('  · correction {id} [{severity}{fixBy}]: {what}{where}', { id: line(item?.id || '?', 20), severity: line(item?.severity || '?', 10), fixBy: item?.fix_by ? `, ${line(item.fix_by, 12)}` : '', what: line(item?.what || '', 240), where: Array.isArray(item?.where) && item.where.length ? t(' (in {where})', { where: listText(item.where.map(value => line(value, 80)), 4) }) : '' }));
+    if (last.notes) lines.push(t('Notes: «{notes}»', { notes: line(last.notes, 300) }));
+  }
+  lines.push('', t('Accepting over the reviewer is recorded in relayd as your decision, with your reason. An integration is then applied to the branch; the final review closes the swarm.'), t('To cancel or revise the task: relay task cancel --task {task} (or task revise), in your terminal.', { task: id }));
+  // Gate 3: sin veredicto (revisor caído, intento perdido) lo primero es otra revisión del mismo
+  // candidato; con las rondas agotadas, decidir sobre la objeción, o darle una ronda más.
+  const objected = last?.effective === 'object';
+  const override = { id: 'override', label: t('Accept over the objection'), description: t('review.override with your reason (recorded in relayd).') };
+  const retry = { id: 'retry', label: t(objected ? 'One more round' : 'Ask for another review'), description: t('review.retry: the same candidate goes back to the reviewer, with your reason (recorded in relayd).') };
+  return { title: t('Review escalated · {task}', { task: id }), description: lines.join('\n'), items: [
+    ...(objected ? [override, retry] : [retry, override]),
+    { id: 'later', label: t('Later'), description: t('/relay shows it again.') },
+  ], hint: t('Enter chooses · ↑/↓ · Esc later') };
+}
+
+/** Final del enjambre: resumen, cambios en la rama y la fusión como decisión del humano.
+ *  `evidence` son metadatos de attestation.list/captura (tarea, check, resultado, bytes y ruta):
+ *  la tarjeta nunca lleva los píxeles, solo dónde quedó la captura para compararla con el diseño. */
+export function finishCard({ swarm, objective, branch, counts, diffStat = '', base, ok = true, diffCommand, evidence = [], review = null }) {
+  const evidenceLines = (Array.isArray(evidence) ? evidence : []).slice(0, 8).map(item => {
+    const capture = item?.capture || {}, kib = Math.round(num(capture.bytes ?? item?.capture_bytes) / 1024);
+    const values = { task: line(item?.task || item?.task_id || '?', 60), check: line(item?.check || item?.criterion || '?', 40), outcome: line(item?.outcome || item?.result || 'PASS', 24) };
+    const saved = capture.path || capture.file || item?.capture_path;
+    return kib > 0 && saved ? t('  · {task} · {check} {outcome} · capture {kib} KiB saved in {path}', { ...values, kib, path: line(saved, 200) }) : t('  · {task} · {check} {outcome}', values);
+  });
+  const lines = [
+    t('Swarm {swarm} · «{objective}»', { swarm: line(swarm, 60), objective: line(objective || '', 300) }),
+    t('Tasks: {done} done · {failed} failed · {other} other', { done: counts.done || 0, failed: counts.failed || 0, other: counts.other || 0 }),
+    ...(evidenceLines.length ? ['', t('Eyes (verifier evidence):'), ...evidenceLines] : []),
+    ...reviewLines(review),
+    '',
+    t('Changes ({command}):', { command: diffCommand || `git diff --stat ${short(base, 8)}..${branch}` }),
+    ...(diffStat.trim() ? diffStat.trimEnd().split('\n').slice(0, 30).map(text => '  ' + line(text, 200)) : [t('  (no changes on the branch yet)')]),
+    '',
+    t('Merging is your decision: git merge {branch} (review it first with git diff {base}..{branch}).', { branch, base: short(base, 8) }),
+  ];
+  return { title: t(ok ? 'Result ready on {branch}' : 'The swarm finished with problems · {branch}', { branch }), description: lines.join('\n'), items: [
+    { id: 'diff', label: t('Show the diff in the conversation'), description: t('git diff of the branch, read-only.') },
+    { id: 'ok', label: t('Got it'), description: t('Nothing is merged.') },
+  ] };
+}
+
+/** Veredicto final del revisor (task.get de la raíz, `review`): quién aceptó y la evidencia,
+ *  solo metadatos (ruta bajo _review/, tipo, KiB y hash); nunca los archivos ni los píxeles. */
+function reviewLines(review) {
+  if (!review || typeof review !== 'object') return [];
+  const last = review.last || {}, pass = (Array.isArray(last.criteria) ? last.criteria : []).filter(item => item?.result === 'pass').length;
+  const head = review.overridden ? t('Final review: accepted by you over the reviewer («{reason}»).', { reason: line(review.overridden, 200) }) : last.effective === 'approve' ? t('Final review: approved by the reviewer ({n} criteria pass).', { n: pass }) : null;
+  if (!head) return [];
+  const files = (Array.isArray(last.evidence) ? last.evidence : []).slice(0, 8).map(item => t('  · {path} · {media} · {kib} KiB · b3 {hash}…', { path: line(item?.path || '?', 120), media: line(item?.media || '?', 40), kib: Math.max(1, Math.round(num(item?.bytes) / 1024)), hash: short(item?.blake3, 12) }));
+  return ['', head, ...(files.length ? [t('Reviewer evidence (metadata; the files stay in relayd):'), ...files] : [])];
+}
+
+const DONE = new Set(['done']), FAILED = new Set(['failed', 'cancelled']);
+/** Conteo de tareas por estado final. */
+export function taskCounts(tasks = []) {
+  const counts = { done: 0, failed: 0, other: 0 };
+  for (const task of tasks) counts[DONE.has(task.state) ? 'done' : FAILED.has(task.state) ? 'failed' : 'other']++;
+  return counts;
+}
+
+/** Estado del proyecto ligado y lo que se puede hacer (todo control humano). */
+export function statusCard({ project, status = {}, connected, swarms = [], pending = [] }) {
+  const unit = status.unit || {}, active = unit.active === 'active', eyes = statusEyes(status);
+  const lines = [
+    t('relayd {state} (unit {unit}) · UI {web}', { state: t(active ? 'relayd running' : 'relayd stopped'), unit: line(unit.unit || `open-relay-${project}`, 60), web: line(unit.web ? (/^https?:/.test(unit.web) ? unit.web : `http://${unit.web}`) : '?', 60) }),
+    t('Branch {branch} · repo {repo}', { branch: line(status.branch || '?', 80), repo: line(status.repo || '?', 200) }),
+    ...(eyes ? [t('Eyes {eyes}', { eyes: eyesStatus(eyes) })] : []),
+    connected?.ok ? t('Comal connected · delegation of {principal} · caps {caps}', { principal: line(connected.principal || '?', 40), caps: (connected.caps || []).join(',') }) : t('Comal is not connected to this project: {reason}', { reason: line(connected?.reason || '?', 200) }),
+    '', t('Swarms'),
+  ];
+  for (const swarm of swarms.slice(0, 8)) {
+    const counts = taskCounts(swarm.tasks || []), waiting = (swarm.pending || []).filter(item => item.kind === 'question').length + (swarm.plans?.length || 0);
+    lines.push(t('  · {id} «{objective}» · {done}/{total} tasks done{waiting}', { id: line(swarm.id, 60), objective: line(swarm.objective || '', 80), done: counts.done, total: (swarm.tasks || []).length, waiting: waiting ? t(' · {n} waiting for you', { n: waiting }) : '' }));
+  }
+  if (!swarms.length) lines.push(t('  (no swarms yet)'));
+  const items = [...pending];
+  if (active && connected?.ok) items.push({ id: 'swarm', label: t('New swarm'), description: t('Write an objective and start it (start card).') });
+  if (active && connected?.ok) items.push({ id: 'board', label: t('Live board (/swarm)'), description: t('Tasks, questions and plans, updated by events.wait.') });
+  if (active && !connected?.ok) items.push({ id: 'trust', label: t('Connect Comal'), description: t('Trust card: plugin and delegation for this project.') });
+  items.push(active ? { id: 'stop', label: t('Stop the project'), description: t('Stops its relayd (the unit); swarms and branch stay.') } : { id: 'start', label: t('Start the project'), description: t('Starts its relayd again.') });
+  items.push({ id: 'new', label: t('Another project for this repo'), description: t('Proposal card for a new project.') }, { id: 'close', label: t('Close') });
+  return { title: t('open-relay · {project}', { project }), description: lines.join('\n'), items };
+}
+
+/** Tarea bloqueada porque el check no corrió (host remoto no disponible, LEASE_TIMEOUT…).
+ *  El bloqueo nunca se reintenta solo: el humano elige «Reintentar» —por la sesión delegada
+ *  si la capacidad lo permite (retry.delegated) o con el comando exacto (retry.command)— o
+ *  «Más tarde». `reason` es el motivo tal cual lo dio el verificador (acotado con line()). */
+/** Tarea bloqueada que espera al operador (el verificador no pudo correr el check, configuración,
+ *  entorno, presupuesto o reintentos de infraestructura agotados). task.resume NUNCA es delegable
+ *  en open-relay: «Reintentar» enseña el comando exacto para la terminal del humano, sin llamar a nada. */
+export function blockedCard({ task, reason, check, at, retry, why }) {
+  const id = line(task?.id || '?', 60), title = line(task?.title || '', 120);
+  const command = line(retry?.command || `relay task resume ${task?.id || '?'}`, 300);
+  const lines = [
+    t('Task {task} «{title}»', { task: id, title: title || '?' }),
+    check ? t('The verifier could not run the check: the task stays blocked and nothing is retried on its own.') : t('The task stays blocked until the operator resumes it: nothing is retried on its own.'),
+    ...(why ? [t('Blocked: {why}', { why: line(why, 80) })] : []),
+    '',
+    t('Reason: {reason}', { reason: line(reason || '?', 200) }),
+    ...(check ? [t('Check: {check}', { check: line(check, 40) })] : []),
+    ...(at ? [t('Blocked at {time}', { time: hhmm(at) })] : []),
+  ];
+  return {
+    title: t('Task blocked · {task}', { task: id }),
+    description: lines.join('\n'),
+    items: [
+      { id: 'retry', label: t('Retry'), description: t('Retry is the operator\'s (task.resume is never delegated to Comal): run it yourself, exactly: {command}', { command }) },
+      { id: 'later', label: t('Later'), description: t('/relay shows it again.') },
+    ],
+    hint: t('Enter shows the exact command · Esc: later'),
+  };
+}