builder-assistant-engineer 0.2.0

package/dist/i18n/es.js

@@ -0,0 +1,288 @@
+export const es = {
+    "program.description": "Convierte una idea o un repo existente en un plan de ejecución para agentes de IA de consola.",
+    "option.backend": "backend de IA a usar",
+    "option.lang": "idioma del CLI y de los artefactos generados",
+    "option.dryRun": "muestra exactamente qué se enviaría a la IA, sin escribir nada",
+    "option.yes": "acepta todas las confirmaciones",
+    "option.help": "muestra la ayuda",
+    "option.version": "muestra la versión",
+    "option.only": "genera solo un grupo de artefactos",
+    "option.headless": "ejecuta el agente sin sesión interactiva (acepta ediciones, nunca bypass)",
+    "command.init": "detecta el proyecto, elige backend, agentes e idioma, y hace la entrevista",
+    "command.plan": "analiza el repo y genera el plan, la memoria y los agentes",
+    "command.next": "ejecuta la siguiente tarea pendiente, la verifica, la revisa y la marca como hecha",
+    "command.status": "muestra fases, tareas y progreso",
+    "command.replan": "re-analiza el repo, conserva lo hecho y actualiza lo pendiente",
+    "command.review": "revisa el diff de una tarea contra sus criterios de aceptación y AGENTS.md",
+    "command.help": "muestra la ayuda de un comando",
+    "option.brief": "archivos separados por comas con tu brief o docs (evita pegar texto)",
+    "ui.cancelled": "Cancelado.",
+    "format.retrying": "La respuesta no siguió el formato; se pide una vez más corregir solo el formato.",
+    "format.failed": "La respuesta sigue sin cumplir el formato ({{details}}). Salida original guardada en {{path}}.",
+    "init.intro": "builder-assistant-engineer · configuración",
+    "init.lang": "Idioma del CLI y del plan generado",
+    "init.mode": "Tipo de proyecto",
+    "init.detected": "detectado",
+    "init.backend": "¿Qué IA hará el análisis?",
+    "init.backendMissing": "`{{command}}` no está en el PATH; instálalo antes de ejecutar plan.",
+    "init.targets": "¿Qué agentes trabajarán en este repo?",
+    "init.redoInterview": "Ya existe una entrevista en .bae/interview.md. ¿Rehacerla?",
+    "init.briefMissing": "No se pudieron leer los archivos del brief: {{path}}",
+    "init.dryRunNoAi": "Dry run: init no enviaría nada a la IA.",
+    "init.dryRunDone": "Dry run terminado. No se escribió nada.",
+    "init.done": "Configuración guardada en .bae/. Siguiente paso: {{command}}",
+    "mode.greenfield": "Greenfield — proyecto nuevo, poco o ningún código",
+    "mode.brownfield": "Brownfield — código existente",
+    "backend.label.manual": "Manual (copiar y pegar)",
+    "backend.hint.installed": "instalado",
+    "backend.hint.missing": "no está en el PATH",
+    "backend.hint.api": "clave de Anthropic o compatible con OpenAI por variables de entorno",
+    "backend.hint.apiReady": "credenciales encontradas en el entorno",
+    "backend.hint.manual": "funciona con cualquier IA, incluso un chat web",
+    "interview.intro": "Entrevista — pulsa Enter para saltar cualquier pregunta.",
+    "interview.brief": "Brief: pega un resumen de una línea, o rutas a archivos con tu brief o docs (separadas por comas)",
+    "interview.briefPlaceholder": "p. ej. docs/brief.md, notas/idea.md",
+    "interview.briefLoaded": "Cargados {{count}} archivo(s): {{paths}}",
+    "interview.objective": "¿Cuál es el objetivo sobre este repo?",
+    "interview.q.what": "¿Qué quieres construir y para quién?",
+    "interview.q.problem": "¿Qué problema resuelve y cómo sabrás que funciona?",
+    "interview.q.scope": "¿Qué entra en el primer entregable y qué queda fuera?",
+    "interview.q.constraints": "Restricciones: stack obligatorio, plazos, plataformas, integraciones, presupuesto?",
+    "interview.q.team": "¿Quién ejecuta el plan (solo IA, tú + IA, un equipo) y con qué nivel?",
+    "interview.q.rules": "Preferencias y prohibiciones: convenciones, zonas del repo que no se tocan?",
+    "interview.followUps": "El analista puede hacer hasta {{max}} preguntas de seguimiento.",
+    "interview.thinking": "Pensando la siguiente pregunta…",
+    "interview.other": "Otra (escríbela)",
+    "interview.skip": "Saltar",
+    "interview.answer": "Tu respuesta",
+    "interview.adaptiveFailed": "Se omiten las preguntas de seguimiento restantes: {{details}}",
+    "interview.adaptiveManual": "Con el backend manual se omiten las preguntas de seguimiento.",
+    "objective.feature": "Construir una funcionalidad nueva",
+    "objective.refactor": "Refactorizar",
+    "objective.migration": "Migrar (framework, lenguaje, infraestructura)",
+    "objective.bugs": "Corregir bugs",
+    "objective.docs": "Documentar el código",
+    "md.interview": "Entrevista",
+    "md.mode": "Modo",
+    "md.objective": "Objetivo",
+    "md.brief": "Brief",
+    "md.followUps": "Preguntas de seguimiento",
+    "md.summary": "Resumen",
+    "md.skipped": "sin respuesta",
+    "config.missing": "No hay configuración en .bae/config.json. Ejecuta primero {{command}}.",
+    "digest.reading": "Leyendo el repositorio…",
+    "plan.intro": "builder-assistant-engineer · plan",
+    "plan.noInterview": "No hay entrevista en .bae/interview.md; se planifica solo a partir del repositorio.",
+    "plan.analyzing": "El analista está construyendo el plan (puede tardar varios minutos)",
+    "plan.progress": "Recibiendo el plan… {{chars}} caracteres",
+    "plan.existingPlan": "Ya existe un plan en docs/plan/tasks. ¿Regenerarlo desde cero? (replan conserva el progreso)",
+    "plan.useReplan": "Sin cambios. Usa replan para actualizar el plan conservando lo hecho.",
+    "plan.dryRunDone": "Dry run: el prompt de arriba es exactamente lo que se enviaría. No se escribió nada.",
+    "plan.continuing": "La respuesta se cortó en {{marker}}; se pide al analista que continúe desde ahí.",
+    "plan.summary": "Resumen",
+    "plan.blocking": "bloqueante",
+    "plan.done": "{{count}} archivo(s) escritos. Siguiente paso: {{next}}",
+    "plan.nothingWritten": "No se escribió ningún archivo.",
+    "artifacts.changes": "Cambios",
+    "artifacts.confirm": "¿Escribir {{count}} archivo(s)?",
+    "artifacts.all": "Escribir todo",
+    "artifacts.each": "Revisar uno a uno",
+    "artifacts.none": "No escribir nada",
+    "artifacts.confirmOne": "¿Escribir {{path}}?",
+    "artifacts.new": "nuevo, {{lines}} líneas",
+    "artifacts.updated": "+{{added}} −{{removed}}",
+    "artifacts.unchanged": "sin cambios",
+    "artifacts.keptDone": "tarea hecha, se conserva tal cual",
+    "tasks.invalid": "Se ignora un archivo de tarea inválido: {{error}}",
+    "next.intro": "builder-assistant-engineer · next",
+    "next.meta": "fase {{phase}} · tamaño {{size}} · riesgo {{risk}} · depende de {{deps}}",
+    "next.dryRunDone": "Dry run: la tarea de arriba es exactamente lo que recibiría el agente. No se cambió nada.",
+    "next.headlessNeedsAgent": "--headless necesita un backend de agente (claude, opencode, codex, gemini); se usa el flujo manual.",
+    "next.launching": "Abriendo {{backend}} con la tarea. Sal de la sesión cuando la tarea esté terminada.",
+    "next.attempt": "Intento {{attempt}} de {{max}} con {{backend}} (headless, acepta ediciones)",
+    "next.done": "{{id}} está hecha. Siguiente paso: {{command}}",
+    "next.notDone": "{{id}} sigue en curso. Corrígela y vuelve a ejecutar {{command}}.",
+    "next.blocked": "{{id}} queda bloqueada: {{reason}} Logs: {{path}}",
+    "next.noPlan": "Todavía no hay tareas. Ejecuta primero {{command}}.",
+    "next.allDone": "Todas las tareas están hechas.",
+    "next.nothingReady": "No hay ninguna tarea lista",
+    "next.unblock": "Desbloquea o termina las tareas de arriba, o ejecuta replan.",
+    "verify.commands": "Verificación",
+    "verify.confirm": "¿Ejecutar ahora estos comandos de verificación?",
+    "verify.declined": "No se ejecutó la verificación; la tarea sigue en curso.",
+    "verify.none": "La tarea no tiene comandos de verificación en un bloque ```sh dentro de Verification.",
+    "verify.failed": "La verificación falló: `{{command}}` terminó con {{code}}.",
+    "verify.passed": "Verificación superada.",
+    "verify.stillFailing": "`{{command}}` ya fallaba antes de la tarea y sigue fallando (salida {{code}}), así que no bloqueó. Si algún criterio de aceptación exige que pase, la tarea no está hecha.",
+    "review.intro": "builder-assistant-engineer · review",
+    "review.running": "El revisor está comprobando {{id}}…",
+    "review.findings": "Hallazgos de la revisión",
+    "review.passed": "Revisión superada.",
+    "review.failed": "La revisión de {{id}} no pasó.",
+    "review.noGit": "Revisión omitida: no es un repositorio git, así que no hay diff que revisar.",
+    "review.noChanges": "La tarea no cambió archivos y sus chequeos pasan, así que no se llamó al revisor.",
+    "review.dryRun": "Dry run: el prompt de revisión de arriba no se envió.",
+    "review.noTask": "No hay ninguna tarea en curso. Indica un id, p. ej. review T-003.",
+    "review.unknownTask": "No se encontró la tarea {{id}} en docs/plan/tasks.",
+    "status.empty": "Todavía no hay plan. Ejecuta primero {{command}}.",
+    "status.phase": "Fase {{phase}}",
+    "status.waiting": "espera a {{ids}}",
+    "status.total": "{{done}}/{{total}} hechas ({{percent}}%)",
+    "status.next": "siguiente: {{id}} {{title}}",
+    "status.noNext": "ninguna tarea lista",
+    "replan.intro": "builder-assistant-engineer · replan",
+    "replan.noPlan": "No hay plan que actualizar. Ejecuta primero {{command}}.",
+    "replan.noChangelog": "El analista no escribió docs/plan/CHANGELOG.md.",
+    "artifacts.removed": "se elimina, ya no está en el plan",
+    "argument.task": "id de tarea, p. ej. T-003 (por defecto, la tarea en curso)",
+    "error.configJson": "{{path}} no es JSON válido: {{details}}",
+    "error.configInvalid": "{{path}} no es válido:\n{{details}}",
+    "error.promptMissingVars": "{{path}} usa variables que no se proporcionaron: {{vars}}",
+    "error.unexpected": "Error inesperado. Repórtalo adjuntando la salida siguiente.",
+    "backend.notInstalled": "`{{command}}` no está instalado o no está en el PATH. Instálalo o elige otro backend con --backend.",
+    "backend.timedOut": "`{{command}}` no terminó en {{minutes}} minutos y se detuvo (agent.timeoutMinutes en .bae/config.json).",
+    "backend.failed": "`{{command}}` terminó con código {{code}}:\n{{details}}",
+    "backend.apiNotConfigured": "El backend api necesita ANTHROPIC_API_KEY, u OPENAI_BASE_URL/OPENAI_API_KEY para un endpoint compatible con OpenAI.",
+    "backend.apiModelRequired": "Define BAE_MODEL con el modelo a usar en {{baseUrl}}.",
+    "backend.apiProviderInvalid": "BAE_API_PROVIDER debe ser anthropic u openai, no {{provider}}.",
+    "backend.apiHttp": "Error de la API de {{provider}} ({{status}}): {{details}}",
+    "backend.apiNetwork": "No se pudo conectar con {{url}}: {{details}}",
+    "backend.apiInteractive": "El backend api no puede abrir una sesión interactiva.",
+    "backend.refusal": "El modelo rechazó la solicitud.",
+    "backend.truncated": "La respuesta alcanzó el límite de tokens de salida y está incompleta.",
+    "manual.copied": "Prompt copiado al portapapeles y guardado en {{path}}.",
+    "manual.notCopied": "No se pudo usar el portapapeles; el prompt está guardado en {{path}}.",
+    "manual.awaitingResponse": "Pégalo en tu IA. Luego pega aquí la respuesta completa y termina con Ctrl-D (Ctrl-Z, Enter en Windows), o guárdala en {{path}} y pulsa Enter.",
+    "manual.awaitingDone": "Ejecútalo con tu agente y pulsa Enter cuando la tarea termine.",
+    "manual.emptyResponse": "No se recibió respuesta. Pégala aquí o guárdala en {{path}}.",
+    "plan.commands": "Comandos del proyecto guardados en .bae/config.json",
+    "regression.title": "Chequeo de regresión",
+    "regression.baselineTitle": "Línea base de regresión, antes de la tarea",
+    "regression.confirm": "¿Ejecutar ahora los comandos de lint y test del proyecto para registrar la línea base?",
+    "regression.preexisting": "`{{command}}` ya falla antes de la tarea (salida {{code}}); queda registrado como preexistente y no bloquea.",
+    "regression.found": "Regresión: `{{command}}` termina con {{code}} después de la tarea.",
+    "regression.stillFailing": "`{{command}}` sigue fallando (salida {{code}}), igual que antes de la tarea.",
+    "regression.passed": "Chequeo de regresión superado.",
+    "evidence.retrying": "{{count}} ruta(s) citadas no están en el repositorio ni marcadas (new); se pide al analista corregir solo esas.",
+    "evidence.fixing": "El analista está corrigiendo las rutas citadas…",
+    "evidence.fixed": "Todas las rutas citadas existen o están marcadas (new).",
+    "evidence.unverified": "{{count}} ruta(s) citadas siguen sin verificar; aparecen en el resumen.",
+    "evidence.summary": "Rutas sin verificar (no están en el repositorio ni marcadas como nuevas):",
+    "mechanical.secretFile": "Parece un archivo de secretos (.env, clave privada o credenciales); déjalo fuera del cambio.",
+    "mechanical.secretValue": "Añade lo que parece una credencial ({{kind}}); léela del entorno.",
+    "mechanical.noTests": "La tarea exige tests (tests: required), pero no ejecuta más tests que antes ni añade aserciones a un archivo de test.",
+    "mechanical.outOfScope": "Cambios fuera del Scope de la tarea: {{files}}",
+    "mechanical.failed": "Los chequeos automáticos fallaron, así que no se lanzó el revisor.",
+    "plan.openQuestions": "Preguntas abiertas, guardadas en .bae/interview.md; respóndelas allí y ejecuta replan cuando puedas",
+    "plan.questionsSaved": "{{count}} pregunta(s) guardadas en .bae/interview.md.",
+    "plan.rerun": "Respondiste preguntas bloqueantes. ¿Volver a generar el plan ahora con tus respuestas?",
+    "plan.rerunning": "Generando el plan otra vez con tus respuestas.",
+    "md.planQuestions": "Preguntas del plan ({{date}})",
+    "md.why": "Por qué",
+    "md.options": "Opciones",
+    "md.blocking": "Bloqueante: el plan asumió una respuesta",
+    "md.answer": "Respuesta",
+    "md.open": "abierta, sin responder",
+    "handoff.missing": "{{path}} no tiene nota de traspaso: escribe como máximo {{max}} líneas bajo ## Log (qué cambió, decisiones, trampas).",
+    "handoff.tooLong": "La nota de traspaso de {{path}} tiene {{count}} líneas; déjala en {{max}} como máximo.",
+    "handoff.passed": "Nota de traspaso presente.",
+    "md.lessons": "Lecciones aprendidas",
+    "lesson.asking": "{{id}} falló varias veces; pidiendo al agente la causa raíz y una regla…",
+    "lesson.title": "Lección de {{id}}",
+    "lesson.body": "Causa raíz: {{cause}}\nRegla: {{rule}}",
+    "lesson.confirm": "¿Añadir esta regla a AGENTS.md?",
+    "lesson.added": "Regla añadida a AGENTS.md.",
+    "lesson.skipped": "Regla no añadida; queda en {{path}}.",
+    "lesson.failed": "No se pudo obtener una lección del agente: {{details}}",
+    "status.blockedReason": "{{id}} está bloqueada: {{reason}}",
+    "status.metrics": "Métricas locales",
+    "status.attempts": "intentos: {{attempts}} en {{tasks}} tarea(s), {{average}} por tarea",
+    "status.firstAttempt": "hechas al primer intento: {{count}}/{{tasks}} ({{percent}}%)",
+    "status.regressions": "regresiones atrapadas: {{count}}",
+    "status.time": "tiempo por tarea hecha: {{average}} de media, {{total}} en total",
+    "status.taskRuns": "{{attempts}} intento(s), {{time}}",
+    "format.repaired": "Respuesta reparada localmente: {{repairs}}.",
+    "evidence.retryFailed": "Falló la petición para corregir las rutas citadas, así que el plan las conserva tal cual: {{details}}",
+    "regression.noCommands": "No hay comando de lint ni de test en .bae/config.json ni en los manifiestos; el chequeo de regresión queda desactivado hasta que los añadas en commands.",
+    "option.acceptFinding": "acepta un hallazgo por su id (repetible); solo secretos, y hallazgos de contrato o de tests en archivos que el Alcance de la tarea lista",
+    "review.noBase": "Revisión fallida: el commit registrado al empezar la tarea ya no existe, así que no se pueden aislar sus cambios.",
+    "review.noCapture": "{{id}} no tiene captura de next; se revisa contra el HEAD actual.",
+    "contract.title": "Contrato",
+    "contract.failed": "La tarea cambió archivos que definen sus propios chequeos; se restauraron desde el estado capturado antes de la tarea.",
+    "contract.recovered": "Una ejecución anterior de {{id}} terminó antes de sus chequeos; se restauraron los archivos que cambió y que definen los chequeos.",
+    "contract.task": "Editó el archivo de la tarea fuera de ## Log.",
+    "contract.tasks": "Editó otro archivo de tarea.",
+    "contract.bae": "Cambió la configuración o los prompts de bae.",
+    "contract.agents": "Cambió la definición de un agente o la configuración con la que corre el revisor.",
+    "contract.gitignore": "Cambió un archivo de ignore, que decide qué ve la revisión.",
+    "contract.scripts": "Cambió {{detail}}, que los chequeos ejecutan.",
+    "contract.runner": "Cambió la configuración del runner de tests.",
+    "contract.restored": "Restaurado.",
+    "contract.removed": "Eliminado.",
+    "findings.accepted": "Aceptado con --accept-finding.",
+    "findings.acceptedTitle": "Hallazgos aceptados",
+    "regression.failed": "El chequeo de regresión falló.",
+    "regression.mustPass": "`{{command}}` sigue fallando (exit {{code}}) y la tarea es tests: fix, así que la suite de tests debe terminar en verde.",
+    "regression.uncomparable": "`{{command}}` ya fallaba antes de la tarea y sigue fallando (exit {{code}}); su salida no tiene conteos para comparar, así que solo pasa en verde.",
+    "regression.worse": "Regresión: `{{command}}` falla más chequeos que antes de la tarea ({{now}}; antes: {{before}}).",
+    "regression.lateStop": "{{id}} no tiene línea base de regresión de antes de que corriera su agente.",
+    "regression.declinedStop": "Sin correr antes lint y tests no hay línea base, así que la tarea no podría completarse.",
+    "regression.unusable": "`{{command}}` no da una línea base usable (exit {{code}}): no terminó, o falla sin conteos que comparar. La tarea no podría completarse mientras siga en rojo.",
+    "review.noVerdict": "El revisor no dio veredicto.",
+    "review.error": "El revisor no pudo dar un veredicto: {{details}}",
+    "skip.used": "Se continúa sin este chequeo por --allow-skip: {{what}}",
+    "skip.title": "Omitido con --allow-skip",
+    "skip.stopped": "No se lanzó nada. Corrige la causa, o vuelve a correr next con --allow-skip para seguir sin ese chequeo; la omisión queda en el log de la ejecución.",
+    "next.budgetUsed": "La tarea ya usó sus {{max}} intentos automáticos.",
+    "next.refusedBlocked": "{{id}} queda bloqueada antes de lanzar el agente, porque sus chequeos no pueden correr. Corrige la Verificación de la tarea o los comandos de .bae/config.json y vuelve a ponerla en pending.",
+    "capture.lateStop": "{{id}} está en curso sin una captura de antes de que corriera su agente, así que sus chequeos no tienen un punto de partida fiable. Vuelve a ponerla en pending, o corre con --allow-skip.",
+    "capture.noGit": "No es un repositorio git, así que la revisión no puede ver los cambios de la tarea.",
+    "option.allowSkip": "continúa cuando un chequeo no puede correr (sin git, sin línea base, sin veredicto del revisor); cada omisión queda registrada",
+    "integrity.title": "Integridad de los tests",
+    "integrity.failed": "La tarea quitó o desactivó tests.",
+    "integrity.deleted": "Borra un archivo de test.",
+    "integrity.skipMarker": "Añade un marcador que omite o aísla tests ({{marker}}).",
+    "integrity.exclusion": "Añade una configuración del runner de tests que deja tests fuera ({{keys}}).",
+    "integrity.fewerTests": "`{{command}}` ejecuta menos tests que antes de la tarea ({{now}}; antes: {{before}}).",
+    "integrity.moreSkipped": "`{{command}}` omite más tests que antes de la tarea ({{now}}; antes: {{before}}).",
+    "verify.noBash": "La Verificación corre como un script de bash y no se encontró bash. En Windows instala Git for Windows, que trae Git Bash; en otros sistemas pon bash en el PATH.",
+    "verify.masks": "La Verificación oculta fallos en `{{command}}` (|| true, set +e). El bloque corre con set -euo pipefail y debe fallar cuando falla un chequeo.",
+    "verify.trivial": "La Verificación no ejecuta nada que compruebe la tarea:\n{{command}}\nUsa el runner de tests del proyecto, un linter o un chequeo con resultado esperado (test -f, grep -q, curl -f).",
+    "verify.notAllowed": "`{{command}}` no está en la lista de comandos que bae corre cuando nadie los confirma ({{why}}). Añade un prefijo a verify.allow en .bae/config.json, o corre next sin --yes ni --headless y confírmalo tú.",
+    "regression.notAllowed": "El comando del proyecto `{{command}}` no está en la lista de comandos que bae corre cuando nadie los confirma ({{why}}). Añade un prefijo a verify.allow en .bae/config.json.",
+    "verify.dynamic": "ejecuta código que se arma en tiempo de ejecución o en otro shell",
+    "verify.unknown": "programa desconocido",
+    "verify.unsafeWarning": "`{{command}}` parece peligroso ({{reason}}); léelo antes de confirmar.",
+    "verify.onlyExcused": "La Verificación solo ejecuta comandos que ya fallaban antes de la tarea, así que no comprueba nada de esta tarea.",
+    "evidence.linesFailed": "El plan cita líneas que no existen, incluso después de pedir al analista que las corrija:\n{{list}}\nEl plan no se escribió; la respuesta rechazada está en {{path}}. Vuelve a correr plan.",
+    "state.tampered": "Código ejecutado para esta tarea cambió el estado propio de bae fuera del repositorio ({{files}}); se restauró y el intento falla.",
+    "review.gitError": "Revisión fallida: git no pudo listar los cambios de la tarea (índice, configuración o filtro rotos), así que los chequeos no pueden verlos.",
+    "contract.memory": "Cambió un archivo de memoria de agentes, que leen los agentes y el revisor.",
+    "contract.git": "Cambió atributos de git, que deciden cómo ve la revisión los archivos.",
+    "contract.gitdir": "Cambió la configuración de git del repositorio en .git, de la que dependen los chequeos.",
+    "contract.toolchain": "Cambió una configuración del gestor de paquetes o de una herramienta que decide cómo corren los chequeos.",
+    "contract.shadow": "Añadió un archivo que se ejecutaría en lugar de la herramienta del proyecto.",
+    "contract.indexFlags": "Marcó archivos como sin cambios en el índice de git (assume-unchanged o skip-worktree), lo que los oculta de la revisión: {{files}}. Se quitaron las marcas.",
+    "integrity.removedTests": "Quita tests que no vuelven a añadirse: {{tests}}.",
+    "integrity.lostAssertions": "Quita {{count}} línea(s) de aserción de un archivo de test sin volver a añadirlas.",
+    "capture.headMoved": "{{id}} conserva el commit registrado cuando empezó; los commits hechos desde entonces cuentan como parte de los cambios de la tarea.",
+    "contract.restoreFailed": "No se pudo restaurar {{files}} desde la captura. Corrígelos a mano; la siguiente ejecución los vuelve a comprobar antes de empezar.",
+    "integrity.suppression": "Añade un comentario que silencia un chequeo ({{markers}}).",
+    "integrity.expectedOutput": "Cambia un snapshot o un archivo de salida esperada, que decide qué aceptan los tests.",
+    "regression.baselineTampered": "Correr los comandos del proyecto para la línea base cambió archivos de los que dependen los chequeos ({{files}}); se restauraron y no se lanzó nada.",
+    "regression.unknown": "`{{command}}` termina con {{code}}, pero bae no pudo leer cuántos tests corrieron, así que no puede saber si pasaron.",
+    "regression.unknownRunner": "bae no reconoce el runner de tests detrás de `{{command}}`, así que no puede saber si los tests pasan. Pon en commands.test de .bae/config.json el runner mismo, por ejemplo `npx vitest run`, `npx jest`, `pytest`, `go test -v ./...`, `cargo test` o `dotnet test`.",
+    "regression.noCounts": "`{{command}}` no da una línea base usable: pasa, pero no dice cuántos tests corrieron, así que la tarea no podría compararse con ella.",
+    "regression.unreadSkipped": "`{{command}}` no dijo cuántos tests corrieron",
+    "contract.scoped": "El Scope de la tarea lista este archivo, así que el cambio se queda: los chequeos corren con él y el revisor lo ve.",
+    "contract.weakerScripts": "Deja de correr lo que corrían estos scripts: {{scripts}}.",
+    "contract.weakerRunner": "Añade ajustes que dejan tests fuera ({{keys}}).",
+    "contract.weakerToolchain": "Añade un ajuste que cambia cómo arranca el gestor de paquetes o el runner de tests.",
+    "review.noEvidence": "(ninguna: esta revisión no se corrió justo después de los chequeos de next)",
+    "integrity.scoped": "El Scope de la tarea lista este archivo, así que el revisor debe decir por qué este cambio es correcto.",
+    "review.unjustified": "El revisor aprobó la tarea sin decir por qué son correctos estos cambios en archivos de test: {{files}}.",
+    "mechanical.secretHistory": "Un commit hecho durante la tarea añade algo que parece una credencial ({{kind}}). Se queda en el historial de git aunque el archivo ya no lo tenga, así que reescribe esos commits.",
+    "mechanical.secretFileHistory": "Un commit hecho durante la tarea añade un archivo de secretos. Se queda en el historial de git aunque el archivo ya no exista, así que reescribe esos commits.",
+    "regression.noTestsYet": "`{{command}}` todavía no tiene tests que correr, así que no hay línea base; después de la tarea debe pasar y decir cuántos tests corrieron.",
+    "integrity.planned": "El Scope de la tarea marca archivos de test que elimina, así que lo juzga el revisor.",
+};

