@trazum/cli 1.50.4 → 1.50.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trazum/cli",
-  "version": "1.50.4",
+  "version": "1.50.6",
   "description": "Trazum CLI: find where your LLM bill goes, price every finding per month, and enforce token budgets in CI.",
   "license": "MIT",
   "author": "David Mu\u00f1oz Rey",
@@ -37,7 +37,7 @@
     "prepublishOnly": "npm run build && npm test"
   },
   "dependencies": {
-    "@trazum/core": "1.50.4"
+    "@trazum/core": "1.50.6"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",

package/src/i18n/en.ts

@@ -58,6 +58,7 @@ ${bold('USAGE')}
   trazum models
   trazum rules
   trazum gateway <anthropic|openai> --on-cannot-tell <fail-open|fail-closed>
+  trazum ladder <log>
   trazum feedback
   trazum --version
 
@@ -597,6 +598,12 @@ ${bold('CONFIG FILE')}
     spend     { "maxUsd": 200, "byLabel": { "chat": 40 } } — money budgets for
               "trazum profile", in dollars. A budgeted label with no calls in
               the log is reported as not measured, never as a pass
+    ladders   { "support": { "tiers": ["claude-haiku-4-5", "claude-opus-5"],
+              "escalateOn": ["escalated"] } } — cheap model first, escalate a
+              recorded failure to a dearer one. Both fields required.
+              "trazum ladder <log>" prints the break-even escalation rate
+              beside the measured one: an escalation pays twice, so above that
+              rate the ladder costs more than never having built it
     outcomes  { "values": ["resolved", "escalated"], "success": ["resolved"] } —
               your own vocabulary for what happened, and which of it counts as
               a win. Both required: which words mean success is a judgement
@@ -957,6 +964,47 @@ ${bold('EXAMPLES')}
       `${path} exists and could not be parsed, so nothing was written over it. Fix or move it first.`,
   },
 
