@trazum/cli 1.81.0 → 1.83.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/i18n/es.ts CHANGED
@@ -46,8 +46,12 @@ ${bold('USO')}
46
46
  trazum schema <contrato>
47
47
  trazum rollup <documento...|dir> [--json] [--html-out <fichero>]
48
48
  trazum position <uso.jsonl>
49
+ trazum receipt <uso.jsonl|dir> [--stamp] [-o <fichero>]
49
50
  trazum from-claude-code <fichero|dir> [--label <nombre>] [-o <fichero>]
50
51
  trazum from-otel <fichero|dir> [--label-from-service] [-o <fichero>]
52
+ trazum from-litellm <fichero|dir> [-o <fichero>]
53
+ trazum from-helicone <fichero|dir> [-o <fichero>]
54
+ trazum from-langsmith <fichero|dir> [-o <fichero>]
51
55
  trazum switch <uso.jsonl> --to <modelo> [--migration-usd <n>] [--cases <n>]
52
56
  trazum ownrate --gpu-usd-hour <n> --tokens-per-second <n> [--utilization <0-1>]
53
57
  trazum pulse [--max-stale-hours <n>]
@@ -119,6 +123,29 @@ ${bold('OPCIONES DE rollup')}
119
123
 
120
124
  Sale con 1 cuando una contribución se entregó y no se pudo agregar.
121
125
 
126
+ ${bold('OPCIONES DE receipt')}
127
+ --stamp Registra la hora de emisión en el documento.
128
+ Desactivado por defecto para que dos ejecuciones
129
+ sobre un log den los mismos bytes: el periodo que
130
+ cubren las cifras ya está dentro, leído del reloj
131
+ del propio log.
132
+ -o, --out <fichero> Escribe el recibo ahí en vez de en la salida
133
+ estándar. El resumen siempre va al error
134
+ estándar, así que una redirección escribe un
135
+ documento y no un documento con un resumen
136
+ pegado delante.
137
+ --pricing <fichero> Lo precia con tu propia tarjeta de precios en
138
+ vez de con el catálogo incluido.
139
+ --pricing-live Lo precia con tarifas en vivo vía OpenRouter.
140
+
141
+ Un perfil responde donde se ejecutó. Un recibo son las mismas cifras con la
142
+ forma que las deja seguir respondiendo en otro sitio: cada línea lleva las
143
+ tarifas que produjeron su dinero y la fecha en que las de ese proveedor se
144
+ leyeron por última vez de su propia página. Lo que no lleva es texto del
145
+ prompt, respuestas, rutas de fichero, nombres de rama, credenciales ni
146
+ sesiones: no censurados, ausentes, porque la forma de la que se construye no
147
+ tiene campo donde meterlos. No envía nada a ningún sitio.
148
+
122
149
  ${bold('OPCIONES DE write')}
123
150
  --answers <fichero> Un objeto JSON de ids de slot y respuestas. Sin
124
151
  esto, las preguntas se hacen una a una; una línea
@@ -170,6 +197,44 @@ ${bold('OPCIONES DE ownrate')}
170
197
  en trazum.config.json, de modo que el modelo que tú mismo sirves sea una
171
198
  fila de primera en cada informe, tasado por ti y marcado como tal.
172
199
 
