@trazum/cli 1.40.0 → 1.42.0

package/src/i18n/es.ts

@@ -29,6 +29,8 @@ ${bold('USO')}
   trazum plan <log.jsonl|dir> [opciones]
   trazum verify <plan.json> --against <nuevo.jsonl|dir> [opciones]
   trazum history <dir-de-informes-guardados> [opciones]
+  trazum connect <anthropic|openai> [opciones]
+  trazum store [--prune] [opciones]
   trazum diff <antes> <después> [opciones]
   trazum diff --all <dir> <dir> [opciones]
   trazum rank <dir> [opciones]
@@ -326,7 +328,66 @@ ${bold('OPCIONES DE plan')}
   consejo haciéndose pasar por aritmética. El ahorro proyectado y el dinero ya
   gastado son totales separados en todas partes.
 
+${bold('OPCIONES DE store')}
+  --prune                     Borra las mediciones más antiguas que la política
+                              de retención y compacta el log a lo que el
+                              almacén ya resuelve. Dice qué se fue.
+  --keep <n>d                 Retención para esta ejecución, si la config no
+                              tiene ninguna.
+  --dry-run                   Con --prune: dice qué se iría y no borra nada.
+  --json                      El inventario como datos.
+
+  Dice qué guarda el almacén local: cuántas mediciones, sobre qué período, por
+  proveedor, y qué se llevaría una poda. El almacén guarda agregados y campos
+  de facturación — nunca texto de prompt, nunca texto de respuesta, nunca una
+  credencial — así que es un fichero que un equipo puede respaldar sin una
+  revisión de privacidad.
+
+  La poda es la única operación de aquí que destruye algo, así que se niega a
+  correr sin política de retención: pon "store": {"keepDays": 90} en la config
+  o pasa --keep. Borrar mediciones con una política que nadie escribió no es un
+  valor por defecto que nadie deba recibir por accidente.
+
+${bold('OPCIONES DE connect')}
+  --since <cuándo>            La ventana que se descarga. Un día UTC, una marca
+  --until <cuándo>            ISO, una ventana relativa (7d, 24h) o "now". Por
+                              defecto, los últimos 30 días.
+  --dry-run                   Dice qué se llamaría y de qué variable de entorno
+                              saldría la clave. No envía nada y no necesita
+                              credencial.
+  --payload <fichero>         Tasa un payload de uso que ya tengas, en vez de
+                              descargar uno. Sin credencial y sin red — la misma
+                              aritmética sobre la misma forma.
+  --store                     Guarda lo descargado en el almacén local, para que
+                              la próxima vez no haya que bajarlo otra vez y
+                              "trazum history --store" tenga una serie.
+  -o, --out <fichero>         Guarda el informe tasado como JSON.
+  --markdown-out <fichero>    Lo escribe además como Markdown, para CI.
+  --json                      El informe como datos.
+
+  Lee tu factura desde la API de uso del proveedor, para que nadie tenga que
+  exportar nada a mano. La credencial se lee del entorno en el momento de la
+  llamada y nunca se guarda, nunca se imprime y nunca se escribe en un fichero
+  de configuración: define TRAZUM_ANTHROPIC_ADMIN_KEY o TRAZUM_OPENAI_ADMIN_KEY.
+  Cada proveedor necesita la clave más estrecha que pueda leer un informe de
+  uso, y una clave de API normal no puede.
+
+  Estas APIs sirven sumas sobre una ventana, no una fila por llamada, así que
+  un informe conectado es un informe restringido y lo dice: los totales, el
+  reparto por modelo, la serie por día y el veredicto de caché están todos
+  disponibles, y los hallazgos por llamada — formas de entrada, reintentos por
+  truncado, conversaciones, presión de contexto — se listan como no disponibles
+  con lo que los desbloquearía. Un límite de tasa, un tope de páginas o un
+  cursor caducado devuelven lo que llegó con el hueco nombrado, nunca un total
+  que describe en silencio menos tráfico del que pediste.
+
 ${bold('OPCIONES DE history')}