+  ladder: {
+    heading: () => 'Escalation ladders',
+    noLadders: () =>
+      'No ladders configured. A ladder sends a workload to a cheap model first and escalates a recorded failure to a dearer one — add "ladders" to trazum.config.json, for example {"support": {"tiers": ["claude-haiku-4-5", "claude-opus-5"], "escalateOn": ["escalated"]}}.',
+    workload: (label) => label,
+    arithmetic: (cheap, dear, breakEven) =>
+      `${cheap} a call cheap, ${dear} dear. Break-even escalation rate: ${breakEven}.`,
+    measured: (rate, escalations, calls) =>
+      `Measured: ${rate} (${escalations} of ${calls} calls escalated).`,
+    saving: (delta) => `Saving ${delta} a call against never having built it.`,
+    costing: (delta) =>
+      `Costing ${delta} a call MORE than never having built it. Escalating above the break-even rate means paying for the cheap attempt and the dear one on most calls.`,
+    atBreakEven: (band) =>
+      `Within ${band} of break-even, so no sign is claimed. Inside that band the answer flips on ordinary week-to-week variation, and "saving" on Monday and "costing" on Thursday from the same policy teaches a reader to ignore the figure.`,
+    cannotTell: (why, calls) =>
+      why === 'too-few-calls'
+        ? `Cannot tell yet: ${calls} calls carried a declared outcome, and a rate over that few moves more from one more call than from anything you could do about it.`
+        : why === 'no-outcomes-recorded'
+          ? 'Cannot tell: nothing in this log recorded an outcome for this workload, so there is no escalation rate to compare against.'
+          : why === 'tier-unpriced'
+            ? 'Cannot tell: one of the tiers is not in the price catalogue, so the break-even rate cannot be computed.'
+            : 'Cannot tell: this ladder declares no escalation values.',
+    problemsHeading: (label) => `${label} — this ladder will not do what it looks like it does`,
+    problem: (kind, detail) =>
+      kind === 'escalate-on-a-success'
+        ? `escalateOn names "${detail}", which "outcomes.success" declares a SUCCESS. This ladder pays twice for work that already worked, on every call, while looking exactly like a cost-saving measure.`
+        : kind === 'escalate-on-undeclared'
+          ? `escalateOn names "${detail}", which "outcomes.values" does not declare. This ladder never fires, silently.`
+          : kind === 'tiers-not-cheapest-first'
+            ? `"${detail}" is cheaper than the tier before it. That is not a ladder; it is a routing rule that escalates to something cheaper and reports a saving for it.`
+            : kind === 'duplicate-tier'
+              ? `"${detail}" appears twice in tiers.`
+              : kind === 'unknown-model'
+                ? `"${detail}" is not in the price catalogue.`
+                : `a ladder needs at least two tiers; this one has ${detail}.`,
+    theDoubleSpend: () =>
+      'An escalation pays twice: the cheap attempt is not refunded. So a ladder saves money only below its break-even escalation rate, and above it costs more than never having built one — which is why the rate is printed beside the measurement rather than left to be worked out in somebody\u2019s head.',
+    notExecuted: () =>
+      'Trazum does not run the escalation. A ladder escalates after a failure is known, which is after the answer came back and usually after something downstream judged it, so the retry belongs in your own loop. What is here is the policy and the arithmetic that says whether the policy is worth running.',
+  },
+
   gateway: {
     badProvider: (given, known) =>
       given === ''
@@ -1653,6 +1701,30 @@ ${bold('EXAMPLES')}
       `${share} of the bill (${usd}) carried no outcome, and is in neither half of the rate above.`,
     outcomeUndeclared: (values) =>
       `Not declared in "outcomes.values": ${values}. Named rather than counted as failures \u2014 a typo in an exporter should look like a typo, not like a product regression.`,
+    perOutcomeHeading: () => 'What an outcome costs',
+    perOutcomeRow: (key, perCall, perOutcome, coverage) => `${key} ${perCall} ${perOutcome} ${coverage}`,
+    perOutcomeColumns: {
+      workload: 'workload',
+      perCall: 'per call',
+      perOutcome: 'per success',
+      recorded: 'recorded',
+    },
+    perOutcomeWithheld: (why, successes, coverage) =>
+      why === 'too-few-outcomes'
+        ? `${successes} so far`
+        : why === 'too-little-coverage'
+          ? `${coverage} covered`
+          : why === 'no-successes-recorded'
+            ? 'none succeeded'
+            : why === 'nothing-recorded'
+              ? 'not recorded'
+              : 'no vocabulary',
+    perOutcomeNumerator: () =>
+      'Per success divides the spend on calls that recorded an outcome, never the whole bill \u2014 dividing everything would charge your uninstrumented traffic to your measured successes and report a figure too high by exactly the uncovered share, silently, in the direction that gets a working feature killed. "recorded" is what share of each workload\u2019s spend the figure covers.',
+    perOutcomeDisagreement: (key, callRank, outcomeRank) =>
+      `${key} is #${callRank} by cost per call and #${outcomeRank} by cost per success.`,
+    perOutcomeBothOrders: () =>
+      'Cheapest per call and cheapest per success are different orders, and both are printed rather than one being picked. A workload can move up one while moving down the other, and somebody optimising on the first number would be moving the wrong one.',
     outcomeColumns: { outcome: 'outcome', calls: 'calls', spend: 'spend' },
     verdictSuccess: () => 'success',
     verdictOther: () => '\u2014',

package/src/i18n/es.ts

@@ -45,6 +45,7 @@ ${bold('USO')}
   trazum models
   trazum rules
   trazum gateway <anthropic|openai> --on-cannot-tell <fail-open|fail-closed>
+  trazum ladder <log>
   trazum feedback
   trazum --version
 
@@ -617,6 +618,12 @@ ${bold('FICHERO DE CONFIGURACIÓN')}
     spend     { "maxUsd": 200, "byLabel": { "chat": 40 } } — presupuestos en
               dólares para "trazum profile". Una etiqueta con presupuesto y sin
               llamadas se informa como no medida, nunca como aprobada
+    ladders   { "support": { "tiers": ["claude-haiku-4-5", "claude-opus-5"],
+              "escalateOn": ["escalated"] } } — modelo barato primero, escalar
+              un fallo registrado a uno más caro. Los dos campos obligatorios.
+              "trazum ladder <log>" imprime la tasa de escalado de equilibrio
+              junto a la medida: un escalado paga dos veces, así que por encima
+              de esa tasa la escalera cuesta más que no haberla construido
     outcomes  { "values": ["resolved", "escalated"], "success": ["resolved"] } —
               tu propio vocabulario para lo que pasó, y cuál de él cuenta como
               acierto. Los dos son obligatorios: qué palabras significan éxito
@@ -993,6 +1000,47 @@ ${bold('EJEMPLOS')}
       `${path} existe y no se pudo interpretar, así que no se escribió nada encima. Arréglalo o muévelo primero.`,
   },
 
