@trazum/cli 1.9.0 → 1.10.0

package/src/i18n/en.ts

@@ -1,5 +1,8 @@
 import type { CliMessages } from './types.js';
 
+/** Counts, grouped. A log with forty thousand torn lines should say so legibly. */
+const count = (value: number): string => value.toLocaleString('en-US');
+
 /** "(46 days ago)", or nothing when the age is unknown. */
 const ago = (days: number | null): string =>
   days === null ? '' : days === 0 ? ' (today)' : days === 1 ? ' (1 day ago)' : ` (${days} days ago)`;
@@ -371,7 +374,7 @@ ${bold('EXAMPLES')}
     inputTokens: () => 'Input tokens',
     estimated: (offFamily) =>
       offFamily === null
-        ? ' (estimated, ±15%)'
+        ? ' (estimated, ±10%)'
         : ` (estimated — the counter is calibrated on Claude, not ${offFamily})`,
     exactCount: () => ' (exact count)',
     rulesApplied: () => 'Rules applied',
@@ -551,7 +554,7 @@ ${bold('EXAMPLES')}
       `Showing the most recent ${shown}. Pass --limit for more.`,
     followedRename: (from) => `Followed a rename: earlier revisions are ${from}.`,
     estimateNote: () =>
-      'Token counts are estimates (±15%). The trend is the point; the absolute figures are not.',
+      'Token counts are estimates (±10%). The trend is the point; the absolute figures are not.',
   },
 
   languages: {
@@ -754,7 +757,7 @@ ${bold('EXAMPLES')}
     footer: (source, level) => `Token counts ${source} · rule level \`${level}\``,
     pricingOverlaid: (count, lastReviewed) =>
       `Prices for ${count} ${count === 1 ? 'model' : 'models'} came from a local overlay reviewed ${lastReviewed}.`,
-    sourceEstimated: () => 'estimated, ±15%',
+    sourceEstimated: () => 'estimated, ±10%',
     sourceExact: () => 'counted exactly',
     measuringOptimised: () =>
       'Measuring what the rules would leave, not what is written in the file.',
@@ -799,6 +802,36 @@ ${bold('EXAMPLES')}
     exactCountsCost: (files) =>
       `Counting ${files} ${files === 1 ? 'file' : 'files'} through the API, one call each. This takes a moment.`,
   },