200
+ ${bold('OPCIONES DE from-helicone')}
201
+ -o, --out <fichero> Escribe el log de uso ahí en vez de en stdout.
202
+
203
+ Un export de peticiones de Helicone, leído como un log de uso: modelo, marca
204
+ de tiempo, etiqueta y los recuentos de tokens de cada fila, y nada más. El
205
+ cuerpo de la petición, el de la respuesta y el id de usuario se quedan en la
206
+ fila. Se pone precio al modelo que respondió, y las filas respondidas por un
207
+ modelo distinto del pedido se cuentan. cache_enabled es una bandera y nunca
208
+ un reparto de tokens, así que los veredictos de caché dicen "no se puede
209
+ saber". Un request id es una llamada y nunca una conversación, así que los
210
+ registros no llevan sesión y los hallazgos de conversación no se pueden
211
+ responder desde este registro; se dice en cada ejecución.
212
+
213
+ ${bold('OPCIONES DE from-langsmith')}
214
+ -o, --out <fichero> Escribe el log de uso ahí en vez de en stdout.
215
+
216
+ Un export de runs de LangSmith, leído como un log de uso: modelo, marca de
217
+ tiempo, etiqueta, la traza como sesión y los recuentos de tokens, y nada más.
218
+ Los inputs y los outputs se quedan en el run, y de los metadatos se leen
219
+ claves con nombre y nunca se copian enteros. Solo run_type "llm" es una
220
+ llamada: cadenas, herramientas y retrievers se saltan y se cuentan, porque la
221
+ cadena que envuelve una llamada repite los tokens de su hijo. Un run cuyos
222
+ metadatos no nombran modelo se rechaza en lugar de tarifarlo por el nombre
223
+ del run, que es una clase cliente. El coste propio de LangSmith se informa
224
+ aparte y nunca se mezcla con el de Trazum.
225
+
226
+ ${bold('OPCIONES DE from-litellm')}
227
+ -o, --out <fichero> Escribe el log de uso ahí en vez de en stdout.
228
+
229
+ Un spend log de LiteLLM, leído como un log de uso: modelo, marca de tiempo,
230
+ etiqueta, sesión y los recuentos de tokens de cada fila, y nada más. Los
231
+ mensajes, la respuesta, la clave con hash, la dirección del solicitante y el
232
+ usuario final se quedan en la fila. cache_hit es una bandera y nunca un
233
+ reparto de tokens, así que los veredictos de caché dicen "no se puede saber"
234
+ en vez de uno inventado. Las filas que no nombran modelo se cuentan y se
235
+ dejan fuera: model_group es una ruta, no un modelo. La cifra de gasto propia
236
+ de LiteLLM se imprime al lado de la de Trazum y nunca se funde con ella.
237
+
173
238
  ${bold('OPCIONES DE from-otel')}
174
239
  --label-from-service Etiqueta cada registro con el nombre de servicio
175
240
  de su span, para que salga una factura por
@@ -1018,6 +1083,14 @@ ${bold('EJEMPLOS')}
1018
1083
  },
1019
1084
 
