@trazum/cli 1.8.0

package/src/i18n/es.ts

@@ -0,0 +1,838 @@
+import type { CliMessages } from './types.js';
+
+/** "(hace 46 días)", o nada cuando no se sabe la antigüedad. */
+const hace = (days: number | null): string =>
+  days === null ? '' : days === 0 ? ' (hoy)' : days === 1 ? ' (hace 1 día)' : ` (hace ${days} días)`;
+
+
+/** Spanish catalogue. Mirrors `en.ts`; see that file for the contract. */
+export const es: CliMessages = {
+  locale: 'es',
+  numberLocale: 'es-ES',
+
+  help: (d, bold) => `${bold('trazum')} — reduce el coste de tus prompts sin perder lo que piden.
+
+${bold('USO')}
+  trazum optimize <fichero|-> [opciones]
+  trazum check <fichero|dir|-> --max-tokens <n> [opciones]
+  trazum baseline [dir] [opciones]
+  trazum eval <fichero> --cases <fichero> [opciones]
+  trazum eval <fichero> --cases <fichero> --export promptfoo -o suite.json
+  trazum diff <antes> <después> [opciones]
+  trazum diff --all <dir> <dir> [opciones]
+  trazum rank <dir> [opciones]
+  trazum doctor [dir] [opciones]
+  trazum blame <fichero> [opciones]
+  trazum prune <fichero> --cases <fichero> --yes
+  trazum where [fichero]
+  trazum models
+  trazum rules
+
+${bold('OPCIONES DE prune')}
+  --cases <fichero>           Una entrada por línea, o un array JSON. Obligatorio.
+  --yes                       Gasta las llamadas de verdad. Sin él se imprime la
+                              estimación y no se llama a nada.
+  --concurrency <n>           Llamadas en vuelo a la vez. Por defecto: 3.
+  --json                      La medición como datos.
+
+  Retira cada ejemplo few-shot por turnos y mide si las respuestas se mueven más
+  de lo que el prompt ya se mueve por su cuenta. La factura es
+  (2 + ejemplos) x casos, y por eso es el único comando que pregunta antes.
+
+  Informa de "sin efecto en estas entradas", nunca de "bórralo": un ejemplo puede
+  existir para un caso que tus entradas no contienen. No se edita nada.
+
+${bold('OPCIONES DE eval')}
+  --cases <fichero>           Una entrada por línea, o un array JSON. Obligatorio.
+  --level <safe|aggressive>   Qué reescritura juzgar. Por defecto: safe.
+  --concurrency <n>           Llamadas simultáneas. Por defecto: 3.
+  --export promptfoo          Escribe una suite de promptfoo en vez de ejecutar
+                              nada: los dos prompts, todos los casos, sin clave
+                              de API y sin gastar ninguna llamada. Las aserciones
+                              son tuyas: esto existe para la pregunta que la
+                              concordancia no puede contestar.
+  -o, --out <fichero>         Dónde escribirla. Por defecto, stdout.
+
+${bold('OPCIONES DE rank')}
+  --level <safe|aggressive>   Qué reglas cuentan como recuperables. Por defecto: safe.
+  --model, --calls,           Calcula el coste de los tokens recuperables, como
+  --output-tokens, --batch    en optimize.
+  --prompt <nombre>           Qué prompt marcado tomar de cada fichero de código.
+  --markdown-out <fichero>    Escribe además el ranking en Markdown, para el
+                              resumen de un job de CI o un comentario de PR.
+  --json                      El ranking como datos.
+
+  No hay puntuación. Los prompts se ordenan por lo que las reglas recuperarían
+  de verdad, midiéndolo al ejecutarlas; las demás columnas explican esa posición.
+
+${bold('OPCIONES DE doctor')}
+  --level <safe|aggressive>   Qué reglas contar. Por defecto: safe.
+  --model, --calls,           Calcula el coste de los hallazgos, igual que optimize.
+  --output-tokens, --batch
+  --prompt <nombre>           Qué prompt marcado tomar de cada fichero de código.
+  --otlp-out <fichero>        Escribe el reconocimiento como métricas OpenTelemetry
+                              (JSON OTLP/HTTP). Trazum escribe el fichero; tu
+                              pipeline lo envía.
+  --json                      El reconocimiento como datos.
+
+  Revisa un workspace completo: qué prompts no vigila nada, cuáles ya se pasan del
+  presupuesto y cuánto suman los avisos en todos ellos. Cada hallazgo es un aviso
+  que trazum optimize da en ese prompt por separado, así que cualquier línea se
+  puede comprobar contra un solo fichero. No hay puntuación.
+
+  Sale con 0 aunque encuentre cosas. trazum check es la puerta.
+
+${bold('OPCIONES DE blame')}
+  --limit <n>                 Revisiones a recorrer. Por defecto: 20, máximo 500.
+  --prompt <nombre>           Sigue un prompt marcado dentro de un fichero fuente,
+                              para que refactorizar los imports no cuente como
+                              crecimiento del prompt.
+  --model, --calls,           Calcula el coste del movimiento, igual que optimize.
+  --output-tokens, --batch
+  --markdown-out <fichero>    Escribe además el historial en Markdown, para el
+                              resumen de un job de CI o un comentario de PR.
+  --json                      El historial como datos.
+
+  Después de "--" las rutas se toman literales: trazum blame -- --nombre-raro.txt
+
+${bold('OPCIONES DE optimize')}
+  --level <safe|aggressive>   Agresividad de las reglas. Por defecto: safe.
+  --model <id>                Modelo para calcular el coste. Por defecto: ${d.model}.
+  --calls <n>                 Llamadas al mes. Por defecto: ${d.callsPerMonth}.
+  --output-tokens <n>         Tokens de salida medios. Por defecto: ${d.avgOutputTokens}.
+  --cache-hit-rate <0-1>      Tasa de acierto de caché estimada. Por defecto: ${d.cacheHitRate}.
+  --batch                     El trabajo tolera latencia (Batch API, 50% menos).
+  --disable <id,id>           Desactiva reglas concretas (ver "trazum rules").
+  --suggest                   Pide al LLM reescrituras a nivel de frase y las lista
+                              con lo que ahorra cada una. Por sí solo no cambia
+                              nada: cada propuesta se comprueba contra tu prompt y
+                              se descarta si no sobrevive.
+  --apply-suggestions         Las aplica. Solo con --suggest; a secas es un error,
+                              no un flag que se ejecuta sin hacer nada.
+  --cache-suggestions         Responde a --suggest desde una caché local cuando ya
+                              se preguntó por el mismo prompt, en vez de pagar otra
+                              vez la llamada. Desactivado por defecto: un acierto es
+                              lo que el modelo dijo la última vez, y eso debe
+                              elegirse. En $XDG_CACHE_HOME/trazum, 0600, 7 días.
+  --reorder                   Mueve las instrucciones estables delante del primer
+                              marcador, para que la caché de prompts las alcance. Esto
+                              MUEVE texto en vez de borrarlo: lee el diff y decide si
+                              el orden importaba. Se niega con cualquier bloque que
+                              haga referencia hacia atrás ("el texto anterior"), y
+                              dice qué frase lo ha impedido.
+  --llm                       Añade una pasada por el LLM configurado por entorno.
+  --exact-tokens              Cuenta tokens con la API oficial en vez de la heurística.
+  --tokens-only               Informa del ahorro de tokens y de ningún importe. Es
+                              lo que hace por defecto dentro de Claude Code, Codex
+                              o Cursor, donde una suscripción significa que no hay
+                              factura que reducir.
+  --cost                      Muestra el dinero también ahí: el host dice dónde se
+                              ejecuta Trazum, no a dónde va tu prompt.
+  --prompt <nombre>           Qué prompt marcado optimizar, cuando un fichero
+                              fuente tiene más de uno. Ver "trazum where".
+  --diff                      Muestra el diff línea a línea.
+  --json                      Vuelca el informe completo en JSON.
+  --locale <${d.locales.join('|')}>            Idioma del informe. Por defecto: el del sistema.
+  -o, --out <fichero>         Escribe el prompt optimizado a un fichero.
+  -h, --help                  Esta ayuda.
+  --clear-suggestion-cache    Vacía la caché de --cache-suggestions y dice cuánto
+                              ocupaba. Es un recado, no un modo: no necesita
+                              comando ni lee el config.
+
+${bold('OPCIONES DE check')}
+  --max-tokens <n>            Presupuesto de tokens de entrada. Obligatorio salvo que el config cubra el fichero.
+  --level <safe|aggressive>   Nivel al calcular si el prompt optimizado cabría.
+  --exact-tokens              Recuento exacto (necesita ANTHROPIC_API_KEY).
+  --json                      Resultado en JSON.
+  --markdown-out <fichero>    Escribe además el informe en Markdown, para el resumen
+                              de un job de CI o un comentario de pull request.
+  --baseline                  Aplica la línea base registrada. Activo por defecto siempre
+                              que el config declare una, así CI no necesita argumentos; la
+                              forma útil es --no-baseline, que la omite en una ejecución.
+
+  Pensado para CI: sale con código 1 si el prompt supera el presupuesto,
+  así una plantilla que crece sin control rompe la build en vez de la factura.
+
+  Si le das un directorio, comprueba todos los prompts que hay dentro contra
+  los patrones de "budgets" de ${bold('trazum.config.json')} — un solo paso de CI para
+  todo un repositorio de prompts. Un fichero que ningún patrón cubre sale
+  listado como sin presupuesto, no omitido en silencio, y una ejecución en la
+  que no se ha presupuestado nada es un error: "0 fallos" de una comprobación
+  que no ha medido nada es lo más engañoso que podría decirte.
+
+${bold('OPCIONES DE baseline')}
+  Registra lo que cuestan ahora mismo los prompts de un directorio, en un fichero
+  del que haces commit. Después "check" tumba la build cuando el repositorio se
+  desvía de él: la pregunta que los presupuestos no pueden responder, porque un
+  repositorio al 95% de todos sus presupuestos pasa siempre mientras un PR añade
+  cuatrocientos tokens repartidos en doce ficheros.
+
+  -o, --out <fichero>         Dónde escribirlo. Por defecto: baseline.path del config,
+                              o trazum.baseline.json.
+  --model, --calls, --output-tokens, --cache-hit-rate, --batch
+                              El escenario con el que se registra la cifra mensual. Se
+                              registra para que una comparación posterior pueda decir si el
+                              dinero es comparable — la puerta va en tokens, así que
+                              cambiar el precio de un modelo nunca tumba una build por sí solo.
+  --exact-tokens              Recuentos exactos (necesita ANTHROPIC_API_KEY).
+  --json                      Resultado en JSON.
+
+  Nunca falla. Registrar no es un veredicto, y un comando que pudiera fallar
+  mientras escribe aquello con lo que arreglarías el fallo es un bucle.
+
+${bold('OPCIONES DE eval')}
+  --cases <fichero>           Entradas a probar, una por línea o array JSON. Obligatorio.
+  --level <safe|aggressive>   Nivel con el que optimizar antes de comparar.
+  --concurrency <n>           Casos en paralelo. Por defecto: 3.
+  --json                      Resultado en JSON.
+
+  Ejecuta las dos versiones del prompt sobre tus casos y dice si la
+  optimización ha cambiado las respuestas. Cuesta TRES llamadas por caso: el
+  original dos veces, para medir la varianza propia del modelo, y el optimizado
+  una. Esa base es la vara de medir: sin ella, un porcentaje de divergencia no
+  significa nada. Sale con código 1 cuando las respuestas divergen de verdad.
+
+${bold('OPCIONES DE diff')}
+  --max-growth <n>            Falla si el prompt ha crecido más de n tokens.
+  --all                       Compara dos directorios de prompts, emparejados por
+                              ruta relativa. Los prompts que solo están en un lado
+                              se nombran, nunca se cuentan: una eliminación es una
+                              pregunta, no un ahorro. --max-growth se aplica
+                              entonces por prompt, no al total.
+  --optimized                 Mide lo que dejarían las reglas, no lo escrito.
+  --level <safe|aggressive>   Nivel para las reglas y los avisos.
+  --model <id>                Modelo con el que calcular el coste.
+  --calls <n>                 Llamadas al mes, para la cifra de coste.
+  --json                      Resultado en JSON.
+  --markdown-out <fichero>    Escribe además el informe en Markdown, para el resumen
+                              de un job de CI o un comentario de pull request.
+
+  Compara dos versiones de un prompt: cómo se ha movido el recuento de tokens,
+  cuánto cuesta eso, qué avisos ha introducido o resuelto la edición. Toda
+  cifra es un delta y positivo significa peor. Informa y sale con 0 salvo que
+  des --max-growth: decidir que crecer es inaceptable es cosa tuya, no nuestra.
+
+${bold('trazum where')}
+  Dice a qué proveedor van de verdad los prompts de un fichero, y cómo lo sabe:
+  un import del SDK, una base URL, un id de modelo entrecomillado, o "model=" en
+  un marcador trazum:prompt. Toda respuesta nombra la línea de la que sale.
+
+  Se niega cuando un fichero nombra dos proveedores en vez de elegir uno. Dos
+  respuestas no son una versión débil de una, y elegir en silencio es como
+  alguien acaba presupuestando contra el proveedor equivocado durante un mes.
+
+  Una base URL gana al SDK al que apunta: Moonshot, DeepSeek, xAI y Groq se
+  llaman con el SDK de OpenAI y otra base_url, así que tratarlo como
+  contradicción sería negarse a preciar un cliente perfectamente normal.
+
+  Sin fichero, informa solo de dentro de qué herramienta se ejecuta Trazum — y
+  avisa cuando esa herramienta cobra por suscripción, porque ahí un ahorro
+  mensual es aritmética sobre tokens, no dinero que recuperes.
+
+${bold('FICHERO DE CONFIGURACIÓN')}
+  ${bold('trazum.config.json')}, que se busca subiendo desde el directorio de trabajo
+  y parando en la raíz del repositorio. Todas las claves son opcionales:
+
+    level, locale, disable, maxGrowth, extensions
+    usage     { model, callsPerMonth, avgOutputTokens, cacheHitRate, batchEligible }
+    budgets   { "prompts/**": 2000, "prompts/system.txt": 4000 }
+    baseline  { "path": "trazum.baseline.json", "maxGrowthTokens": 0, "maxGrowthPct": 5 }
+    pricing   "./prices.json"   — correcciones locales de precios, ver abajo
+
+  Las opciones ganan al config; el config gana a los valores por defecto. Los
+  presupuestos se resuelven con el patrón más específico que encaje — gana el
+  que tenga más caracteres literales. Un booleano que el config haya activado se
+  desactiva con --no-<opción>, por ejemplo --no-batch.
+
+  ${bold('budgets')} es un techo; ${bold('baseline')} es una puerta. Uno pregunta si un
+  fichero cabe, la otra si el repositorio ha empeorado respecto al commit que
+  alguien registró con "trazum baseline". Un repositorio al 95% de todos sus
+  presupuestos pasa siempre, mientras un PR añade cuatrocientos tokens
+  repartidos en doce ficheros. Con baseline en el config, "check" sobre un
+  directorio lo lee y lo aplica sin ninguna opción: una puerta que exige
+  acordarse de pasar un argumento se ejecuta en la terminal del autor y no en
+  CI. Los umbrales van en tokens, nunca en dólares — si no, cambiar el precio de
+  un modelo tumbaría una build por algo que nadie tocó.
+
+  Un config que no valide es un error, incluida una clave desconocida. Un
+  parser permisivo restauraría los valores por defecto en silencio, y para un
+  presupuesto el valor por defecto es "sin presupuesto": una build en verde de
+  un prompt que nadie ha medido.
+
+  --config <fichero>          Usa este config en vez de buscar uno.
+
+${bold('PRECIOS')}
+  Los precios cambian en el calendario de otros, así que corregir uno no exige
+  actualizar Trazum. Un overlay de precios es un JSON que se superpone al
+  catálogo incluido:
+
+    { "lastReviewed": "2027-01-15",
+      "models": { "claude-opus-5": { "inputPerMTok": 6 } } }
+
+  Solo cambian los campos que nombres. Un modelo que no esté en el catálogo
+  incluido tiene que venir completo: uno definido a medias costaría cero por
+  algún lado y anunciaría un ahorro que no existe. "promo": null retira una
+  promoción.
+
+  Todo informe dice cuándo se han usado precios de overlay y qué modelos cubren:
+  una cifra del catálogo incluido y una de tu JSON son indistinguibles si no.
+
+  --pricing <fichero>         Usa este overlay, por delante del del config.
+  --pricing-live              Toma los precios de OpenRouter en vez de la tabla
+                              incluida: cifras de hoy para cientos de modelos de
+                              docenas de proveedores. Opt-in, porque es una llamada
+                              de red — el núcleo determinista no hace ninguna.
+                              Un fichero --pricing gana sobre esto.
+
+                              Esa fuente no publica si un modelo tiene caché de
+                              prompt ni el mínimo a partir del cual cachea. Así que
+                              los modelos que añade no reciben ningún consejo de
+                              caché, en vez de una suposición: afirmar que cachea
+                              ofrecería un ahorro que nadie puede comprar, y
+                              afirmar que no esconde el mayor ahorro que hay.
+
+${bold('LLM OPCIONAL')}
+  El núcleo es determinista y gratis. Con --llm se añade una pasada de
+  compresión semántica usando el proveedor que configures por entorno:
+
+    TRAZUM_LLM_PROVIDER   openai | anthropic          (por defecto: openai)
+    TRAZUM_LLM_BASE_URL   https://tu-llm/v1
+    TRAZUM_LLM_API_KEY    tu clave
+    TRAZUM_LLM_MODEL      identificador del modelo
+
+  El resultado del LLM solo se acepta si es más corto y conserva intacto
+  el código, las URLs y los marcadores de plantilla.
+
+${bold('IDIOMA')}
+  El idioma del informe sale de --locale, luego TRAZUM_LOCALE, luego LANG, y por
+  último del fichero de configuración — así un proyecto puede fijar el idioma en
+  el que se leen sus logs de CI sin pisar el idioma de quien está al teclado.
+  Solo cambia el informe: el mismo prompt se optimiza siempre igual.
+
+${bold('EJEMPLOS')}
+  trazum optimize prompt.txt --calls 50000 --diff
+  cat prompt.md | trazum optimize - --level aggressive --json
+  trazum optimize prompt.txt --reorder --diff
+  trazum optimize prompt.txt --llm -o prompt.optimizado.txt
+  trazum eval prompt.txt --cases casos.txt --level aggressive
+  trazum diff prompts/system.txt prompts/system.new.txt --max-growth 10
+  trazum check prompts/
+`,
+
+  cache: {
+    cleared: (entries: number, bytes: number, dir: string) =>
+      entries === 0
+        ? `No hay sugerencias en caché que eliminar (${dir}).`
+        : `Se eliminaron ${entries} ${entries === 1 ? 'respuesta' : 'respuestas'} en caché (${(bytes / 1024).toFixed(1)} KB) de ${dir}.`,
+    used: (hits: number, misses: number) =>
+      `Sugerencias: ${hits} desde la caché, ${misses} consultadas. Las respuestas en caché son lo que el modelo dijo la última vez; usa --clear-suggestion-cache para empezar de nuevo.`,
+  },
+
+  errors: {
+    livePricingFailed: (url: string, detail: string) =>
+      `No se han podido cargar los precios en vivo desde ${url}: ${detail}. Los precios incluidos siguen ahí — quita --pricing-live para usarlos.`,
+    optionNeedsValue: (name) => `La opción --${name} necesita un valor.`,
+    mustBeNonNegative: (name, raw) =>
+      `--${name} debe ser un número no negativo (recibido: "${raw}").`,
+    badLevel: (received) => `--level debe ser "safe" o "aggressive" (recibido: "${received}").`,
+    unknownRuleInDisable: (id) =>
+      `Regla desconocida en --disable: "${id}". Lista completa: trazum rules`,
+    unknownCommand: (command) => `Comando desconocido: "${command}". Prueba con "trazum --help".`,
+    missingInputFile: () =>
+      'Falta el fichero de entrada. Usa "-" para leer de la entrada estándar.',
+    applyNeedsSuggest: () =>
+      '--apply-suggestions no tiene nada que aplicar sin --suggest. Por su cuenta habría '
+      + 'funcionado en silencio sin cambiar nada, y eso no es una respuesta.',
+    llmNotConfigured: () =>
+      'Has pedido --llm pero no hay proveedor configurado.\n' +
+      'Define TRAZUM_LLM_BASE_URL y TRAZUM_LLM_MODEL (endpoint compatible con OpenAI),\n' +
+      'o TRAZUM_LLM_PROVIDER=anthropic con TRAZUM_LLM_API_KEY.',
+    exactTokensNeedsKey: () => '--exact-tokens necesita ANTHROPIC_API_KEY en el entorno.',
+    checkNeedsMaxTokens: () => 'trazum check necesita --max-tokens <n>.',
+    evalNeedsCases: () => 'trazum eval necesita --cases <fichero>.',
+    unknownExportFormat: (received, allowed) =>
+      `Formato de exportación desconocido "${received}". Disponibles: ${allowed}.`,
+    evalNoCases: (path) => `No se ha encontrado ningún caso en "${path}".`,
+    unknownFlag: (name, allowed) =>
+      `Opción desconocida --${name}. Este comando acepta: ${allowed}.`,
+    unknownFlagDidYouMean: (name, suggestion) =>
+      `Opción desconocida --${name}. ¿Querías decir --${suggestion}?`,
+    diffNeedsTwoFiles: () =>
+      'trazum diff necesita dos ficheros: trazum diff <antes> <después>.',
+    cannotNegate: (name) => `--no-${name} no tiene sentido: --${name} lleva un valor.`,
+    noPromptsFound: (directory, extensions) =>
+      `No hay ficheros de prompt en "${directory}". Se han buscado: ${extensions}.`,
+    noBudgetsApply: (directory, configFile) =>
+      `Ningún presupuesto cubre nada dentro de "${directory}". Añade uno en ${configFile}, en "budgets", o pasa --max-tokens. ` +
+      'Decir "0 fallos" de unos ficheros que nadie ha medido sería peor que este error.',
+    baselineMissing: (path) =>
+      `El config declara una l\u00ednea base en "${path}" y no est\u00e1. Registra una con "trazum baseline" y hazle commit. Es un error y no una comprobaci\u00f3n omitida: una puerta que el config ha pedido y no se ha podido ejecutar no es un aprobado.`,
+    baselineTooBig: (path, limit) =>
+      `"${path}" supera el l\u00edmite de ${limit} bytes para una l\u00ednea base. En esa ruta hay algo que no es una l\u00ednea base.`,
+    errorLabel: () => 'Error',
+  },
+
+  report: {
+    inputTokens: () => 'Tokens de entrada',
+    estimated: (offFamily) =>
+      offFamily === null
+        ? ' (estimado, ±15%)'
+        : ` (estimado — el contador está calibrado sobre Claude, no sobre ${offFamily})`,
+    exactCount: () => ' (recuento exacto)',
+    rulesApplied: () => 'Reglas aplicadas',
+    nothingToTrim: () => '  Ninguna regla ha encontrado nada que recortar.',
+    dictionaryCoverage: (languages) =>
+      `  Los diccionarios de frases cubren ${languages}. Un prompt en otro idioma `
+      + 'no es necesariamente eficiente: puede ser simplemente uno que Trazum '
+      + 'todavía no sabe leer.',
+    levelAggressive: () => '[agresiva]',
+    levelSafe: () => '[segura]',
+    ruleHits: (hits, tokensSaved) => `(${hits}×, ~${tokensSaved} tokens)`,
+    moreChanges: (count) => `+${count} más sin mostrar`,
+    llmPass: () => 'Pasada por LLM',
+    examplesReview: () => 'Ejemplos que el modelo considera redundantes',
+    examplesReviewNote: (provider, model, count) =>
+      `${count} ejemplos revisados por ${provider}/${model}. Es una sugerencia que leer, no un cambio hecho.`,
+    exampleRedundant: (redundant, keep) =>
+      `El ejemplo ${redundant.map((i) => i + 1).join(', ')} repite el ejemplo ${keep + 1}`,
+    llmApplied: (provider, model, before, after) =>
+      `aplicada vía ${provider}/${model}: ${before} → ${after} tokens`,
+    llmRejected: (reason) => `descartada: ${reason}`,
+    costWith: (modelName) => `Coste con ${modelName}`,
+    usageLine: (calls, outputTokens, batch) =>
+      `${calls} llamadas/mes · ${outputTokens} tokens de salida por llamada${
+        batch ? ' · Batch API' : ''
+      }`,
+    perMonthSaving: (saving, pct) => `ahorro ${saving}/mes (${pct}%)`,
+    beyondShortening: () => 'Además de acortar el prompt',
+    biggestLever: () => 'Empieza por aquí:',
+    biggestLeverDetail: (title, amount, times) =>
+      // El título conserva sus mayúsculas: pasarlo a minúsculas convertía
+      // "Claude Opus 5" en "claude opus 5", un nombre de producto destrozado.
+      `"${title}" — ${amount}/mes` +
+      (times !== null && times >= 2 ? `, ${times}× lo que han ahorrado las reglas.` : '.'),
+    perMonthSuffix: (amount) => ` ~${amount}/mes`,
+    diff: () => 'Diff',
+    tokensOnlyHeading: (host) => `Qué ganas con esto en ${host}`,
+    tokensOnlyWhy: (host) =>
+      `${host} cobra por suscripción, así que no hay factura que reducir ni cifra mensual que imprimir.`,
+    tokensOnlyAsked: () => 'Costes ocultos porque has pedido solo tokens.',
+    tokensSaved: (tokens) =>
+      `${tokens} token${tokens === '1' ? '' : 's'} de vuelta, en cada llamada.`,
+    windowUse: (before, after, model, window) =>
+      `Ventana de contexto: ${before} → ${after} de los ${window} tokens de ${model} — sitio que se lleva la conversación.`,
+    tokensOnlyCost: () => 'Usa --cost si este prompt va a una API de pago por uso.',
+    pricingOverlaid: (models, lastReviewed) =>
+      `Los precios de ${models} vienen de un overlay local revisado el ${lastReviewed}, no del catálogo incluido.`,
+    reorderHeading: () => 'Reordenado para la caché',
+    reorderMoved: (blocks, tokens) =>
+      `Se ${
+        blocks === 1 ? 'ha movido 1 bloque' : `han movido ${blocks} bloques`
+      } (~${tokens} tokens) delante del primer marcador.`,
+    reorderPrefix: (before, after) => `Prefijo cacheable ${before} → ${after} tokens.`,
+    reorderDeclined: (count) =>
+      `Se ${
+        count === 1 ? 'ha dejado 1 bloque donde estaba' : `han dejado ${count} bloques donde estaban`
+      }:`,
+    reorderDeclinedRef: (phrase, excerpt) => `hace referencia hacia atrás ("${phrase}"): ${excerpt}`,
+    reorderDeclinedAfter: (excerpt) => `va después de un bloque que tenía que quedarse: ${excerpt}`,
+    reorderDeclinedScript: (script) =>
+      `este prompt está escrito en ${script}, y Trazum no tiene frases de referencia hacia ` +
+      `atrás para ese alfabeto. No puede distinguir "resume el texto de arriba" de una ` +
+      `instrucción que sí se puede mover, así que no ha movido nada. Añadir un idioma es ` +
+      `añadir un array a phrases.ts.`,
+    reorderDeclinedMore: (count) => `…y ${count} más, en el fichero de salida.`,
+    reorderPiped: (moved, tokens, declined) => {
+      const head =
+        moved === 0
+          ? 'no se ha podido mover nada con seguridad'
+          : `se ${
+              moved === 1 ? 'ha movido 1 bloque' : `han movido ${moved} bloques`
+            } (~${tokens} tokens) al prefijo cacheable`;
+      const tail =
+        declined === 0
+          ? ''
+          : `; ${
+              declined === 1 ? 'se ha dejado 1 bloque' : `se han dejado ${declined} bloques`
+            } en su sitio`;
+      return `trazum: ${head}${tail}. Ejecuta sin redirigir la salida para ver los motivos.`;
+    },
+    reorderNothing: () => 'No se ha podido mover nada con seguridad.',
+    suggestHeading: () => 'Reescrituras sugeridas',
+    suggestOffered: (count, tokens) =>
+      `${count} ${count === 1 ? 'frase podría decir' : 'frases podrían decir'} lo mismo con ~${tokens} tokens menos:`,
+    suggestApplied: (count, tokens) =>
+      `Aplicadas ${count} ${count === 1 ? 'reescritura' : 'reescrituras'} (~${tokens} tokens). Lee el diff.`,
+    suggestNothing: (provider, model) =>
+      `${provider} (${model}) no ha encontrado nada que reescribir que las reglas no hubieran cogido ya.`,
+    suggestRejected: (count) =>
+      `${count} ${count === 1 ? 'propuesta no ha superado' : 'propuestas no han superado'} la comprobación contra tu prompt.`,
+    suggestRemoved: () => '(eliminado)',
+    suggestHowToApply: () => 'No se ha cambiado nada. Añade --apply-suggestions para aplicarlas.',
+    reorderReview: () =>
+      'Lee el diff: esto ha movido texto en vez de borrarlo, así que la pregunta es si el orden importaba.',
+    diffTooLarge: (lines, max) =>
+      `  Diff omitido: ${lines} líneas supera el límite de ${max}, y alinearlas costaría más memoria de lo que vale la respuesta.`,
+    wroteTo: (path) => `Prompt optimizado escrito en ${path}`,
+  },
+
+  where: {
+    hostHeading: () => 'Ejecutándose dentro de',
+    subscription: (host) =>
+      `${host} cobra por suscripción, no por token. Un ahorro mensual de los de abajo es aritmética sobre tokens, no dinero que recuperes: lo que ganas es margen de ventana de contexto y de rate limit.`,
+    noTarget: () => 'Pasa un fichero fuente para ver a qué proveedor van sus prompts.',
+    sourceHeading: (path) => `Los prompts de ${path} van a`,
+    conflict: () => 'No se puede saber: el fichero nombra más de un proveedor.',
+    conflictFallback: () =>
+      'No se ha asumido nada. Define "usage.model" en trazum.config.json, o pasa --model.',
+    nothingFound: () => 'Nada en este fichero dice a qué proveedor llama.',
+    providerOnly: () => ' (solo el proveedor — nada nombra un modelo)',
+    evidenceLine: (line, kind, detail) => `línea ${line}  ${kind}: ${detail}`,
+    pricedAs: () => 'Se cobra como',
+    fromConfig: () => '(de trazum.config.json)',
+    fromDetection: () => '(leído del código)',
+    fromProviderDefault: (provider) =>
+      `(${provider} se ha leído del código; nada nombra un modelo, así que este es el suyo)`,
+    fromDefault: () => '(el valor por defecto — nada dijo otra cosa)',
+  },
+
+  pricing: {
+    liveLoaded: (added: number, refreshed: number, skipped: number) =>
+      `Precios en vivo: ${refreshed} actualizados, ${added} modelos añadidos, ${skipped} descartados por no traer precio o ventana de contexto utilizables. Esta fuente no publica los mínimos de caché, así que el consejo de caché se omite para los modelos añadidos.`,
+  },
+
+  models: {
+    title: () => 'Modelos y precios',
+    unit: () => '  (USD por millón de tokens)',
+    reviewedOn: (date, days) =>
+      `  Tabla revisada el ${date}${hace(days)}. Verifica antes de presupuestar.`,
+    columns: {
+      model: 'modelo',
+      input: 'entrada',
+      output: 'salida',
+      context: 'contexto',
+      cacheMin: 'mín. caché',
+    },
+    promoNote: () => '  Los precios entre paréntesis son el precio tras acabar la promoción.',
+    cacheNote: () =>
+      '  Caché: leer cuesta el 10% de la entrada; escribir, el 125% (5 min) o 200% (1 h).',
+    batchNote: () => '  Batch API: 50% de descuento sobre entrada y salida.',
+  },
+
+  rank: {
+    heading: (root, count) =>
+      `${count} ${count === 1 ? 'prompt' : 'prompts'} en ${root}, primero los más recuperables`,
+    subheading: (model, calls) => `Calculado con ${model} y ${calls} llamadas al mes.`,
+    columns: {
+      recoverable: 'Recupera',
+      tokensBack: 'Tokens',
+      tokens: 'Tamaño',
+      density: 'Tok/fra',
+      notes: 'Prompt',
+    },
+    noteExamples: (count, tokens) => `${count} ejemplos, ~${tokens} tokens`,
+    noteFormat: (tokens) => `~${tokens} tokens repitiendo el formato de salida`,
+    noteProtected: (pct) => `el ${pct}% es código o URLs, que no se pueden recortar`,
+    skipped: (count) =>
+      `Se ${count === 1 ? 'ha omitido' : 'han omitido'} ${count} fichero${count === 1 ? '' : 's'} de código sin marcador `
+      + '`// trazum:prompt`: sus prompts no están en este ranking.',
+    densityNote: () =>
+      'Tok/fra son tokens por frase: verbosidad independiente de la longitud. No hay puntuación: cada columna es una medida que puedes comprobar contra el fichero.',
+    recoverableNote: () =>
+      'Recupera es lo que quitarían las reglas deterministas en este nivel, valorado con el perfil de uso, con el número de tokens al lado: ahorrar un token son veinticinco céntimos y ningún trabajo que merezca la pena. Se obtiene ejecutando las reglas, no con una fórmula.',
+  },
+
+  blame: {
+    heading: (path, revisions) =>
+      `${path} — ${revisions} ${revisions === 1 ? 'revisión' : 'revisiones'}`,
+    notARepository: () =>
+      'blame lee el historial de un fichero desde git, y este directorio no está dentro de un repositorio.',
+    outsideRepository: (path) =>
+      `${path} está fuera del repositorio, así que no hay historial que leer.`,
+    noHistory: (path) => `git no tiene commits que toquen ${path}.`,
+    gitMissing: () => 'git no está en el PATH, y blame no tiene de dónde leer el historial.',
+    columns: { when: 'Fecha', tokens: 'Tokens', change: 'Cambio', who: 'Autor', commit: 'Commit' },
+    net: (first, last, delta, pct) =>
+      `Neto en este historial: ${first} → ${last} tokens (${delta}, ${pct}).`,
+    netCost: (amount, model, calls) =>
+      `Ese movimiento son ${amount} al mes en ${model} con ${calls} llamadas.`,
+    biggestRise: () => 'Mayor subida en un solo commit',
+    biggestRiseDetail: (tokens, author, subject, sha) =>
+      `+${tokens} tokens — ${author}, "${subject}" (${sha})`,
+    addedAt: () => 'añadido',
+    goneAt: () => 'no existía',
+    truncated: (shown) =>
+      `Mostrando las ${shown} más recientes. Usa --limit para ver más.`,
+    followedRename: (from) => `Se ha seguido un renombrado: las revisiones anteriores son ${from}.`,
+    estimateNote: () =>
+      'Los recuentos son estimaciones (±15%). Lo que importa es la tendencia, no las cifras absolutas.',
+  },
+
+  languages: {
+    and: 'y',
+    en: 'inglés',
+    es: 'español',
+    fr: 'francés',
+    de: 'alemán',
+    pt: 'portugués',
+    it: 'italiano',
+    nl: 'neerlandés',
+  },
+
+  rules: {
+    title: () => 'Reglas disponibles',
+    disableHint: () => '  Desactiva las que no quieras con --disable id1,id2',
+  },
+
+
+  doctor: {
+    heading: (root, prompts) => `${root} — ${prompts} prompt${prompts === 1 ? '' : 's'}`,
+    subheading: (model, calls) => `Con precios de ${model} y ${calls} llamadas al mes.`,
+    pricesReviewed: (date, days) => `Precios revisados el ${date}${hace(days)}.`,
+    budgetsHeading: () => 'Presupuestos',
+    everyPromptBudgeted: (count) =>
+      count === 1
+        ? 'El prompt tiene presupuesto y está dentro.'
+        : `Los ${count} prompts tienen presupuesto y están dentro.`,
+    unbudgeted: (count, total) =>
+      `${count} de ${total} prompt${count === 1 ? '' : 's'} sin presupuesto, así que nada los vigila`,
+    overBudget: (count) =>
+      count === 1
+        ? '1 prompt ya se pasa de su presupuesto — trazum check fallaría con él'
+        : `${count} prompts ya se pasan de su presupuesto — trazum check fallaría con ellos`,
+    andMore: (count) => `y ${count} más`,
+    findingsHeading: () => 'Qué merecería la pena arreglar',
+    acrossPrompts: (count) => `${count} prompt${count === 1 ? '' : 's'}`,
+    findingsNote: () =>
+      'Cada línea es el mismo aviso que trazum optimize da en esos prompts, sumado. '
+      + 'Ejecútalo sobre cualquiera de ellos para ver la cifra por separado.',
+    notAGate: () =>
+      'Nada de esto hace fallar un build. trazum check es la puerta; esto es el '
+      + 'reconocimiento — la recomendación de modelo es una heurística de palabras clave, '
+      + 'y un build que dependa de una enseña a repetir hasta que salga verde.',
+
+    sharedPrefixHeading: () => 'Preámbulos que podrían compartir caché y no lo hacen',
+    sharedPrefixGroup: (count, tokens, drift) =>
+      `${count} prompts empiezan con el mismo preámbulo de ${tokens} tokens, `
+      + (drift === 'whitespace'
+        ? 'y solo difieren en espaciado'
+        : 'y difieren en redacción, mayúsculas o puntuación'),
+    sharedPrefixFix: (drift) =>
+      drift === 'whitespace'
+        ? 'Lo arregla un formateador: el texto ya coincide, el espaciado no.'
+        : 'Alguien tiene que elegir una redacción — difiere el texto, no solo su espaciado.',
+    sharedPrefixNoFigure: () =>
+      'No se adjunta cifra, a propósito. El caché compara bytes, así que estos prompts '
+      + 'ocupan una entrada cada uno en lugar de una entre todos — pero lo que eso cuesta '
+      + 'depende de cómo se reparten las llamadas dentro del grupo, y Trazum aplica un '
+      + 'único --cache-hit-rate a todos. Cifrarlo sería inventarse tu tráfico.',
+  },
+
+  prune: {
+    needsExamples: () =>
+      'Este prompt tiene menos de dos ejemplos few-shot, así que no hay nada que comparar.',
+    estimate: (examples, cases, calls) =>
+      `${examples} ejemplos × ${cases} casos: ${calls} llamadas al proveedor `
+      + `(2 de referencia por caso, y luego una por ejemplo retirado).`,
+    needsConsent: () =>
+      'No se ha llamado a nada. Añade --yes para gastarlo. Es el único comando que '
+      + 'pregunta, porque es el único cuya factura crece con la longitud de tu prompt.',
+    heading: (model) => `Qué hace cada ejemplo, medido en ${model}`,
+    selfAgreement: (pct) =>
+      `El prompt coincide consigo mismo el ${pct} de las veces. Ese es el patrón de medida: `
+      + 'una retirada que mueva la respuesta menos que eso no movió nada atribuible al ejemplo.',
+    line: (n, tokens, pct) => `ejemplo ${n} — ${tokens} tokens, ${pct} de coincidencia sin él`,
+    verdictNeeded: () => 'hace falta aquí',
+    verdictRecoverable: () => 'sin efecto en estas entradas',
+    verdictUnknown: () => 'no concluyente',
+    recoverable: (tokens) =>
+      `${tokens} tokens están en ejemplos cuya retirada no cambió nada medible aquí.`,
+    caveat: () =>
+      'Lo cual no es lo mismo que "bórralos". Un ejemplo puede existir para un caso que '
+      + 'estas entradas no contienen — la condición límite que alguien encontró en '
+      + 'producción y para la que añadió una demostración. Esto mide las entradas que le '
+      + 'diste, y solo tú sabes si cubren lo que importa. No se ha editado nada.',
+  },
+
+  eval: {
+    nothingToCompare: () =>
+      'Las reglas no han cambiado nada en este prompt, así que no hay nada que comparar. Prueba con --level aggressive.',
+    starting: (cases, calls, model) =>
+      `Ejecutando ${cases} casos con ${model}: ${calls} llamadas (el original dos veces por caso, para medir su propia varianza, y el optimizado una).`,
+    heading: () => 'Coincidencia',
+    selfAgreement: (pct) => `${pct}  del prompt original consigo mismo  ${'\u2190'} la vara de medir`,
+    crossAgreement: (pct) => `${pct}  del prompt optimizado con el original`,
+    verdict: (kind) =>
+      ({
+        indistinguishable: {
+          label: 'Indistinguible',
+          detail: 'Todas las respuestas coinciden. Sobre este conjunto, la optimización no ha cambiado nada.',
+        },
+        'within-noise': {
+          label: 'Dentro del propio ruido del modelo',
+          detail:
+            'El prompt optimizado discrepa del original más o menos tanto como el original discrepa de sí mismo, así que la diferencia no es atribuible a la reescritura. Amplía el conjunto antes de fiarte.',
+        },
+        diverges: {
+          label: 'Diverge',
+          detail:
+            'El modelo es consistente consigo mismo y bastante menos con la reescritura, así que la optimización ha cambiado lo que pide el prompt. Lee los casos de abajo y el diff antes de subir esto.',
+        },
+        inconclusive: {
+          label: 'No concluyente',
+          detail:
+            'El prompt original no coincide consigo mismo lo suficiente como para juzgar nada contra él. Baja la temperatura, o puede que la tarea sea demasiado abierta para esta prueba.',
+        },
+      })[kind],
+    mostChanged: () => 'Casos que más han cambiado',
+    caseAgreement: (cross, self) => `${cross} de coincidencia con el original (que consigo mismo dio ${self})`,
+    exportWarnings: (count) =>
+      `${count} ${count === 1 ? 'cosa' : 'cosas'} que saber antes de fiarte de la ejecución:`,
+    exportWrote: (path, cases, assertions) =>
+      `Escrito ${path}: dos prompts, ${cases} ${cases === 1 ? 'caso' : 'casos'}, ` +
+      `${assertions === 0 ? 'sin aserciones' : `${assertions} aserción${assertions === 1 ? '' : 'es'} (el prompt pide JSON)`}. ` +
+      `Añade las tuyas y ejecuta: npx promptfoo eval -c ${path}`,
+    callsMade: (count) => `${count} llamadas al proveedor.`,
+  },
+
+
+  diff: {
+    heading: (before, after) => `${before} → ${after}`,
+    measuringOptimised: () =>
+      'Midiendo lo que dejarían las reglas, no lo que está escrito.',
+    monthly: (delta, calls, model) =>
+      `${delta}/mes con ${calls} llamadas y ${model}`,
+    advisoriesAppeared: () => 'Problemas nuevos',
+    advisoriesResolved: () => 'Resueltos',
+    rulesNewlyFiring: () => 'Reglas que ahora encuentran algo:',
+    rulesNoLongerFiring: () => 'Reglas que ya no encuentran nada:',
+    overLimit: (delta, max) =>
+      `Ha crecido ${delta} tokens, por encima del límite de ${max}.`,
+    someOverLimit: (count, max) =>
+      `${count} prompt${count === 1 ? '' : 's'} por encima del límite por prompt de ${max} tokens:`,
+    allSubheading: (prompts) => `${prompts} prompt${prompts === 1 ? '' : 's'} en ambos lados.`,
+    allTotal: (delta, prompts) =>
+      `${delta} tokens en ${prompts} prompt${prompts === 1 ? '' : 's'}`,
+    signConvention: () =>
+      'Toda cifra es después menos antes, así que positivo significa peor — lo contrario que en el resto de Trazum.',
+    onlyBefore: () => 'solo antes ',
+    onlyAfter: () => 'solo después',
+    onlyOneSideNote: () =>
+      'No entran en los totales. Un prompt que desaparece es una pregunta, no un ahorro.',
+  },
+
+  markdown: {
+    checkHeading: (target) => `Trazum — presupuestos de tokens en ${target}`,
+    baselineGrew: (delta, pct) => `Esta rama a\u00f1ade ${delta} tokens (${pct}) a los prompts de aqu\u00ed`,
+    baselineShrank: (delta, pct) => `Esta rama quita ${delta} tokens (${pct}) de los prompts de aqu\u00ed`,
+    baselineUnchanged: () => 'Sin cambios frente a la l\u00ednea base registrada',
+    baselineOverLimit: (limits) => `supera el l\u00edmite de ${limits}`,
+    baselineLimitTokens: (limit) => `${limit} tokens`,
+    baselineLimitPct: (limit) => `${limit}%`,
+    baselineColumnBefore: () => 'L\u00ednea base',
+    baselineColumnAfter: () => 'Ahora',
+    baselineMoney: (before, after, delta) => `Coste mensual **${before} \u2192 ${after}** (${delta})`,
+    baselineMoneyIncomparable: () =>
+      'El escenario o el cat\u00e1logo de precios han cambiado desde que se registr\u00f3 la l\u00ednea base, as\u00ed que las dos cifras mensuales no son la misma medida y aqu\u00ed no se restan. La comparaci\u00f3n de tokens de arriba no se ve afectada.',
+    baselineReRecord: (command, path) =>
+      `Si este crecimiento es intencionado, vuelve a registrar con \`${command}\` y haz commit de \`${path}\`.`,
+    diffHeading: (before, after) => `Trazum — ${before} → ${after}`,
+    rankHeading: (root, count) =>
+      `Trazum — qué arreglar primero en ${root} (${count} ${count === 1 ? "prompt" : "prompts"})`,
+    blameHeading: (path) => `Trazum — historial de tokens de ${path}`,
+    rankLevel: (level) => `Medido al nivel de reglas \`${level}\`.`,
+    columnFile: () => 'Prompt',
+    columnTokens: () => 'Tokens',
+    columnBudget: () => 'Presupuesto',
+    columnMetric: () => 'Métrica',
+    columnChange: () => 'Cambio',
+    allWithin: (budgeted) =>
+      budgeted === 1
+        ? 'El prompt está dentro de presupuesto.'
+        : `Los ${budgeted} prompts con presupuesto están dentro de presupuesto.`,
+    overBudget: (failures, budgeted) => `${failures} de ${budgeted} por encima del presupuesto`,
+    noBudget: () => '—',
+    unbudgetedNote: (count) =>
+      count === 1
+        ? 'Hay 1 prompt que ningún patrón de presupuesto cubre, así que nadie lo está vigilando.'
+        : `Hay ${count} prompts que ningún patrón de presupuesto cubre, así que nadie los está vigilando.`,
+    whatWouldHelp: () => 'Qué ayudaría',
+    wouldFit: (level, optimizedTokens) =>
+      `optimizar con \`${level}\` lo dejaría en ~${optimizedTokens} tokens, y sí cabría`,
+    stillTooBig: (optimizedTokens) =>
+      `ni optimizado cabe (~${optimizedTokens} tokens): hay que recortar contenido a mano`,
+    truncated: () =>
+      'Se ha parado antes de tiempo: el directorio supera el límite de recorrido, así que esto no es el cuadro completo.',
+    footer: (source, level) => `Recuento de tokens ${source} · nivel de reglas \`${level}\``,
+    pricingOverlaid: (count, lastReviewed) =>
+      `Los precios de ${count} ${count === 1 ? 'modelo' : 'modelos'} vienen de un overlay local revisado el ${lastReviewed}.`,
+    sourceEstimated: () => 'estimado, ±15%',
+    sourceExact: () => 'exacto',
+    measuringOptimised: () =>
+      'Se mide lo que dejarían las reglas, no lo que está escrito en el fichero.',
+    metricTokens: (before, after) => `Tokens de entrada (${before} → ${after})`,
+    metricMonthly: (calls, model) => `Coste al mes con ${calls} llamadas y ${model}`,
+    deltaConvention: () =>
+      'Toda cifra es un delta: después menos antes, así que <strong>positivo significa peor</strong>. ' +
+      'Es lo contrario que en el resto de Trazum, donde toda cifra es un ahorro.',
+    advisoriesAppeared: () => 'Problemas que ha introducido esta edición',
+    advisoriesResolved: () => 'Problemas que ha resuelto esta edición',
+    rulesNewlyFiring: () => 'Reglas que ahora encuentran algo',
+    rulesNoLongerFiring: () => 'Reglas que ya no encuentran nada',
+    collapsedNote: () => 'nada por encima del presupuesto, despliega para ver las cifras',
+    trimNotice: () =>
+      '_Recortado para que quepa en un comentario. El informe completo está en el resumen de la ejecución._',
+    commentTitle: () => 'Trazum',
+  },
+
+  check: {
+    okLabel: () => 'OK',
+    embeddedHeading: (path, count) =>
+      `${path} — ${count} ${count === 1 ? 'prompt marcado' : 'prompts marcados'}`,
+    declinedHeading: (count) =>
+      `No se ${count === 1 ? 'ha podido leer 1 marcador' : `han podido leer ${count} marcadores`}:`,
+    declinedAt: (line, detail) => `línea ${line}: ${detail}`,
+    failedLabel: () => 'FALLO',
+    ok: (tokens, budget) => `${tokens} tokens dentro del presupuesto de ${budget}.`,
+    failed: (tokens, budget) => `${tokens} tokens supera el presupuesto de ${budget}.`,
+    wouldFit: (level, optimizedTokens) =>
+      `  Optimizado con "trazum optimize --level ${level}" quedaría en ~${optimizedTokens} tokens y sí cabría.`,
+    stillTooBig: (optimizedTokens) =>
+      `  Ni optimizado cabe (~${optimizedTokens} tokens): hay que recortar contenido a mano.`,
+    directoryHeading: (directory, files) =>
+      `${directory} — ${files} ${files === 1 ? 'prompt' : 'prompts'}`,
+    directorySummary: (failures, files) =>
+      failures === 0
+        ? `Los ${files} dentro de presupuesto.`
+        : `${failures} de ${files} por encima del presupuesto.`,
+    noBudget: () => '(sin presupuesto)',
+    walkTruncated: () =>
+      'Se ha parado antes de tiempo: el directorio supera el límite de recorrido, así que esto no es el cuadro completo.',
+    exactCountsCost: (files) =>
+      `Contando ${files} ${files === 1 ? 'fichero' : 'ficheros'} con la API, una llamada por cada uno. Esto tarda un momento.`,
+  },
+  baseline: {
+    recorded: (path, files, tokens) =>
+      `Registrados ${files} prompts, ${tokens} tokens, en ${path}. Haz commit: la puerta compara el \u00e1rbol con lo que est\u00e9 commiteado.`,
+    recordedMoney: (monthly, model, calls) =>
+      `Son ${monthly} al mes con ${model} y ${calls} llamadas. Es informativo, no la puerta: los umbrales van en tokens, as\u00ed que cambiar el precio de un modelo nunca tumba una build por s\u00ed solo.`,
+    heading: () => 'Frente a la l\u00ednea base',
+    unchanged: (tokens) => `sin cambios, ${tokens} tokens`,
+    grew: (delta, pct, tokens) => `ha crecido ${delta} tokens (${pct}) hasta ${tokens}`,
+    shrank: (delta, pct, tokens) => `ha bajado ${delta} tokens (${pct}) hasta ${tokens}`,
+    entry: (path, before, after, delta) => `${path}  ${before} \u2192 ${after}  (${delta})`,
+    addedHeading: (count) => `Nuevos desde la l\u00ednea base (${count})`,
+    removedHeading: (count) => `Desaparecidos desde la l\u00ednea base (${count})`,
+    grownHeading: (count) => `Han crecido (${count})`,
+    breachTokens: (actual, limit) =>
+      `un crecimiento de ${actual} tokens supera el l\u00edmite de ${limit}`,
+    breachPct: (actual, limit) => `un crecimiento de ${actual} supera el l\u00edmite de ${limit}`,
+    reRecord: (path) =>
+      `Si el crecimiento es intencionado, vuelve a registrar con "trazum baseline" y haz commit de ${path}.`,
+    money: (before, after, delta) => `Coste mensual ${before} \u2192 ${after} (${delta})`,
+    moneyIncomparableScenario: () =>
+      'El escenario de uso ha cambiado desde que se registr\u00f3 la l\u00ednea base, as\u00ed que las dos cifras mensuales no son la misma medida. La comparaci\u00f3n de tokens no se ve afectada.',
+    moneyIncomparablePricing: (was, now) =>
+      `Los precios se revisaron el ${was} cuando se registr\u00f3 la l\u00ednea base y el ${now} ahora, as\u00ed que las cifras mensuales no son la misma medida. La comparaci\u00f3n de tokens no se ve afectada.`,
+  },
+};