package/dist/i18n/index.js

@@ -0,0 +1,18 @@
+import { en } from "./en.js";
+import { es } from "./es.js";
+export const LANGS = ["en", "es"];
+const catalogs = { en, es };
+const PLACEHOLDER = /\{\{(\w+)\}\}/g;
+let current = "en";
+export function setLang(lang) {
+    current = lang;
+}
+export function getLang() {
+    return current;
+}
+export function isLang(value) {
+    return LANGS.some((lang) => lang === value);
+}
+export function t(key, vars = {}) {
+    return catalogs[current][key].replace(PLACEHOLDER, (match, name) => String(vars[name] ?? match));
+}

package/dist/interview/adaptive.js

@@ -0,0 +1,69 @@
+import { buildAnalystPrompt } from "../analyst/prompt.js";
+import { runWithFormatRetry } from "../analyst/retry.js";
+import { UserError } from "../core/errors.js";
+import { t } from "../i18n/index.js";
+import { MAX_FOLLOW_UPS } from "./questions.js";
+import { renderInterview } from "./render.js";
+import { INTERVIEW_FORMAT, parseInterviewReply } from "./reply.js";
+export async function runAdaptiveRound(context, data) {
+    const followUps = [];
+    context.prompter.info(t("interview.followUps", { max: MAX_FOLLOW_UPS }));
+    try {
+        for (let round = 0; round < MAX_FOLLOW_UPS; round++) {
+            const reply = await nextReply(context, { ...data, followUps });
+            if (reply.done)
+                return { ...data, followUps, summary: reply.summary };
+            followUps.push({
+                question: reply.question,
+                answer: await askQuestion(context.prompter, reply),
+            });
+        }
+    }
+    catch (error) {
+        if (!(error instanceof UserError) || error.message === t("ui.cancelled"))
+            throw error;
+        context.prompter.warn(t("interview.adaptiveFailed", { details: error.message }));
+    }
+    return { ...data, followUps };
+}
+export function interviewPrompt(context, data) {
+    return buildAnalystPrompt(context.cwd, {
+        mode: "INTERVIEW",
+        projectType: context.projectType,
+        lang: context.lang,
+        targets: context.targets,
+        interview: renderInterview(data),
+        digest: context.digest,
+        canExplore: context.canExplore,
+        priorPlan: "",
+    });
+}
+async function nextReply(context, data) {
+    const prompt = await interviewPrompt(context, data);
+    return context.prompter.spinner(t("interview.thinking"), () => runWithFormatRetry({
+        backend: context.backend,
+        prompt,
+        options: { cwd: context.cwd, access: "read" },
+        parse: parseInterviewReply,
+        format: INTERVIEW_FORMAT,
+        onRetry: () => context.prompter.warn(t("format.retrying")),
+    }));
+}
+export async function askQuestion(prompter, reply) {
+    if (reply.why)
+        prompter.note(reply.why, reply.question);
+    const options = reply.options ?? [];
+    if (options.length === 0)
+        return prompter.text(reply.question, t("interview.answer"));
+    const choices = [
+        ...options.map((option, index) => ({ value: `option-${index}`, label: option })),
+        { value: "other", label: t("interview.other") },
+        { value: "skip", label: t("interview.skip") },
+    ];
+    const picked = await prompter.select(reply.question, choices);
+    if (picked === "skip")
+        return "";
+    if (picked === "other")
+        return prompter.text(reply.question, t("interview.answer"));
+    return options[Number(picked.slice("option-".length))] ?? "";
+}