+  profile: {
+    noTarget: () =>
+      'Point this at a usage log: trazum profile usage.jsonl — one JSON object per line, each with a "model" and the "usage" object the API returned. Recording one is three lines in your own code, and it never contains prompt text.',
+    heading: () => 'Where the money went',
+    spent: (calls, total) => `${calls} calls · ${total}`,
+    part: (name, usd, pct, tokens) => `${name.padEnd(13)}${usd.padStart(11)}  ${pct.padStart(5)}   ${tokens} tokens`,
+    partInput: () => 'Input',
+    partCacheRead: () => 'Cache reads',
+    partCacheWrite: () => 'Cache writes',
+    partOutput: () => 'Output',
+    byLabelHeading: () => 'By label',
+    byModelHeading: () => 'By model',
+    row: (name, usd, pct, calls) => `${usd.padStart(11)}  ${pct.padStart(5)}   ${name}  (${calls} calls)`,
+    unlabelled: () => 'unlabelled',
+    cacheHit: (pct) => `Cache hit rate ${pct} of billable input.`,
+    cacheNever: () => 'Caching was never used on these calls. If any prefix repeats, that is the largest saving available.',
+    biggestPart: (name, pct) => `${name} is ${pct} of this bill.`,
+    outputDominates: (pct) =>
+      `Output is ${pct} of this bill, so shortening prompts has a low ceiling here. What moves it is asking for shorter answers and capping max_tokens.`,
+    unpriced: (models, calls) =>
+      `${count(calls)} ${calls === 1 ? 'call is' : 'calls are'} not in these totals — the pricing catalogue does not know: ${models}. Add them with a pricing overlay (--pricing) to include them.`,
+    skipped: (lineCount, lines) =>
+      `${count(lineCount)} ${lineCount === 1 ? 'line' : 'lines'} could not be read and ${lineCount === 1 ? 'was' : 'were'} left out (${lineCount === 1 ? 'line' : 'lines'} ${lines}).`,
+    empty: () => 'No usage records in that file.',
+    nothingPriced: () =>
+      'None of the models in that log are in the pricing catalogue, so there is no bill to report. Add them with a pricing overlay (--pricing) and run this again.',
+    assumedWriteTtl: (calls) =>
+      `${count(calls)} ${calls === 1 ? 'call did' : 'calls did'} not say which cache-write TTL was used, so the cheaper 5-minute rate was assumed. A 1-hour entry costs 2x input rather than 1.25x, so this total is a floor for those calls. Record the "cache_creation" object the API returns to remove the assumption.`,
+  },
+
   baseline: {
     recorded: (path, files, tokens) =>
       `Recorded ${files} prompts, ${tokens} tokens, to ${path}. Commit it — the gate compares the tree against what is committed.`,

package/src/i18n/es.ts

@@ -1,5 +1,8 @@
 import type { CliMessages } from './types.js';
 
+/** Counts, grouped. A log with forty thousand torn lines should say so legibly. */
+const count = (value: number): string => value.toLocaleString('es-ES');
+
 /** "(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)`;
@@ -376,7 +379,7 @@ ${bold('EJEMPLOS')}
     inputTokens: () => 'Tokens de entrada',
     estimated: (offFamily) =>
       offFamily === null
-        ? ' (estimado, ±15%)'
+        ? ' (estimado, ±10%)'
         : ` (estimado — el contador está calibrado sobre Claude, no sobre ${offFamily})`,
     exactCount: () => ' (recuento exacto)',
     rulesApplied: () => 'Reglas aplicadas',
@@ -565,7 +568,7 @@ ${bold('EJEMPLOS')}
       `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.',
+      'Los recuentos son estimaciones (±10%). Lo que importa es la tendencia, no las cifras absolutas.',
   },
 
   languages: {
@@ -766,7 +769,7 @@ ${bold('EJEMPLOS')}
     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%',
+    sourceEstimated: () => 'estimado, ±10%',
     sourceExact: () => 'exacto',
     measuringOptimised: () =>
       'Se mide lo que dejarían las reglas, no lo que está escrito en el fichero.',
@@ -811,6 +814,36 @@ ${bold('EJEMPLOS')}
     exactCountsCost: (files) =>
       `Contando ${files} ${files === 1 ? 'fichero' : 'ficheros'} con la API, una llamada por cada uno. Esto tarda un momento.`,
   },
+  profile: {
+    noTarget: () =>
+      'Apúntalo a un log de uso: trazum profile usage.jsonl — un objeto JSON por línea, cada uno con un "model" y el objeto "usage" que devolvió la API. Registrarlo son tres líneas en tu propio código, y nunca contiene el texto del prompt.',
+    heading: () => 'Adónde fue el dinero',
+    spent: (calls, total) => `${calls} llamadas · ${total}`,
+    part: (name, usd, pct, tokens) => `${name.padEnd(15)}${usd.padStart(11)}  ${pct.padStart(5)}   ${tokens} tokens`,
+    partInput: () => 'Entrada',
+    partCacheRead: () => 'Lecturas caché',
+    partCacheWrite: () => 'Escrituras caché',
+    partOutput: () => 'Salida',
+    byLabelHeading: () => 'Por etiqueta',
+    byModelHeading: () => 'Por modelo',
+    row: (name, usd, pct, calls) => `${usd.padStart(11)}  ${pct.padStart(5)}   ${name}  (${calls} llamadas)`,
+    unlabelled: () => 'sin etiqueta',
+    cacheHit: (pct) => `Tasa de acierto de caché: ${pct} de la entrada facturable.`,
+    cacheNever: () => 'No se usó caché en estas llamadas. Si algún prefijo se repite, ese es el mayor ahorro disponible.',
+    biggestPart: (name, pct) => `${name} es el ${pct} de esta factura.`,
+    outputDominates: (pct) =>
+      `La salida es el ${pct} de esta factura, así que acortar prompts tiene un techo bajo aquí. Lo que mueve la aguja es pedir respuestas más cortas y limitar max_tokens.`,
+    unpriced: (models, calls) =>
+      `${count(calls)} ${calls === 1 ? 'llamada no está' : 'llamadas no están'} en estos totales: el catálogo de precios no conoce ${models}. Añádelos con un overlay de precios (--pricing) para incluirlos.`,
+    skipped: (lineCount, lines) =>
+      `No se ${lineCount === 1 ? 'pudo leer' : 'pudieron leer'} ${count(lineCount)} ${lineCount === 1 ? 'línea y quedó fuera' : 'líneas y quedaron fuera'} (${lineCount === 1 ? 'línea' : 'líneas'} ${lines}).`,
+    empty: () => 'No hay registros de uso en ese archivo.',
+    nothingPriced: () =>
+      'Ninguno de los modelos de ese log está en el catálogo de precios, así que no hay factura que reportar. Añádelos con un overlay de precios (--pricing) y vuelve a ejecutarlo.',
+    assumedWriteTtl: (calls) =>
+      `${count(calls)} ${calls === 1 ? 'llamada no dijo' : 'llamadas no dijeron'} qué TTL de escritura de caché se usó, así que se asumió la tarifa más barata, la de 5 minutos. Una entrada de 1 hora cuesta 2x la entrada en vez de 1.25x, así que este total es un suelo para esas llamadas. Registra el objeto "cache_creation" que devuelve la API para quitar la suposición.`,
+  },
+
   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.`,

package/src/i18n/types.ts

@@ -351,6 +351,32 @@ export interface CliMessages {
    * get worse" rather than "does this fit" — and both verdicts appear in the
    * same run.
    */
+  profile: {
+    noTarget(): string;
+    heading(): string;
+    /** Totals line: calls and the bill they came to. */
+    spent(calls: string, total: string): string;
+    /** One row of the split, with its share of the bill. */
+    part(name: string, usd: string, pct: string, tokens: string): string;
+    partInput(): string;
+    partCacheRead(): string;
+    partCacheWrite(): string;
+    partOutput(): string;
+    byLabelHeading(): string;
+    byModelHeading(): string;
+    row(name: string, usd: string, pct: string, calls: string): string;
+    unlabelled(): string;
+    cacheHit(pct: string): string;
+    cacheNever(): string;
+    /** The finding the whole command exists to produce. */
+    biggestPart(name: string, pct: string): string;
+    outputDominates(pct: string): string;
+    unpriced(models: string, calls: number): string;
+    skipped(count: number, lines: string): string;
+    empty(): string;
+    nothingPriced(): string;
+    assumedWriteTtl(calls: number): string;
+  };
   baseline: {
     recorded(path: string, files: string, tokens: string): string;
     recordedMoney(monthly: string, model: string, calls: string): string;

package/src/index.ts

@@ -3,52 +3,56 @@ import { readFile, stat, writeFile } from 'node:fs/promises';
 import { join, resolve as resolvePath } from 'node:path';
 
 import {
+  applyRewrites,
   BASELINE_FILENAME,
   BASELINE_VERSION,
-  MAX_BASELINE_BYTES,
   breaches,
-  compareToBaseline,
-  formatBaseline,
-  moneyIsComparable,
-  parseBaseline,
-  DEFAULT_USAGE,
-  LOCALES,
-  PRICING_LAST_REVIEWED,
-  reviewAgeDays,
-  RULES,
+  cacheableMinimum,
+  cacheHitRate,
   comparePrompts,
-  countTokensAnthropic,
-  getModel,
-  applyRewrites,
+  compareToBaseline,
   computeSavings,
-  profilePrompt,
-  toPromptfoo,
-  PHRASE_LANGUAGES,
+  countTokensAnthropic,
+  DEFAULT_USAGE,
+  detectFromSource,
   estimateTokens,
-  formatUsd,
+  evaluate,
+  extractPrompts,
+  findExamples,
+  formatBaseline,
   formatSignedUsd,
+  formatUsd,
   getMessages,
+  getModel,
+  hasMarker,
   listModels,
+  LOCALES,
+  MAX_BASELINE_BYTES,
+  moneyIsComparable,
   nearestName,
   optimize,
-  toOtlpMetrics,
-  providerFromEnv,
-  reorderForCache,
-  sharedPrefixes,
-  cacheableMinimum,
-  findExamples,
+  parseBaseline,
+  PHRASE_LANGUAGES,
   plannedCalls,
-  pruneExamples,
-  extractPrompts,
+  PRICING_LAST_REVIEWED,
+  profilePrompt,
+  profileUsage,
   promptId,
-  hasMarker,
-  SOURCE_EXTENSIONS,
-  detectFromSource,
-  evaluate,
+  providerFromEnv,
+  pruneExamples,
   refineWithLlm,
   rejectionText,
-  suggestRewrites,
+  reorderForCache,
+  reviewAgeDays,
   reviewExamples,
+  RULES,
+  sharedPrefixes,
+  sharesOf,
+  SOURCE_EXTENSIONS,
+  suggestRewrites,
+  toOtlpMetrics,
+  toPromptfoo,
+  UNLABELLED,
   withExactTokenCounts,
 } from '@trazum/core';
 import { cacheDir, cacheStats, cachingProvider, clearCache } from './suggest-cache.js';
@@ -404,6 +408,7 @@ const COMMAND_FLAGS: Record<string, string[]> = {
   ],
   check: ['max-tokens', 'level', 'exact-tokens', 'markdown-out', 'baseline'],
   baseline: ['model', 'calls', 'output-tokens', 'cache-hit-rate', 'batch', 'exact-tokens', 'out', 'o'],
+  profile: ['json', 'pricing', 'pricing-live'],
   eval: ['cases', 'level', 'concurrency', 'export', 'out', 'o', 'model'],
   prune: ['cases', 'concurrency', 'json', 'yes'],
   diff: ['level', 'model', 'calls', 'output-tokens', 'batch', 'max-growth', 'optimized', 'markdown-out', 'all', 'prompt'],
@@ -504,7 +509,7 @@ function renderDiff(before: string, after: string, t: CliMessages): string {
  * The provider's name when the estimator was not calibrated for it.
  *
  * `estimateTokens` is a heuristic tuned against Claude's tokenizer, and the
- * ±15% band descends from that. Printing the same band beside a GPT or Kimi
+ * ±10% band descends from that. Printing the same band beside a GPT or Kimi
  * figure states a precision nobody has measured for that family — and since the
  * catalogue grew past Anthropic, that is most of it. Returns null when the model
  * is Anthropic's, where the band is at least the claim it was written for.
@@ -527,6 +532,59 @@ function languageNames(codes: readonly string[], t: CliMessages): string {
   return `${names.slice(0, -1).join(', ')} ${t.languages.and} ${names[names.length - 1]}`;
 }
 
+/**
+ * Advisories whose entire pitch is money.
+ *
+ * On a subscription these are not weaker advice, they are not advice: "use a
+ * cheaper model" saves nothing on a flat plan, and its detail text quotes dollars
+ * per month, so suppressing only the price tag beside the title left the money in
+ * the sentence underneath.
+ */
+const MONEY_ONLY_ADVISORIES: ReadonlySet<string> = new Set([
+  'model-downgrade',
+  'batch-api',
+  'output-dominated',
+  'promo-pricing',
+  'prompt-caching-not-worth-it',
+]);
+
+/**
+ * The one thing worth doing about this prompt, and how it compares to shortening it.
+ *
+ * `null` when there is nothing to say: no advisory carries a figure, or the
+ * reader is on a subscription where a monthly saving is meaningless. A heading
+ * with a shrug under it is worse than no heading.
+ */
+function biggestLever(
+  result: OptimizationResult,
+  tokensOnly: boolean,
+  t: CliMessages,
+): { line: string } | null {
+  /**
+   * One guard, and it is the only thing deciding.
+   *
+   * The first version also filtered the candidate list by `!tokensOnly`, which
+   * duplicated this and made it untestable: removing the guard left the filter
+   * still suppressing the line, so a mutation that priced a subscription passed
+   * the suite. Two checks for one condition is one check and one place for a bug.
+   */
+  if (tokensOnly) return null;
+  const best = result.advisories.find((a) => (a.estimatedMonthlyUsd ?? 0) > 0);
+  if (!best?.estimatedMonthlyUsd) return null;
+
+  const ruleSaving = result.savings.monthlySavingsUsd;
+  return {
+    line: t.report.biggestLeverDetail(
+      best.title,
+      formatUsd(best.estimatedMonthlyUsd),
+      // The multiple is the point of the line, and it is only honest when there
+      // is something to divide by. A prompt the rules could not improve at all
+      // gets the amount and no ratio rather than a division by zero dressed up.
+      ruleSaving > 0 ? Math.round(best.estimatedMonthlyUsd / ruleSaving) : null,
+    ),
+  };
+}
+
 function printReport(
   result: OptimizationResult,
   showDiff: boolean,
@@ -543,6 +601,32 @@ function printReport(
       ? c.dim(t.report.estimated(offFamilyName(result.usage.model)))
       : c.dim(t.report.exactCount());
 
+  /**
+   * The largest lever, first.
+   *
+   * This line used to be the last thing in the report and it is the most useful
+   * thing in it. Measured on an ordinary support prompt — already reasonably
+   * written, which is what a real one is — the rules recover **three tokens of
+   * 306**, worth $0.75 a month, while the cache reorder sitting below them is
+   * worth $48. The report opened with the 1.3% and closed with the 64×.
+   *
+   * That ordering is not a presentation quibble. It teaches the reader that
+   * shortening the prompt is what this tool is for, and on any prompt somebody
+   * competent wrote, shortening it is the smallest thing available. The rules
+   * earn their keep on genuine bloat — a duplicated paragraph, "due to the fact
+   * that" — and recover close to nothing once that is gone, because they recover
+   * waste rather than creating savings.
+   *
+   * So the answer to "what should I do about this prompt" goes at the top, and
+   * the token count follows as the detail it is.
+   */
+  const best = biggestLever(result, tokensOnly, t);
+  if (best) {
+    console.log();
+    console.log(c.bold(t.report.biggestLever()));
+    console.log(`  ${c.dim(wrap(best.line, 74, '  '))}`);
+  }
+
   console.log();
   console.log(c.bold(t.report.inputTokens()));
   console.log(
@@ -668,13 +752,7 @@ function printReport(
   // The rest stay: an overflowing context window still fails the call, a
   // contradiction is still wrong, redundant examples still cost tokens, and
   // caching still buys latency and rate-limit headroom.
-  const MONEY_ONLY = new Set([
-    'model-downgrade',
-    'batch-api',
-    'output-dominated',
-    'promo-pricing',
-    'prompt-caching-not-worth-it',
-  ]);
+  const MONEY_ONLY = MONEY_ONLY_ADVISORIES;
   const advisories = tokensOnly
     ? result.advisories.filter((a) => !MONEY_ONLY.has(a.id))
     : result.advisories;
@@ -711,23 +789,8 @@ function printReport(
       console.log(`${gutter}${c.dim(wrap(advisory.detail, 78 - gutter.length, gutter))}`);
     }
 
-    // What to do first. The rules trimmed $1.25 and the top advisory is worth
-    // $506; leaving the reader to notice that by comparing four numbers in four
-    // sentences is how the most valuable line in the report gets skipped.
-    const best = advisories.find((a) => (a.estimatedMonthlyUsd ?? 0) > 0);
-    if (!tokensOnly && best?.estimatedMonthlyUsd) {
-      const ruleSaving = result.savings.monthlySavingsUsd;
-      const line = t.report.biggestLeverDetail(
-        best.title,
-        formatUsd(best.estimatedMonthlyUsd),
-        ruleSaving > 0 ? Math.round(best.estimatedMonthlyUsd / ruleSaving) : null,
-      );
-      console.log();
-      // Wrapped to the same width as everything else. An unwrapped closing line
-      // is the one that runs off a narrow terminal, and it is the line most
-      // worth reading.
-      console.log(`  ${c.bold(t.report.biggestLever())} ${c.dim(wrap(line, 62, '  '))}`);
-    }
+    // The "start here" line is printed at the top of the report now, where a
+    // reader who stops after four lines still sees it.
   }
 
   printSuggestions(suggestions, t, n);
@@ -1802,6 +1865,156 @@ function isoDate(): string {
   return new Date().toISOString().slice(0, 10);
 }
 
+/**
+ * `trazum profile <log.jsonl>` — where the money actually went.
+ *
+ * Every other command in this file reads a prompt and reasons forward about what
+ * it would cost. This one reads what the provider charged and reasons backward,
+ * and it exists because the forward direction can only see the smallest line item:
+ * on an ordinary support prompt the rules recover about 1% of the monthly figure
+ * while output alone was 87% of it.
+ *
+ * **Money is never suppressed here, unlike every other report.** The rest of the
+ * CLI hides dollar figures on a subscription host, because a saving quoted to
+ * somebody on a flat plan is money that does not exist. This log is a record of
+ * metered API calls somebody was actually billed for — the bill exists wherever
+ * Trazum happens to be running, so the host has no bearing on it.
+ */
+async function commandProfile(args: Args, pricing: PricingCatalogue, t: CliMessages): Promise<void> {
+  const path = args.positional[0];
+  if (path === undefined) {
+    console.log();
+    console.log(c.dim(wrap(t.profile.noTarget(), 74, '  ')));
+    console.log();
+    return;
+  }
+
+  const raw = await readFile(path, 'utf8');
+  const report = profileUsage(raw, { catalogue: pricing });
+  const n = (value: number): string => value.toLocaleString(t.numberLocale);
+  const pct = (share: number): string => `${(share * 100).toFixed(1)}%`;
+
+  if (boolFlag(args, 'json')) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  /**
+   * Nothing priced means there is no report, not a report of zero.
+   *
+   * The guard was `total.calls === 0 && unpriced.calls === 0`, so a log whose every
+   * model was unknown fell through and printed a full report built from a zeroed
+   * total: `0 calls · $0`, four `$0 / 0.0%` rows, a meaningless "Input is 0.0% of
+   * this bill", and — on a log containing a hundred thousand cache-read tokens —
+   * the flatly false "Caching was never used on these calls".
+   *
+   * Two affirmatively wrong claims and a $0 headline for a real bill. The trailing
+   * unpriced note was the only correct line on screen, and it was the quietest.
+   */
+  if (report.total.calls === 0) {
+    console.log();
+    console.log(c.dim(report.unpriced.calls === 0 ? t.profile.empty() : t.profile.nothingPriced()));
+    reportProfileGaps(report, t, n);
+    return;
+  }
+
+  const shares = sharesOf(report.total);
+  const parts: Array<[string, number, number, number]> = [
+    [t.profile.partInput(), report.total.inputUsd, shares.input, report.total.inputTokens],
+    [t.profile.partCacheRead(), report.total.cacheReadUsd, shares.cacheRead, report.total.cacheReadTokens],
+    [t.profile.partCacheWrite(), report.total.cacheWriteUsd, shares.cacheWrite, report.total.cacheWriteTokens],
+    [t.profile.partOutput(), report.total.outputUsd, shares.output, report.total.outputTokens],
+  ];
+
+  console.log();
+  console.log(c.bold(t.profile.heading()));
+  console.log(`  ${t.profile.spent(n(report.total.calls), formatUsd(report.total.totalUsd))}`);
+  console.log();
+  // Every part, including the zero ones. A row missing because it was zero reads
+  // as a row somebody forgot, and "you are not caching at all" is a finding.
+  for (const [name, usd, share, tokens] of parts) {
+    console.log(`  ${c.dim(t.profile.part(name, formatUsd(usd), pct(share), n(tokens)))}`);
+  }
+
+  /**
+   * The line the command exists for: which part of the bill to argue with.
+   *
+   * When output is both the biggest part and over half, the two sentences say the
+   * same thing and the second says more — so only the second prints. Reporting a
+   * fact twice in adjacent lines reads as a bug, and it was one.
+   */
+  const [biggestName, , biggestShare] = parts.reduce((a, b) => (b[1] > a[1] ? b : a));
+  const outputDominates = shares.output > 0.5;
+  console.log();
+  if (outputDominates) {
+    console.log(`  ${c.bold(wrap(t.profile.outputDominates(pct(shares.output)), 74, '  '))}`);
+  } else {
+    console.log(`  ${c.bold(t.profile.biggestPart(biggestName, pct(biggestShare)))}`);
+  }
+
+  const hitRate = cacheHitRate(report.total);
+  console.log(
+    hitRate === null
+      ? `  ${c.dim(wrap(t.profile.cacheNever(), 74, '  '))}`
+      : `  ${c.dim(t.profile.cacheHit(pct(hitRate)))}`,
+  );
+
+  /**
+   * A total that assumed a cache-write rate is a floor, and says so.
+   *
+   * Anthropic's 1-hour entry costs 2x input against the 5-minute entry's 1.25x. A
+   * log carrying only the flat `cache_creation_input_tokens` cannot say which, so
+   * the cheaper one is used — and the flattering direction is exactly the one this
+   * tool refuses to take quietly.
+   */
+  if (report.total.assumedWriteTtlCalls > 0) {
+    console.log(
+      `  ${c.dim(wrap(t.profile.assumedWriteTtl(report.total.assumedWriteTtlCalls), 74, '  '))}`,
+    );
+  }
+
+  for (const [heading, rows] of [
+    [t.profile.byLabelHeading(), report.byLabel.map((r) => [r.label === UNLABELLED ? t.profile.unlabelled() : r.label, r.breakdown] as const)],
+    [t.profile.byModelHeading(), report.byModel.map((r) => [r.model, r.breakdown] as const)],
+  ] as const) {
+    if (rows.length <= 1) continue; // One row is the total again, said twice.
+    console.log();
+    console.log(c.bold(heading));
+    for (const [name, breakdown] of rows) {
+      const share = report.total.totalUsd > 0 ? breakdown.totalUsd / report.total.totalUsd : 0;
+      console.log(`  ${t.profile.row(name, formatUsd(breakdown.totalUsd), pct(share), n(breakdown.calls))}`);
+    }
+  }
+
+  reportProfileGaps(report, t, n);
+}
+
+/**
+ * What the profile could not account for, said out loud.
+ *
+ * Separated so both the empty and the populated path print it. A total that
+ * silently omits calls is wrong in the flattering direction, which is the fault
+ * this repository keeps finding in itself.
+ */
+function reportProfileGaps(
+  report: ReturnType<typeof profileUsage>,
+  t: CliMessages,
+  n: (value: number) => string,
+): void {
+  if (report.unpricedModels.length > 0) {
+    console.log();
+    console.log(
+      `  ${c.yellow('!')} ${c.dim(wrap(t.profile.unpriced(report.unpricedModels.join(', '), report.unpriced.calls), 74, '    '))}`,
+    );
+  }
+  if (report.skippedLines.length > 0) {
+    const shown = report.skippedLines.slice(0, 5).join(', ');
+    console.log(
+      `  ${c.dim(t.profile.skipped(report.skippedLines.length, report.skippedLines.length > 5 ? `${shown}…` : shown))}`,
+    );
+  }
+}
+
 /**
  * `trazum baseline <dir>` — record what the estate costs now.
  *
@@ -3292,6 +3505,9 @@ async function main(): Promise<void> {
     case 'baseline':
       await commandBaseline(args, config, pricing, t, locale);
       break;
+    case 'profile':
+      await commandProfile(args, pricing, t);
+      break;
     case 'eval':
       await commandEval(args, config, t, locale);
       break;