@trazum/cli 1.50.4 → 1.50.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trazum/cli",
-  "version": "1.50.4",
+  "version": "1.50.5",
   "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.5"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",

package/src/i18n/en.ts

@@ -1653,6 +1653,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

@@ -1686,6 +1686,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

@@ -1128,6 +1128,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

@@ -40,6 +40,7 @@ import {
   budgetPositions,
   conform,
   outcomeReport,
+  rankPerOutcome,
   FAILURE_POLICIES,
   detectFromSource,
   matchLocale,
@@ -6497,6 +6498,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(