+  --store                     Construye la serie desde el almacén local en vez
+                              de un directorio de informes guardados. Las
+                              fuentes agregadas no llevan label, así que la
+                              serie por label está ausente y se dice — las de
+                              cuota de modelo y de caché son para lo que existe
+                              una serie, y funcionan enteras.
   --markdown-out <fichero>    Escribe además la serie como Markdown, para un
                               resumen de CI o un comentario de pull request.
   --json                      La historia como datos.
@@ -1470,13 +1531,76 @@ ${bold('EJEMPLOS')}
       `Plan escrito en ${path}, con fecha. Guárdalo: una predicción que nadie apuntó es una predicción que no se le puede exigir a nadie.`,
   },
 
+  store: {
+    appended: (count, dir) => `Guardadas ${count} mediciones en ${dir}.`,
+    empty: (dir) =>
+      `El almacén de ${dir} está vacío. Llénalo con "trazum connect <proveedor> --store" — eso es un estado, no un error.`,
+    heading: (records, usd, from, to) =>
+      `El almacén: ${records} mediciones · ${usd} · ${from} → ${to}`,
+    providerRow: (provider, records, span, models) =>
+      `${provider}  ${records} mediciones · ${span} · ${models} modelos`,
+    holds: (files) =>
+      `Guardado en ${files} ficheros: recuentos de tokens, dólares facturados y los identificadores de workspace y clave de la propia cuenta. Nunca texto de prompt, nunca texto de respuesta, nunca una credencial — esto es un fichero que puedes respaldar sin una revisión de privacidad.`,
+    possiblyDouble: (count) =>
+      `${count} registros no se pudieron distinguir de otro — una ventana de longitud cero, o un registro que no nombra modelo. Se guardan enteros en vez de fundirse, así que un total construido sobre ellos puede contar el mismo gasto dos veces. Decirlo es mejor que un número más pequeño que nadie puede comprobar.`,
+    unknownVersion: (count) =>
+      `${count} registros vienen de un esquema más nuevo del que esta versión conoce, así que se conservan y quedan fuera de las cifras de arriba en vez de adivinarse. Actualiza para leerlos.`,
+    unreadable: (file, line) =>
+      `${file} línea ${line} no se pudo parsear, así que no está en las cifras de arriba. El resto del fichero sí se leyó — una línea rota no puede costar un mes.`,
+    retention: (days) => `Retención: ${days} días, de "store.keepDays". Ejecuta "trazum store --prune" para aplicarla.`,
+    noRetention: () =>
+      'No hay política de retención configurada, así que nunca se borra nada por su cuenta. Pon "store": {"keepDays": 90} cuando quieras una.',
+    pruneNeedsPolicy: () =>
+      'Podar necesita una política de retención: pon "store": {"keepDays": 90} en trazum.config.json, o pasa --keep 90d para esta ejecución. Borrar mediciones con una política que nadie escribió no es un valor por defecto que debas recibir por accidente.',
+    pruneDryRun: (count, days, span, usd) =>
+      span === null
+        ? `Nada es más antiguo que ${days} días, así que una poda no borraría nada.`
+        : `Una poda borraría ${count} mediciones de más de ${days} días, que cubren ${span} y ${usd} de gasto medido. No se borró nada — esto era --dry-run.`,
+    pruned: (count, days, span, usd, kept) =>
+      span === null
+        ? `Nada era más antiguo que ${days} días. ${kept} mediciones conservadas, y el log compactado.`
+        : `Borradas ${count} mediciones de más de ${days} días, que cubren ${span} y ${usd} de gasto medido. ${kept} conservadas, y el log compactado a lo que el almacén ya resolvía.`,
+  },
+
+  connect: {
+    noTarget: (providers) =>
+      `Nombra un proveedor del que leer tu factura: trazum connect anthropic. Disponibles: ${providers}. La credencial sale del entorno y nunca se guarda — añade --dry-run para ver exactamente qué se llamaría y de qué variable saldría.`,
+    unknownProvider: (id, providers) =>
+      `No hay conector para "${id}". Los que existen son: ${providers}.`,
+    dryRun: (provider, from, to, envVars, keyKind) =>
+      `Leería el uso de ${provider} del ${from} al ${to}, usando ${keyKind} tomada de ${envVars}. No se envió nada y no hizo falta ninguna credencial para imprimir esto.`,
+    heading: (provider, from, to, usd, calls) =>
+      calls === null
+        ? `${provider} · ${from} → ${to} · ${usd}`
+        : `${provider} · ${from} → ${to} · ${usd} · ${calls} llamadas`,
+    modelRow: (model, usd, share, calls) =>
+      calls === null ? `${model}  ${usd}  ${share}` : `${model}  ${usd}  ${share} · ${calls} llamadas`,
+    nothingBilled: () =>
+      'El proveedor no facturó nada en esta ventana. Eso es una medición, no un error — ensánchala con --since si esperabas tráfico.',
+    cachePaid: (saved) => `La caché se pagó sola: ${saved} menos de lo que estos tokens habrían costado como entrada normal.`,
+    cacheLost: (added) => `La caché añadió ${added} a esta factura frente a lo que los mismos tokens habrían costado como entrada normal.`,
+    cacheUnsettled: () =>
+      'Esta fuente no dijo con qué TTL se escribió la caché, así que se asumió la tarifa barata y el veredicto cambia con la otra. Sin resolver, no resuelto a tu favor.',
+    noCallCount: (provider) =>
+      `El informe de uso de ${provider} sirve sumas de tokens y ningún recuento de peticiones, así que aquí no hay número de llamadas ni media por llamada. Un cero se leería como "sin tráfico", así que no se imprime nada en su lugar.`,
+    unpriced: (model, tokens) =>
+      `${model} no está en el catálogo de precios, así que sus ${tokens} tokens se cuentan y su dinero no. Añádelo con --pricing en vez de leer el total como completo.`,
+    gap: (detail) => `Esta ventana está incompleta: ${detail}.`,
+    unavailable: (findings) =>
+      `Hallazgos que esta fuente no puede sostener: ${findings}. Necesitan una fila por llamada, y una suma ha perdido las filas — un registro por llamada sí los responde.`,
+    wrote: (path) => `Informe escrito en ${path}.`,
+    footer: () =>
+      'Cada cifra de aquí es el recuento de tokens que el proveedor facturó, a las tarifas del catálogo. No se estimó nada, y no se rellenó nada que el proveedor no sirviera.',
+  },
+
   history: {
     noTarget: () =>
       'Apunta esto a un directorio de informes guardados: trazum history informes/. Lee los documentos --json que escribe "trazum profile" (y los planes guardados que haya al lado) y construye la serie que ninguna comparación por pares puede ver.',
     needsThree: (count) =>
       `Una serie necesita al menos tres informes con fecha, y este directorio tiene ${count}. Dos informes son una comparación, y "trazum profile --against" ya la hace mejor.`,
     heading: (periods, from, to) => `La larga distancia: ${periods} períodos, ${from} → ${to}`,
-    periodRow: (name, usd, calls, days) => `${name}  ${usd} · ${calls} llamadas · ${days} días`,
+    periodRow: (name, usd, calls, days) =>
+      calls === null ? `${name}  ${usd} · ${days} días` : `${name}  ${usd} · ${calls} llamadas · ${days} días`,
     runLabel: (label, periods, sinceName, from, to) =>
       `${label} lleva ${periods} períodos consecutivos subiendo desde ${sinceName}: ${from} → ${to}. Una forma, no un pronóstico.`,
     runModel: (model, periods, sinceName, from, to) =>
@@ -1497,6 +1621,8 @@ ${bold('EJEMPLOS')}
       const span = first !== null && last !== null ? ` (${first} → ${last})` : '';
       return `${what} se ha planificado ${appearances} veces${span} y sigue en el plan más reciente — una decisión que nadie está revisando.`;
     },