package/dist/interview/brief.js

@@ -0,0 +1,27 @@
+import { readFile, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { redact } from "../digest/redact.js";
+const MAX_FILE_CHARS = 50_000;
+export async function loadBrief(cwd, raw) {
+    const tokens = raw
+        .split(",")
+        .map((token) => token.trim())
+        .filter(Boolean);
+    if (tokens.length === 0)
+        return { text: "", files: [] };
+    const contents = await Promise.all(tokens.map((token) => readIfFile(resolve(cwd, token))));
+    if (contents.some((content) => content === undefined))
+        return { text: redact(raw.trim()), files: [] };
+    const sections = tokens.map((token, index) => `### ${token}\n\n${contents[index] ?? ""}`);
+    return { text: redact(sections.join("\n\n")), files: tokens };
+}
+async function readIfFile(path) {
+    try {
+        if (!(await stat(path)).isFile())
+            return undefined;
+        return (await readFile(path, "utf8")).slice(0, MAX_FILE_CHARS).trim();
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/interview/questions.js

@@ -0,0 +1,18 @@
+export const BASE_QUESTIONS = [
+    "interview.q.what",
+    "interview.q.problem",
+    "interview.q.scope",
+    "interview.q.constraints",
+    "interview.q.team",
+    "interview.q.rules",
+];
+export const OBJECTIVES = ["feature", "refactor", "migration", "bugs", "docs", "skip"];
+export const OBJECTIVE_LABELS = {
+    feature: "objective.feature",
+    refactor: "objective.refactor",
+    migration: "objective.migration",
+    bugs: "objective.bugs",
+    docs: "objective.docs",
+    skip: "interview.skip",
+};
+export const MAX_FOLLOW_UPS = 5;

package/dist/interview/render.js

@@ -0,0 +1,19 @@
+import { t } from "../i18n/index.js";
+export function renderInterview(data) {
+    const header = [`# ${t("md.interview")}`, "", `- ${t("md.mode")}: ${data.mode}`];
+    if (data.objective)
+        header.push(`- ${t("md.objective")}: ${data.objective}`);
+    const sections = [header.join("\n")];
+    if (data.brief)
+        sections.push(`## ${t("md.brief")}\n\n${data.brief}`);
+    sections.push(...data.answers.map(renderAnswer("##")));
+    if (data.followUps.length > 0) {
+        sections.push(`## ${t("md.followUps")}`, ...data.followUps.map(renderAnswer("###")));
+    }
+    if (data.summary)
+        sections.push(`## ${t("md.summary")}\n\n${data.summary}`);
+    return `${sections.join("\n\n")}\n`;
+}
+function renderAnswer(level) {
+    return ({ question, answer }) => `${level} ${question}\n\n${answer.trim() || `_${t("md.skipped")}_`}`;
+}

package/dist/interview/reply.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { FormatError } from "../core/errors.js";
+const replySchema = z.discriminatedUnion("done", [
+    z.object({
+        done: z.literal(false),
+        question: z.string().min(1),
+        why: z.string().optional(),
+        options: z.array(z.string().min(1)).optional(),
+    }),
+    z.object({ done: z.literal(true), summary: z.string().min(1) }),
+]);
+export const INTERVIEW_FORMAT = [
+    "JSON only, one of:",
+    '{"done": false, "question": "...", "why": "one line on what this unblocks", "options": ["...", "..."]}',
+    '{"done": true, "summary": "3-6 lines restating goal, users, scope, constraints and success criteria"}',
+].join("\n");
+export function parseInterviewReply(text) {
+    const result = replySchema.safeParse(extractJson(text));
+    if (!result.success)
+        throw new FormatError(z.prettifyError(result.error));
+    return result.data;
+}
+function extractJson(text) {
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start === -1 || end < start)
+        throw new FormatError("no JSON object found");
+    try {
+        return JSON.parse(text.slice(start, end + 1));
+    }
+    catch (error) {
+        throw new FormatError(`invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/next/attempts.js

@@ -0,0 +1,151 @@
+import { CLI, isAgentBackend } from "../commands/shared.js";
+import { UserError } from "../core/errors.js";
+import { renderPrompt } from "../core/prompt-loader.js";
+import { displayPath } from "../core/state.js";
+import { capturedPrompt, clearActive, markActive, saveCapture, } from "../gates/capture.js";
+import { enforceContract } from "../gates/enforce.js";
+import { runGate } from "../gates/gate.js";
+import { guardState } from "../gates/state-guard.js";
+import { t } from "../i18n/index.js";
+import { capturedTask } from "../review/run.js";
+import { attemptsLeft, MAX_ATTEMPTS, readAttempts, recordAttempt, } from "../tasks/attempts.js";
+import { MAX_LOG_LINES } from "../tasks/handoff.js";
+import { learnFromFailure } from "../tasks/learn.js";
+import { runDir, writeRunLog } from "../tasks/runs.js";
+import { setTaskStatus } from "../tasks/status.js";
+const REVIEW_FAILURES_FOR_LESSON = 2;
+export async function attemptOnce(ctx, run, prompt) {
+    const { capture } = run;
+    const backend = ctx.createBackend(isAgentBackend(capture.config.backend) ? capture.config.backend : "manual");
+    ctx.prompter.info(t("next.launching", { backend: backend.name }));
+    const startedAt = new Date();
+    const launched = await launch(ctx, run, startedAt, false, () => backend.run(prompt, { cwd: ctx.cwd, interactive: true }));
+    if (!launched.ok)
+        return notDone(ctx, capture);
+    const result = await gate(ctx, run);
+    await writeRunLog(ctx.cwd, capture.id, result.report);
+    const outcome = result.passed ? "done" : result.stage === "refused" ? "blocked" : "failed";
+    await record(ctx, run, startedAt, false, { outcome, gate: result });
+    if (result.passed)
+        return complete(ctx, capture);
+    if (outcome === "blocked")
+        return block(ctx, capture, result.reason ?? "");
+    await learnFromReviews(ctx, capture, result);
+    return notDone(ctx, capture);
+}
+export async function headlessLoop(ctx, run, first) {
+    const { capture } = run;
+    const backend = ctx.createBackend(capture.config.backend);
+    let left = await attemptsLeft(ctx.cwd, capture.id);
+    if (left === 0) {
+        const reason = t("next.budgetUsed", { max: MAX_ATTEMPTS });
+        await record(ctx, run, new Date(), true, { outcome: "blocked", reason });
+        return block(ctx, capture, reason);
+    }
+    let prompt = first;
+    let attempt = MAX_ATTEMPTS - left;
+    const timeoutMs = capture.config.agent.timeoutMinutes * 60_000;
+    while (left > 0) {
+        attempt++;
+        left--;
+        ctx.prompter.info(t("next.attempt", { attempt, max: MAX_ATTEMPTS, backend: backend.name }));
+        const startedAt = new Date();
+        const launched = await launch(ctx, run, startedAt, true, () => backend.run(prompt, { cwd: ctx.cwd, access: "edit", stream: ctx.print, timeoutMs }), left === 0);
+        if (!launched.ok) {
+            return left === 0 ? block(ctx, capture, launched.reason) : notDone(ctx, capture);
+        }
+        const result = await gate(ctx, run);
+        await writeRunLog(ctx.cwd, capture.id, `# Attempt ${attempt}\n\n${result.report}`);
+        const blocked = !result.passed && (result.stage === "refused" || (result.retryable && left === 0));
+        const outcome = result.passed ? "done" : blocked ? "blocked" : "failed";
+        await record(ctx, run, startedAt, true, { outcome, gate: result });
+        if (result.passed)
+            return complete(ctx, capture);
+        if (blocked)
+            return block(ctx, capture, result.reason ?? "");
+        if (!result.retryable)
+            return notDone(ctx, capture);
+        await learnFromReviews(ctx, capture, result);
+        prompt = renderPrompt(capturedPrompt(capture, "retry"), {
+            task: capture.task,
+            failure: result.report,
+            attempt: String(attempt),
+            task_path: capture.path,
+            max_log_lines: String(MAX_LOG_LINES),
+        });
+    }
+    return false;
+}
+async function launch(ctx, run, startedAt, headless, go, final = false) {
+    await markActive(ctx.cwd, run.capture.id);
+    const guard = await guardState(ctx.cwd);
+    let failure;
+    let failed = false;
+    try {
+        await go();
+    }
+    catch (error) {
+        failure = error;
+        failed = true;
+    }
+    run.tampered.push(...(await guard.verify()));
+    await setTaskStatus(ctx.cwd, capturedTask(run.capture), "in_progress");
+    if (!failed)
+        return { ok: true };
+    await enforceContract(ctx, run.capture, run.acceptance);
+    await clearActive(ctx.cwd);
+    const reason = failure instanceof Error ? failure.message : String(failure);
+    const outcome = final ? "blocked" : "failed";
+    await record(ctx, run, startedAt, headless, { outcome, stage: "agent", reason });
+    if (!(failure instanceof UserError))
+        throw failure;
+    ctx.prompter.warn(reason);
+    return { ok: false, reason };
+}
+async function gate(ctx, run) {
+    const result = await runGate(ctx, run);
+    await clearActive(ctx.cwd);
+    return result;
+}
+async function record(ctx, run, startedAt, headless, result) {
+    const stage = result.gate?.stage ?? result.stage;
+    const reason = result.gate?.reason ?? result.reason;
+    const skips = result.gate?.skips ?? [];
+    const accepted = run.acceptance.accepted.flatMap((finding) => (finding.id ? [finding.id] : []));
+    await recordAttempt(ctx.cwd, run.capture.id, {
+        startedAt: startedAt.toISOString(),
+        durationMs: Date.now() - startedAt.getTime(),
+        headless,
+        outcome: result.outcome,
+        ...(stage ? { stage } : {}),
+        regressions: result.gate?.regressions ?? [],
+        ...(reason ? { reason } : {}),
+        ...(skips.length > 0 ? { skips } : {}),
+        ...(accepted.length > 0 ? { accepted } : {}),
+    });
+}
+async function block(ctx, capture, reason) {
+    await setTaskStatus(ctx.cwd, capturedTask(capture), "blocked");
+    await learnFromFailure(ctx, capture, "blocked");
+    const path = displayPath(runDir(ctx.cwd, capture.id));
+    ctx.prompter.outro(t("next.blocked", { id: capture.id, path, reason }));
+    return false;
+}
+function notDone(ctx, capture) {
+    ctx.prompter.outro(t("next.notDone", { id: capture.id, command: `${CLI} next` }));
+    return false;
+}
+async function learnFromReviews(ctx, capture, result) {
+    if (result.stage !== "review")
+        return;
+    const failures = (await readAttempts(ctx.cwd, capture.id)).filter((attempt) => attempt.stage === "review");
+    if (failures.length >= REVIEW_FAILURES_FOR_LESSON) {
+        await learnFromFailure(ctx, capture, "review");
+    }
+}
+async function complete(ctx, capture) {
+    await setTaskStatus(ctx.cwd, capturedTask(capture), "done");
+    await saveCapture(ctx.cwd, { ...capture, finished: true });
+    ctx.prompter.outro(t("next.done", { id: capture.id, command: `${CLI} next` }));
+    return true;
+}