+  ladder: {
+    heading: () => 'Escaleras de escalado',
+    noLadders: () =>
+      'No hay escaleras configuradas. Una escalera manda una carga a un modelo barato primero y escala un fallo registrado a uno m\u00e1s caro — a\u00f1ade "ladders" a trazum.config.json, por ejemplo {"support": {"tiers": ["claude-haiku-4-5", "claude-opus-5"], "escalateOn": ["escalated"]}}.',
+    workload: (label) => label,
+    arithmetic: (cheap, dear, breakEven) =>
+      `${cheap} por llamada barata, ${dear} cara. Tasa de escalado de equilibrio: ${breakEven}.`,
+    measured: (rate, escalations, calls) =>
+      `Medido: ${rate} (${escalations} de ${calls} llamadas escalaron).`,
+    saving: (delta) => `Ahorra ${delta} por llamada frente a no haberla construido.`,
+    costing: (delta) =>
+      `Cuesta ${delta} por llamada M\u00c1S que no haberla construido. Escalar por encima de la tasa de equilibrio significa pagar el intento barato y el caro en la mayor\u00eda de las llamadas.`,
+    atBreakEven: (band) =>
+      `A menos de ${band} del equilibrio, as\u00ed que no se afirma ning\u00fan signo. Dentro de esa banda la respuesta cambia con la variaci\u00f3n normal de una semana a otra, y decir "ahorra" el lunes y "cuesta" el jueves con la misma pol\u00edtica ense\u00f1a a ignorar la cifra.`,
+    cannotTell: (why, calls) =>
+      why === 'too-few-calls'
+        ? `A\u00fan no se puede decir: ${calls} llamadas llevaron un resultado declarado, y una tasa sobre tan pocas se mueve m\u00e1s con una llamada m\u00e1s que con nada que pudieras hacer.`
+        : why === 'no-outcomes-recorded'
+          ? 'No se puede decir: nada en este log registr\u00f3 un resultado para esta carga, as\u00ed que no hay tasa de escalado con la que comparar.'
+          : why === 'tier-unpriced'
+            ? 'No se puede decir: uno de los pelda\u00f1os no est\u00e1 en la tabla de precios, as\u00ed que la tasa de equilibrio no se puede calcular.'
+            : 'No se puede decir: esta escalera no declara valores de escalado.',
+    problemsHeading: (label) => `${label} — esta escalera no va a hacer lo que parece`,
+    problem: (kind, detail) =>
+      kind === 'escalate-on-a-success'
+        ? `escalateOn nombra "${detail}", que "outcomes.success" declara como \u00c9XITO. Esta escalera paga dos veces por trabajo que ya funcion\u00f3, en cada llamada, con el aspecto exacto de una medida de ahorro.`
+        : kind === 'escalate-on-undeclared'
+          ? `escalateOn nombra "${detail}", que "outcomes.values" no declara. Esta escalera no se dispara nunca, en silencio.`
+          : kind === 'tiers-not-cheapest-first'
+            ? `"${detail}" es m\u00e1s barato que el pelda\u00f1o anterior. Eso no es una escalera; es una regla de enrutado que escala a algo m\u00e1s barato y lo reporta como ahorro.`
+            : kind === 'duplicate-tier'
+              ? `"${detail}" aparece dos veces en tiers.`
+              : kind === 'unknown-model'
+                ? `"${detail}" no est\u00e1 en la tabla de precios.`
+                : `una escalera necesita al menos dos pelda\u00f1os; esta tiene ${detail}.`,
+    theDoubleSpend: () =>
+      'Un escalado paga dos veces: el intento barato no se devuelve. As\u00ed que una escalera solo ahorra por debajo de su tasa de escalado de equilibrio, y por encima cuesta m\u00e1s que no haberla construido — por eso la tasa se imprime junto a la medici\u00f3n en vez de dejarla para calcularla de cabeza.',
+    notExecuted: () =>
+      'Trazum no ejecuta el escalado. Una escalera escala despu\u00e9s de conocer un fallo, que es despu\u00e9s de que llegue la respuesta y normalmente despu\u00e9s de que algo la juzgue, as\u00ed que el reintento va en tu propio bucle. Lo que hay aqu\u00ed es la pol\u00edtica y la aritm\u00e9tica que dice si merece la pena.',
+  },
+
   gateway: {
     badProvider: (given, known) =>
       given === ''
@@ -1686,6 +1734,30 @@ ${bold('EJEMPLOS')}
       `${share} de la factura (${usd}) no llev\u00f3 resultado, y no est\u00e1 en ninguna de las dos mitades de la tasa de arriba.`,
     outcomeUndeclared: (values) =>
       `No declarados en "outcomes.values": ${values}. Nombrados en vez de contados como fallos \u2014 una errata en un exportador debe parecer una errata, no una regresi\u00f3n del producto.`,
+    perOutcomeHeading: () => 'Lo que cuesta un resultado',
+    perOutcomeRow: (key, perCall, perOutcome, coverage) => `${key} ${perCall} ${perOutcome} ${coverage}`,
+    perOutcomeColumns: {
+      workload: 'carga',
+      perCall: 'por llamada',
+      perOutcome: 'por acierto',
+      recorded: 'cubierto',
+    },
+    perOutcomeWithheld: (why, successes, coverage) =>
+      why === 'too-few-outcomes'
+        ? `${successes} hasta ahora`
+        : why === 'too-little-coverage'
+          ? `${coverage} cubierto`
+          : why === 'no-successes-recorded'
+            ? 'ninguno acert\u00f3'
+            : why === 'nothing-recorded'
+              ? 'sin registrar'
+              : 'sin vocabulario',
+    perOutcomeNumerator: () =>
+      'Por acierto divide el gasto de las llamadas que registraron un resultado, nunca la factura entera \u2014 dividirlo todo cargar\u00eda tu tr\u00e1fico sin instrumentar a tus aciertos medidos y dar\u00eda una cifra alta por exactamente la parte no cubierta, en silencio, en la direcci\u00f3n que mata una funci\u00f3n que s\u00ed funciona. "cubierto" es qu\u00e9 parte del gasto de cada carga cubre la cifra.',
+    perOutcomeDisagreement: (key, callRank, outcomeRank) =>
+      `${key} es el #${callRank} por coste por llamada y el #${outcomeRank} por coste por acierto.`,
+    perOutcomeBothOrders: () =>
+      'M\u00e1s barato por llamada y m\u00e1s barato por acierto son \u00f3rdenes distintos, y se imprimen los dos en vez de elegir uno. Una carga puede subir en uno mientras baja en el otro, y quien optimice por el primer n\u00famero estar\u00eda moviendo el equivocado.',
     outcomeColumns: { outcome: 'resultado', calls: 'llamadas', spend: 'gasto' },
     verdictSuccess: () => '\u00e9xito',
     verdictOther: () => '\u2014',

package/src/i18n/types.ts

@@ -264,6 +264,26 @@ export interface CliMessages {
    * between somebody and their provider is trusted on nothing but what it says
    * plainly at start-up.
    */
+  /**
+   * The ladder. Every line here exists to stop somebody reading "we route to
+   * the cheap model first" as a saving without the number that decides it.
+   */
+  ladder: {
+    heading(): string;
+    noLadders(): string;
+    workload(label: string): string;
+    arithmetic(cheap: string, dear: string, breakEven: string): string;
+    measured(rate: string, escalations: string, calls: string): string;
+    saving(delta: string): string;
+    costing(delta: string): string;
+    atBreakEven(band: string): string;
+    cannotTell(why: string, calls: string): string;
+    problem(kind: string, detail: string): string;
+    problemsHeading(label: string): string;
+    theDoubleSpend(): string;
+    notExecuted(): string;
+  };
+
   gateway: {
     badProvider(given: string, known: string): string;
     needsPolicy(policies: string): string;
@@ -1128,6 +1148,13 @@ export interface CliMessages {
     outcomeNoRate(why: string): string;
     outcomeUnrecorded(share: string, usd: string): string;
     outcomeUndeclared(values: string): string;
+    perOutcomeHeading(): string;
+    perOutcomeRow(key: string, perCall: string, perOutcome: string, coverage: string): string;
+    perOutcomeColumns: { workload: string; perCall: string; perOutcome: string; recorded: string };
+    perOutcomeWithheld(why: string, successes: string, coverage: string): string;
+    perOutcomeNumerator(): string;
+    perOutcomeDisagreement(key: string, callRank: string, outcomeRank: string): string;
+    perOutcomeBothOrders(): string;
     outcomeColumns: { outcome: string; calls: string; spend: string };
     verdictSuccess(): string;
     verdictOther(): string;

package/src/index.ts

@@ -39,7 +39,11 @@ import {
   DEFAULT_USAGE,
   budgetPositions,
   conform,
+  BREAK_EVEN_BAND,
+  ladderPosition,
+  validateLadder,
   outcomeReport,
+  rankPerOutcome,
   FAILURE_POLICIES,
   detectFromSource,
   matchLocale,
@@ -569,6 +573,7 @@ const COMMAND_FLAGS: Record<string, string[]> = {
   conform: ['contract', 'json'],
   feedback: [],
   gateway: ['on-cannot-tell', 'port', 'socket', 'pricing', 'pricing-live'],
+  ladder: ['pricing', 'pricing-live', 'since', 'until', 'label'],
   where: [],
   rules: [],
   blame: ['limit', 'model', 'calls', 'output-tokens', 'batch', 'prompt', 'markdown-out'],
@@ -2189,6 +2194,136 @@ async function commandGateway(
   console.log();
 }
 
+/**
+ * `trazum ladder <log>` — is the ladder saving money, or is it a bill?
+ *
+ * The one number this command exists to print is the **break-even escalation
+ * rate**. "We route to the cheap model first" describes a policy that saves
+ * money and a policy that costs money equally well; only the rate separates
+ * them, and nobody works it out in their head because the shape of the
+ * arithmetic is not obvious — an escalation pays twice, since the cheap
+ * attempt is not refunded.
+ */
+async function commandLadder(
+  args: Args,
+  config: TrazumConfig,
+  pricing: PricingCatalogue,
+  t: CliMessages,
+): Promise<void> {
+  const path = args.positional[0];
+  if (path === undefined) {
+    throw new Error(t.errors.missingInputFile());
+  }
+  const report = profileUsage(await readUsageLog(path, t), { catalogue: pricing });
+  const ladders = config.ladders ?? {};
+  const n = (value: number): string => value.toLocaleString(t.numberLocale);
+  const pct = (value: number): string => `${(value * 100).toFixed(1)}%`;
+
+  console.log();
+  console.log(c.bold(t.ladder.heading()));
+  if (Object.keys(ladders).length === 0) {
+    console.log(`  ${c.dim(wrap(t.ladder.noLadders(), 74, '  '))}`);
+    console.log();
+    return;
+  }
+  console.log(`  ${c.dim(wrap(t.ladder.theDoubleSpend(), 74, '  '))}`);
+  console.log();
+
+  const vocabulary = config.outcomes ?? null;
+  let anyProblem = false;
+
+  for (const [label, policy] of Object.entries(ladders)) {
+    /**
+     * Validated before it is measured, and loudly.
+     *
+     * A ladder that escalates on a value declared a *success* pays twice for
+     * work that already worked, on every call, while looking exactly like a
+     * cost-saving measure in the config. Printing its measured position first
+     * would bury that under a number.
+     */
+    const problems = validateLadder(policy, vocabulary, pricing);
+    if (problems.length > 0) {
+      anyProblem = true;
+      console.log(`  ${c.red('✗')} ${c.bold(t.ladder.problemsHeading(label))}`);
+      for (const problem of problems) {
+        const detail =
+          'value' in problem
+            ? problem.value
+            : 'model' in problem
+              ? problem.model
+              : String(problem.tiers);
+        console.log(`      ${wrap(t.ladder.problem(problem.kind, detail), 70, '      ')}`);
+      }
+      console.log();
+      continue;
+    }
+
+    const slice = report.outcomeTallyByLabel.find((entry) => entry.label === label);
+    const breakdown = report.byLabel.find((entry) => entry.label === label);
+    /**
+     * The shape of the work comes from the measured calls, so the break-even
+     * rate is priced against what this workload actually sends rather than
+     * against a token count somebody guessed at.
+     */
+    const calls = breakdown?.breakdown.calls ?? 0;
+    const shape =
+      breakdown === undefined || calls === 0
+        ? { inputTokens: 0, outputTokens: 0 }
+        : {
+            inputTokens: Math.round(
+              (breakdown.breakdown.inputTokens +
+                breakdown.breakdown.cacheReadTokens +
+                breakdown.breakdown.cacheWriteTokens) /
+                calls,
+            ),
+            outputTokens: Math.round(breakdown.breakdown.outputTokens / calls),
+          };
+
+    const empty = { byValue: [], recorded: 0, parsed: 0, unrecordedUsd: 0 };
+    const position = ladderPosition(policy, slice?.tally ?? empty, shape, vocabulary, pricing);
+
+    console.log(`  ${c.bold(t.ladder.workload(label))}  ${c.dim(policy.tiers.join(' → '))}`);
+    console.log(
+      `    ${c.dim(
+        t.ladder.arithmetic(
+          formatUsd(position.arithmetic.cheapUsd),
+          formatUsd(position.arithmetic.dearUsd),
+          position.arithmetic.breakEvenRate === null ? '—' : pct(position.arithmetic.breakEvenRate),
+        ),
+      )}`,
+    );
+
+    if (position.verdict === 'cannot-tell') {
+      console.log(
+        `    ${c.yellow('?')} ${wrap(t.ladder.cannotTell(position.unknown ?? '', n(position.calls)), 70, '      ')}`,
+      );
+    } else {
+      console.log(
+        `    ${t.ladder.measured(pct(position.measuredRate ?? 0), n(position.escalations), n(position.calls))}`,
+      );
+      const delta = formatUsd(Math.abs(position.deltaUsdPerCall ?? 0));
+      if (position.verdict === 'saving') {
+        console.log(`    ${c.green('✓')} ${wrap(t.ladder.saving(delta), 70, '      ')}`);
+      } else if (position.verdict === 'costing') {
+        console.log(`    ${c.red('✗')} ${wrap(t.ladder.costing(delta), 70, '      ')}`);
+      } else {
+        console.log(`    ${c.dim('·')} ${wrap(t.ladder.atBreakEven(pct(BREAK_EVEN_BAND)), 70, '      ')}`);
+      }
+    }
+    console.log();
+  }
+
+  console.log(`  ${c.dim(wrap(t.ladder.notExecuted(), 74, '  '))}`);
+  console.log();
+
+  /**
+   * A misconfigured ladder fails the command, because it is the one finding
+   * here that is wrong *now* rather than a measurement somebody should look
+   * at. Everything else exits 0: this is a survey, like `doctor`.
+   */
+  if (anyProblem) process.exitCode = 1;
+}
+
 function commandModels(t: CliMessages, pricing: PricingCatalogue): void {
   const n = (value: number): string => value.toLocaleString(t.numberLocale);
   const col = t.models.columns;
@@ -6497,6 +6632,76 @@ async function commandProfile(
           )}`,
         );
       }
+      /**
+       * What an outcome costs, per workload — the finding a total cannot make.
+       *
+       * Printed only when at least one workload has enough recorded outcomes
+       * to say something, and every row that cannot state a figure says which
+       * of the five reasons applies rather than showing a blank.
+       */
+      const ranking = rankPerOutcome(
+        report.outcomeTallyByLabel.map((entry) => ({
+          key: entry.label,
+          calls: entry.calls,
+          totalUsd: entry.totalUsd,
+          tally: entry.tally,
+        })),
+        config.outcomes ?? null,
+      );
+      if (ranking.byCall.length > 0) {
+        console.log();
+        console.log(c.bold(t.profile.perOutcomeHeading()));
+        const pcol = t.profile.perOutcomeColumns;
+        const prows = ranking.byCall.map((slice) => ({
+          key: slice.key,
+          perCall: formatUsd(slice.usdPerCall),
+          perOutcome:
+            slice.per.usdPerSuccess !== null
+              ? formatUsd(slice.per.usdPerSuccess)
+              : t.profile.perOutcomeWithheld(
+                  slice.per.withheld ?? 'no-vocabulary',
+                  n(slice.per.successes),
+                  pct(slice.per.coverage),
+                ),
+          recorded: pct(slice.per.coverage),
+        }));
+        const pw = {
+          key: Math.max(...prows.map((r) => r.key.length), pcol.workload.length),
+          perCall: Math.max(...prows.map((r) => r.perCall.length), pcol.perCall.length),
+          perOutcome: Math.max(...prows.map((r) => r.perOutcome.length), pcol.perOutcome.length),
+          recorded: Math.max(...prows.map((r) => r.recorded.length), pcol.recorded.length),
+        };
+        console.log(
+          c.dim(
+            `  ${pcol.workload.padEnd(pw.key)}  ${pcol.perCall.padStart(pw.perCall)}  ` +
+              `${pcol.perOutcome.padStart(pw.perOutcome)}  ${pcol.recorded.padStart(pw.recorded)}`,
+          ),
+        );
+        for (const row of prows) {
+          console.log(
+            `  ${row.key.padEnd(pw.key)}  ${row.perCall.padStart(pw.perCall)}  ` +
+              `${row.perOutcome.padStart(pw.perOutcome)}  ${c.dim(row.recorded.padStart(pw.recorded))}`,
+          );
+        }
+        console.log();
+        console.log(`  ${c.dim(wrap(t.profile.perOutcomeNumerator(), 74, '    '))}`);
+
+        // The disagreement between the two orders, which is itself the finding.
+        if (ranking.disagreements.length > 0) {
+          console.log();
+          console.log(`  ${c.dim(wrap(t.profile.perOutcomeBothOrders(), 74, '    '))}`);
+          for (const d of ranking.disagreements) {
+            console.log(
+              `  ${c.yellow('→')} ${wrap(
+                t.profile.perOutcomeDisagreement(d.slice.key, n(d.callRank + 1), n(d.outcomeRank + 1)),
+                74,
+                '    ',
+              )}`,
+            );
+          }
+        }
+      }
+
       if (outcomes.undeclared.length > 0) {
         console.log(
           `  ${c.yellow('!')} ${wrap(
@@ -8319,6 +8524,9 @@ async function main(): Promise<void> {
     case 'models':
       commandModels(t, pricing);
       break;
+    case 'ladder':
+      await commandLadder(args, config, pricing, t);
+      break;
     case 'gateway':
       await commandGateway(args, config, configDir, pricing, t);
       break;