+    storeNoLabels: () =>
+      'Esta serie viene del almacén, y una API de uso agrupa por modelo y workspace, no por carga de trabajo — así que aquí no hay serie por label en absoluto. Ausente, no vacía: nada de lo de arriba dice que una carga se moviera o dejara de moverse.',
     undated: (name) => `${name} no lleva período, así que no está en ninguna línea de tiempo de arriba — nombrado, nunca absorbido en silencio.`,
     unrecognized: (name) => `${name} no es ni un informe guardado ni un plan guardado, así que no está en ninguna serie de arriba.`,
     footer: () =>

package/src/i18n/types.ts

@@ -1072,6 +1072,65 @@ export interface CliMessages {
     wrote(path: string): string;
   };
 
+  /**
+   * `trazum store` — the measurements kept on disk.
+   *
+   * The one part of this product that deletes something, so its copy is
+   * written to make that visible: what is held, what a prune would take, and
+   * a refusal when no retention policy exists to prune against.
+   */
+  store: {
+    /** Records appended by a pull that asked to keep them. */
+    appended(count: string, dir: string): string;
+    empty(dir: string): string;
+    heading(records: string, usd: string, from: string, to: string): string;
+    providerRow(provider: string, records: string, span: string, models: string): string;
+    /** What the store holds — and what it never holds. */
+    holds(files: string): string;
+    /** Records the store could not tell apart, kept whole rather than merged. */
+    possiblyDouble(count: string): string;
+    unknownVersion(count: string): string;
+    unreadable(file: string, line: string): string;
+    retention(days: string): string;
+    noRetention(): string;
+    /** Deleting on a policy nobody wrote down is refused, never defaulted. */
+    pruneNeedsPolicy(): string;
+    pruneDryRun(count: string, days: string, span: string | null, usd: string): string;
+    pruned(count: string, days: string, span: string | null, usd: string, kept: string): string;
+  };
+
+  /**
+   * `trazum connect` — the bill, read from the provider.
+   *
+   * A usage API serves sums, so the report is restricted on purpose and says
+   * which findings this source cannot support. The credential copy matters as
+   * much as the figures: Trazum borrows a key from the environment and never
+   * stores it, and the messages here are where a user learns that.
+   */
+  connect: {
+    noTarget(providers: string): string;
+    unknownProvider(id: string, providers: string): string;
+    /** What would be called, with no key needed and nothing sent. */
+    dryRun(provider: string, from: string, to: string, envVars: string, keyKind: string): string;
+    /** `calls` is null on a source that serves no request count. */
+    heading(provider: string, from: string, to: string, usd: string, calls: string | null): string;
+    modelRow(model: string, usd: string, share: string, calls: string | null): string;
+    /** A window the provider billed nothing in — not an error, and not a zero to hide. */
+    nothingBilled(): string;
+    cachePaid(saved: string): string;
+    cacheLost(added: string): string;
+    /** The write TTL was not stated, so the verdict moves under the other rate. */
+    cacheUnsettled(): string;
+    /** This source serves token sums and no request count. */
+    noCallCount(provider: string): string;
+    unpriced(model: string, tokens: string): string;
+    /** Something the pull did not get, named rather than silently missing. */
+    gap(detail: string): string;
+    unavailable(findings: string): string;
+    wrote(path: string): string;
+    footer(): string;
+  };
+
   /**
    * `trazum history` — many reports over many periods, as one series.
    *
@@ -1083,12 +1142,15 @@ export interface CliMessages {
     /** Under three dated reports there is no series — only the comparison --against already does. */
     needsThree(count: string): string;
     heading(periods: string, from: string, to: string): string;
-    periodRow(name: string, usd: string, calls: string, days: string): string;
+    /** `calls` is null on a source that serves no request count. */
+    periodRow(name: string, usd: string, calls: string | null, days: string): string;
     runLabel(label: string, periods: string, sinceName: string, from: string, to: string): string;
     runModel(model: string, periods: string, sinceName: string, from: string, to: string): string;
     runCache(periods: string, sinceName: string, from: string, to: string): string;
     /** The same action in plan after plan: a decision nobody is executing. */
     repeated(kind: PlanActionKind, label: string, model: string, appearances: string, first: string | null, last: string | null): string;
+    /** A store source carries no labels, so the label series is absent, not empty. */
+    storeNoLabels(): string;
     undated(name: string): string;
     unrecognized(name: string): string;
     footer(): string;