1020
1085
  errors: {
1086
+ fileNotFound: (path) =>
1087
+ `${path}: no encontrado. Revisa la ruta, o apunta esto al directorio que lo contiene.`,
1088
+ fileIsDirectory: (path) =>
1089
+ `${path} es un directorio, y este comando lee un fichero. Nombra el fichero de dentro, o usa un comando que recorra una carpeta.`,
1090
+ fileIsDirectoryUnnamed: () =>
1091
+ 'esa ruta es un directorio, y este comando lee un fichero. Nombra el fichero de dentro, o usa un comando que recorra una carpeta.',
1092
+ fileNotReadable: (path) =>
1093
+ `${path}: sin permiso de lectura. Revisa el dueño y los permisos del fichero, y vuelve a ejecutarlo.`,
1021
1094
  livePricingFailed: (url: string, detail: string) =>
1022
1095
  `No se han podido cargar los precios en vivo desde ${url}: ${detail}. Los precios incluidos siguen ahí: quita --pricing-live para usarlos.`,
1023
1096
  optionNeedsValue: (name) => `La opción --${name} necesita un valor.`,
@@ -1088,10 +1161,14 @@ ${bold('EJEMPLOS')}
1088
1161
 
1089
1162
  report: {
1090
1163
  inputTokens: () => 'Tokens de entrada',
1091
- estimated: (offFamily) =>
1092
- offFamily === null
1093
- ? ' (estimado, ±10%)'
1094
- : ` (estimado: el contador está calibrado sobre Claude, no sobre ${offFamily})`,
1164
+ estimated: (offFamily, band, measuredOff) => {
1165
+ if (offFamily === null) return ` (estimado, ±${band}%)`;
1166
+ return measuredOff === null
1167
+ ? ` (estimado: el contador está calibrado sobre Claude, no sobre ${offFamily}, y nadie ha`
1168
+ + ' medido cuánto se desvía ahí)'
1169
+ : ` (estimado: el contador está calibrado sobre Claude, no sobre ${offFamily}, donde se ha`
1170
+ + ` medido hasta un ${measuredOff}% de desviación)`;
1171
+ },
1095
1172
  exactCount: () => ' (recuento exacto)',
1096
1173
  rulesApplied: () => 'Reglas aplicadas',
1097
1174
  nothingToTrim: () => ' Ninguna regla ha encontrado nada que recortar.',
@@ -1172,7 +1249,7 @@ ${bold('EJEMPLOS')}
1172
1249
  beyondThisPromptTokensOnly: () =>
1173
1250
  'Acortar un prompt es la palanca más pequeña que hay: medido en un prompt de soporte corriente, las reglas recuperan alrededor del 1% de una factura mensual. Si alguno de tus prompts va a una API de pago por uso, "trazum profile <usage.jsonl>" lee lo que el proveedor cobró de verdad y calcula las palancas que no son el prompt. Grabar ese registro son unas pocas líneas y nunca contiene texto del prompt.',
1174
1251
  beyondThisPrompt: () =>
1175
- 'Acortar un prompt es la palanca más pequeña que hay: medido en un prompt de soporte corriente, las reglas recuperan alrededor del 1% de una factura mensual. En una API de pago por uso, lo que mueve del 40% al 80% es a qué modelo va la llamada, la Batch API, la caché de prompts, y lo que cuesta reenviar la conversación, y "trazum profile <usage.jsonl>" calcula las cuatro a partir de lo que el proveedor cobró de verdad. Grabar ese registro son unas pocas líneas y nunca contiene texto del prompt.',
1252
+ 'Acortar un prompt es la palanca más pequeña que hay: medido en un prompt de soporte corriente, las reglas recuperan alrededor del 1% de una factura mensual. En una API de pago por uso, lo que mueve del 60% al 80% es a qué modelo va la llamada, la Batch API, la caché de prompts, y lo que cuesta reenviar la conversación, y "trazum profile <usage.jsonl>" calcula las cuatro a partir de lo que el proveedor cobró de verdad. Grabar ese registro son unas pocas líneas y nunca contiene texto del prompt.',
1176
1253
  windowUse: (before, after, model, window) =>
1177
1254
  `Ventana de contexto: ${before} → ${after} de los ${window} tokens de ${model}, sitio que se lleva la conversación.`,
1178
1255
  tokensOnlyAskedFor: () =>
@@ -1713,6 +1790,19 @@ ${bold('EJEMPLOS')}
1713
1790
  snippetHeading: () => 'Pega en trazum.config.json (el fichero de overlay «pricing»):',
1714
1791
  },
1715
1792
 
1793
+ receipt: {
1794
+ noLog: () => 'Nombra un log de uso del que hacer el recibo.',
1795
+ written: (file, lines) => `Recibo de ${lines} línea(s) escrito en ${file}.`,
1796
+ summary: (lines, usd) =>
1797
+ `${lines} línea(s), ${usd} con precio. Cada cifra lleva la tarifa que la produjo y la fecha en que se revisó esa tarifa.`,
1798
+ unpriced: (models, calls) =>
1799
+ `${models} modelo(s) que el catálogo no precia, con ${calls} llamada(s): nombrados en los huecos del recibo y fuera del total, en vez de costados a cero.`,
1800
+ unread: (count) => `${count} línea(s) del log no se pudieron leer, y el recibo lo dice.`,
1801
+ noClock: () =>
1802
+ 'El log no lleva reloj, así que el recibo no está acotado en el tiempo y lo declara en vez de inventarse un periodo.',
1803
+ nothingToBill: () => 'Nada de este log se pudo precificar, así que el recibo no tiene líneas.',
1804
+ },
1805
+
1716
1806
  fromOtel: {
1717
1807
  noPath: () => 'from-otel necesita un archivo o directorio OTLP: trazum from-otel spans.json',
1718
1808
  notFound: (path) => `${path}: no existe`,
@@ -1724,6 +1814,65 @@ ${bold('EJEMPLOS')}
1724
1814
  written: (file) => `Escrito ${file}.`,
1725
1815
  },
1726
1816
 
1817
+ fromHelicone: {
1818
+ noPath: () =>
1819
+ 'from-helicone necesita un export de peticiones o un directorio: trazum from-helicone requests.json',
1820
+ notFound: (path) => `${path}: no encontrado`,
1821
+ noExports: (path) =>
1822
+ `${path}: no hay exports .json/.jsonl/.ndjson dentro. Las peticiones de Helicone salen de su endpoint POST /v1/request/query, o del botón de exportar de la tabla de peticiones.`,
1823
+ summary: (files, rows) => `${files} archivo(s), ${rows} petición(es) leída(s).`,
1824
+ unnamedModel: (count) =>
1825
+ `${count} fila(s) no nombran modelo en ninguna de las tres columnas y no están en la salida: nada en la fila dice qué respondió, así que nada puede ponerle precio.`,
1826
+ disagreements: (count) =>
1827
+ `${count} fila(s) las respondió un modelo distinto del pedido. Se pone precio al que respondió, porque una factura va de lo que se facturó; el recuento está aquí para que una sustitución sea algo que ves y no algo que encuentras dentro de un total.`,
1828
+ noTokens: (count) =>
1829
+ `${count} fila(s) traían cero tokens en ambos lados: peticiones registradas a las que nadie puede poner precio. Se cuentan aquí y merecen un vistazo a Helicone.`,
1830
+ cacheFlagged: (count) =>
1831
+ `${count} fila(s) las sirvió la caché de Helicone. Eso es una bandera en la fila y nunca un reparto de tokens, así que los veredictos de caché dicen "no se puede saber" en este registro en vez de uno inventado.`,
1832
+ noSessions: () =>
1833
+ 'Sin identidad de sesión: un request id de Helicone nombra una llamada, no una conversación, así que los hallazgos de conversación (caché desperdiciada en un solo turno, presión de contexto) no se pueden responder desde este registro. Hacer pasar un id por llamada como conversación reportaría cada llamada como una conversación de una.',
1834
+ unparseable: (count) => `${count} línea(s) no se pudieron leer como JSON.`,
1835
+ written: (file) => `Escrito ${file}.`,
1836
+ },
1837
+
1838
+ fromLangsmith: {
1839
+ noPath: () =>
1840
+ 'from-langsmith necesita un export de runs o un directorio: trazum from-langsmith runs.json',
1841
+ notFound: (path) => `${path}: no encontrado`,
1842
+ noExports: (path) =>
1843
+ `${path}: no hay exports .json/.jsonl/.ndjson dentro. Los runs de LangSmith salen de su endpoint de listado, del list_runs() del SDK o del botón de exportar en la tabla de runs de un proyecto.`,
1844
+ summary: (files, rows) => `${files} archivo(s), ${rows} llamada(s) al modelo leídas.`,
1845
+ notModelCalls: (count) =>
1846
+ `${count} run(s) no eran llamadas al modelo y no están en la salida: cadenas, herramientas, retrievers y prompts. Una traza de LangSmith es un árbol y la cadena que envuelve una llamada repite los tokens de su hijo, así que sumar el árbol facturaría los mismos tokens una vez por nivel.`,
1847
+ unnamedModel: (count) =>
1848
+ `${count} llamada(s) no nombran modelo en sus metadatos y no están en la salida. El nombre del run es una clase cliente: «ChatAnthropic» no es un modelo que nadie pueda tarifar, así que se rechaza en lugar de adivinarlo. Pon ls_model_name o registra los invocation params.`,
1849
+ noTokens: (count) =>
1850
+ `${count} llamada(s) no traían recuento de tokens y no están en la salida: runs registrados que nadie puede tarifar. Se cuentan aquí y merecen una mirada en el tracer.`,
1851
+ reportedCost: (usd) =>
1852
+ `LangSmith tarifó estas mismas llamadas en ${usd} con su propia tabla. Esa cifra no se mezcla con nada que calcule Trazum: sumar dos tablas de precios en un total es como un informe se vuelve silenciosamente falso. Compáralas a propósito o no las compares.`,
1853
+ unparseable: (count) => `${count} línea(s) no se han podido leer como JSON.`,
1854
+ written: (file) => `Escrito ${file}.`,
1855
+ },
1856
+
1857
+ fromLiteLlm: {
1858
+ noPath: () =>
1859
+ 'from-litellm necesita un export de spend log o un directorio: trazum from-litellm spend.json',
1860
+ notFound: (path) => `${path}: no encontrado`,
1861
+ noExports: (path) =>
1862
+ `${path}: no hay exports .json/.jsonl/.ndjson dentro. Los spend logs de LiteLLM salen de la tabla LiteLLM_SpendLogs, o de los endpoints /spend del propio proxy.`,
1863
+ summary: (files, rows) => `${files} archivo(s), ${rows} llamada(s) registrada(s) leída(s).`,
1864
+ unnamedModel: (count) =>
1865
+ `${count} fila(s) no nombran modelo y no están en la salida. "model_group" es el nombre de una ruta del proxy y detrás pueden ir varios modelos, así que poner precio a esas llamadas por la ruta que tomaron sería atribuir una cifra a algo que no describe.`,
1866
+ noTokens: (count) =>
1867
+ `${count} fila(s) traían cero tokens en ambos lados: llamadas registradas a las que nadie puede poner precio. Se cuentan aquí y merecen un vistazo al proxy.`,
1868
+ cacheFlagged: (count) =>
1869
+ `${count} fila(s) están marcadas como acierto de caché. LiteLLM lo registra como una bandera y nunca como un reparto de tokens, así que los veredictos de caché dicen "no se puede saber" en este registro en vez de uno inventado.`,
1870
+ reportedSpend: (usd) =>
1871
+ `LiteLLM puso precio a estas mismas llamadas en ${usd} con su propia tabla. Esa cifra no se funde con nada que calcule Trazum: sumar dos tablas de precios en un total es como un informe se vuelve callado y equivocado. Compáralas a propósito o no las compares.`,
1872
+ unparseable: (count) => `${count} línea(s) no se pudieron leer como JSON.`,
1873
+ written: (file) => `Escrito ${file}.`,
1874
+ },
1875
+
1727
1876
  fromClaudeCode: {
1728
1877
  noPath: () => 'from-claude-code necesita un archivo o directorio de transcripts: trazum from-claude-code ~/.claude/projects',
1729
1878
  notFound: (path) => `${path}: no existe`,
@@ -1899,6 +2048,8 @@ ${bold('EJEMPLOS')}
1899
2048
  unit: () => ' (USD por millón de tokens)',
1900
2049
  reviewedOn: (date, days) =>
1901
2050
  ` Tabla revisada el ${date}${hace(days)}. Verifica antes de presupuestar.`,
2051
+ reviewedByProvider: (rows) => ` Por proveedor: ${rows}`,
2052
+ reviewedGroup: (date, days, providers) => `${date}${hace(days)} ${providers}`,
1902
2053
  columns: {
1903
2054
  model: 'modelo',
1904
2055
  input: 'entrada',
@@ -1957,8 +2108,8 @@ ${bold('EJEMPLOS')}
1957
2108
  truncated: (shown) =>
1958
2109
  `Mostrando las ${shown} más recientes. Usa --limit para ver más.`,
1959
2110
  followedRename: (from) => `Se ha seguido un renombrado: las revisiones anteriores son ${from}.`,
1960
- estimateNote: () =>
1961
- 'Los recuentos son estimaciones (±10%). Lo que importa es la tendencia, no las cifras absolutas.',
2111
+ estimateNote: (band) =>
2112
+ `Los recuentos son estimaciones (±${band}% para texto de este tipo). Lo que importa es la tendencia, no las cifras absolutas.`,
1962
2113
  },
1963
2114
 
1964
2115
  languages: {
@@ -2177,7 +2328,7 @@ ${bold('EJEMPLOS')}
2177
2328
  footer: (source, level) => `Recuento de tokens ${source} · nivel de reglas \`${level}\``,
2178
2329
  pricingOverlaid: (count, lastReviewed) =>
2179
2330
  `Los precios de ${count} ${count === 1 ? 'modelo' : 'modelos'} vienen de un overlay local revisado el ${lastReviewed}.`,
2180
- sourceEstimated: () => 'estimado, ±10%',
2331
+ sourceEstimated: (band) => `estimado, ±${band}%`,
2181
2332
  sourceExact: () => 'exacto',
2182
2333
  measuringOptimised: () =>
2183
2334
  'Se mide lo que dejarían las reglas, no lo que está escrito en el fichero.',
@@ -2625,6 +2776,13 @@ ${bold('EJEMPLOS')}
2625
2776
  'Ningún registro lleva marca de tiempo, así que --since/--until no tienen por qué filtrar. Una ventana temporal sobre un registro sin reloj no vigilaría nada, y eso no es una respuesta. Añade "ts" a los registros: la receta del README dice dónde.',
2626
2777
  windowMatchesNothing: (from, to) =>
2627
2778
  `Ningún registro cae dentro de esta ventana. El registro cubre ${from} → ${to}. Una ventana que no encuentra nada no debe volverse un informe de $0: bajo --max-usd pasaría una puerta de presupuesto sobre un periodo que el registro no cubre.`,
2779
+ gateNothingMeasured: (reason) =>
2780
+ `Hay una puerta de gasto armada y no había nada que juzgar: ${reason}. Una ausencia no es un aprobado, así que esto sale con 1 en vez de reportar $0 contra tu presupuesto. Arregla el registro, o pasa --allow-empty si un periodo sin llamadas es la respuesta esperada.`,
2781
+ nothingUnreadable: (lines) =>
2782
+ `las ${count(lines)} ${lines === 1 ? 'línea del fichero era ilegible' : 'líneas del fichero eran ilegibles'}`,
2783
+ nothingUnpriced: (calls) =>
2784
+ `se ${count(calls) && calls === 1 ? 'registró 1 llamada' : `registraron ${count(calls)} llamadas`} y ninguno de sus modelos está en la tabla de precios`,
2785
+ nothingEmpty: () => 'el registro no tiene ni un solo apunte',
2628
2786
  sinceAfterUntil: () =>
2629
2787
  '--since es igual o posterior a --until, así que la ventana no contiene tiempo alguno. Revisa las dos fechas.',
2630
2788
  badWhen: (flag, value) =>
package/src/i18n/types.ts CHANGED
@@ -81,6 +81,20 @@ export interface CliMessages {
81
81
  };
82
82
 
83
83
  errors: {
84
+ /**
85
+ * A filesystem refusal, said in this product's voice rather than Node's.
86
+ *
87
+ * Seven commands used to let `ENOENT: no such file or directory, open
88
+ * '/nope/x.txt'` reach the reader on the commonest mistake there is, a
89
+ * mistyped path, while the five converters answered `/nope/x.json: not
90
+ * found`. The doctrine's rule is that a refusal never arrives bare, so
91
+ * these say the path, what was wrong with it, and the move that settles it.
92
+ */
93
+ fileNotFound(path: string): string;
94
+ fileIsDirectory(path: string): string;
95
+ /** Node reports EISDIR from `read` with no path on it, so this one names none. */
96
+ fileIsDirectoryUnnamed(): string;
97
+ fileNotReadable(path: string): string;
84
98
  livePricingFailed: (url: string, detail: string) => string;
85
99
  optionNeedsValue(name: string): string;
86
100
  mustBeNonNegative(name: string, raw: string): string;
@@ -127,10 +141,25 @@ export interface CliMessages {
127
141
  report: {
128
142
  inputTokens(): string;
129
143
  /**
130
- * @param offFamily Provider name when the model is not the family the
131
- * estimator was calibrated on, otherwise null.
132
- */
133
- estimated(offFamily: string | null): string;
144
+ * Where the input-token figure came from, and how far it can be trusted.
145
+ *
146
+ * Three cases, and the third is the one that took a measurement to earn.
147
+ * `band` is this text's own band, printed alone when the model is the family
148
+ * the estimator was calibrated on. `offFamily` names a tokenizer it was not
149
+ * measured on, and then the Claude band is dropped rather than annotated —
150
+ * a number qualified into meaninglessness is still read as a number.
151
+ * `measuredOff` is the worst error actually measured against that family's
152
+ * own counter, or null where nobody has run it: the difference between
153
+ * *this may be off* and *this was 94.5% off* is the difference between a
154
+ * hedge a reader discounts and one they act on.
155
+ *
156
+ * @param offFamily Provider name when the model is not the calibrated
157
+ * family, otherwise null.
158
+ * @param band This text's own measured band, as a percentage.
159
+ * @param measuredOff Worst measured error against that family's tokenizer,
160
+ * or null when it has never been measured.
161
+ */
162
+ estimated(offFamily: string | null, band: number, measuredOff: number | null): string;
134
163
  exactCount(): string;
135
164
  rulesApplied(): string;
136
165
  nothingToTrim(): string;
@@ -563,6 +592,20 @@ export interface CliMessages {
563
592
  snippetHeading(): string;
564
593
  };
565
594
 
595
+ /**
596
+ * `receipt` — the bill's counts with the provenance of every figure, shaped
597
+ * so they still answer somewhere other than the terminal that produced them.
598
+ */
599
+ receipt: {
600
+ noLog(): string;
601
+ written(file: string, lines: number): string;
602
+ summary(lines: number, usd: string): string;
603
+ unpriced(models: number, calls: number): string;
604
+ unread(count: number): string;
605
+ noClock(): string;
606
+ nothingToBill(): string;
607
+ };
608
+
566
609
  fromOtel: {
567
610
  noPath(): string;
568
611
  notFound(path: string): string;
@@ -574,6 +617,69 @@ export interface CliMessages {
574
617
  written(file: string): string;
575
618
  };
576
619
 
620
+ /**
621
+ * `from-litellm` — the gateway a great many teams already put in front of
622
+ * every provider, so its spend log is the export most likely to already
623
+ * exist on somebody's disk.
624
+ */
625
+ /**
626
+ * `from-helicone` — the proxy that keeps every request it saw, so a team
627
+ * using it already has the export.
628
+ */
629
+ fromHelicone: {
630
+ noPath(): string;
631
+ notFound(path: string): string;
632
+ noExports(path: string): string;
633
+ summary(files: number, rows: number): string;
634
+ unnamedModel(count: number): string;
635
+ /** A proxy answered with a different model than was asked for. */
636
+ disagreements(count: number): string;
637
+ noTokens(count: number): string;
638
+ /** A cache flag is not a token split, and this says so rather than guessing. */
639
+ cacheFlagged(count: number): string;
640
+ /** Said once per run: a request id is one call, never a conversation. */
641
+ noSessions(): string;
642
+ unparseable(count: number): string;
643
+ written(file: string): string;
644
+ };
645
+
646
+ fromLangsmith: {
647
+ noPath(): string;
648
+ notFound(path: string): string;
649
+ noExports(path: string): string;
650
+ summary(files: number, rows: number): string;
651
+ /**
652
+ * Runs that were not model calls: chains, tools, retrievers, prompts.
653
+ *
654
+ * Most of a LangSmith export, and said out loud because a reader who
655
+ * converted a thousand runs into three hundred records is owed the reason.
656
+ */
657
+ notModelCalls(count: number): string;
658
+ /** Runs whose metadata named no model: counted, never priced by the client class. */
659
+ unnamedModel(count: number): string;
660
+ noTokens(count: number): string;
661
+ /** LangSmith's own priced figure, stated and never merged into Trazum's. */
662
+ reportedCost(usd: string): string;
663
+ unparseable(count: number): string;
664
+ written(file: string): string;
665
+ };
666
+
667
+ fromLiteLlm: {
668
+ noPath(): string;
669
+ notFound(path: string): string;
670
+ noExports(path: string): string;
671
+ summary(files: number, rows: number): string;
672
+ /** Rows naming no model: counted, never priced by the route they took. */
673
+ unnamedModel(count: number): string;
674
+ noTokens(count: number): string;
675
+ /** A cache flag is not a token split, and this says so rather than guessing. */
676
+ cacheFlagged(count: number): string;
677
+ /** LiteLLM's own figure, stated and never merged into Trazum's. */
678
+ reportedSpend(usd: string): string;
679
+ unparseable(count: number): string;
680
+ written(file: string): string;
681
+ };
682
+
577
683
  fromClaudeCode: {
578
684
  noPath(): string;
579
685
  notFound(path: string): string;
@@ -707,6 +813,15 @@ export interface CliMessages {
707
813
  unit(): string;
708
814
  /** `days` is null when the date is unusable or in the future. */
709
815
  reviewedOn(date: string, days: number | null): string;
816
+ /**
817
+ * Said only when the providers disagree, which is the case the headline
818
+ * date cannot carry: it is the oldest of them, so a reader pricing only
819
+ * Anthropic calls is told the table is two months old when their half of
820
+ * it was checked today.
821
+ */
822
+ reviewedByProvider(rows: string): string;
823
+ /** The providers that share one review date, joined into the line above. */
824
+ reviewedGroup(date: string, days: number | null, providers: string): string;
710
825
  columns: {
711
826
  model: string;
712
827
  input: string;
@@ -771,7 +886,8 @@ export interface CliMessages {
771
886
  goneAt(): string;
772
887
  truncated(shown: number): string;
773
888
  followedRename(from: string): string;
774
- estimateNote(): string;
889
+ /** `band` is the widest band across the texts the trend covers. */
890
+ estimateNote(band: number): string;
775
891
  };
776
892
 
777
893
  /** `trazum doctor` — the survey across a whole workspace. */
@@ -883,7 +999,13 @@ export interface CliMessages {
883
999
  truncated(): string;
884
1000
  footer(source: string, level: string): string;
885
1001
  pricingOverlaid(count: number, lastReviewed: string): string;
886
- sourceEstimated(): string;
1002
+ /**
1003
+ * `band` is this text's own measured band, from `bandFor` in core.
1004
+ *
1005
+ * Never a constant again: the estimator is 6% out on prose and 33% out on
1006
+ * a CSV ledger, so one figure printed on both was wrong about one of them.
1007
+ */
1008
+ sourceEstimated(band: number): string;
887
1009
  sourceExact(): string;
888
1010
  measuringOptimised(): string;
889
1011
  metricTokens(before: string, after: string): string;
@@ -1001,7 +1123,7 @@ export interface CliMessages {
1001
1123
  * The section the whole command builds towards.
1002
1124
  *
1003
1125
  * Trazum's rules recover about 1% of a bill. Which model a call goes to moves
1004
- * 40% to 80%, and the Batch API moves 50% flat. A report that shows where the
1126
+ * 60% to 80%, and the Batch API moves 50% flat. A report that shows where the
1005
1127
  * money went and then stops is a report that leaves the reader with the
1006
1128
  * smallest lever in their hand.
1007
1129
  */
@@ -1557,6 +1679,18 @@ export interface CliMessages {
1557
1679
  windowNeedsClock(): string;
1558
1680
  /** A window matching nothing must not become a passing $0 gate. */
1559
1681
  windowMatchesNothing(from: string, to: string): string;
1682
+ /**
1683
+ * A gate armed over a report with nothing in it.
1684
+ *
1685
+ * `reason` names the gap: unreadable lines, models with no price, or a log
1686
+ * that is genuinely empty. The doctrine's rule is that an absence is never
1687
+ * reported as a pass, and this is the sentence that refuses to.
1688
+ */
1689
+ gateNothingMeasured(reason: string): string;
1690
+ /** The three gaps, for the sentence above. */
1691
+ nothingUnreadable(lines: number): string;
1692
+ nothingUnpriced(calls: number): string;
1693
+ nothingEmpty(): string;
1560
1694
  sinceAfterUntil(): string;
1561
1695
  badWhen(flag: string, value: string): string;
1562
1696
  /**