@trazum/cli 1.50.8 → 1.50.10

package/package.json

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

package/src/i18n/en.ts

@@ -60,6 +60,8 @@ ${bold('USAGE')}
   trazum gateway <anthropic|openai> --on-cannot-tell <fail-open|fail-closed>
   trazum experiment <log> --a <label> --b <label> --min-outcomes <n>
   trazum quality <log> --label <name> --at <iso> [--gate]
+  trazum semantic <prompt> [--yes]
+  trazum owners <log>
   trazum ladder <log>
   trazum feedback
   trazum --version
@@ -147,6 +149,17 @@ ${bold('OPTIONS FOR quality')}
   whenever the model mix, the call volume or the outcome coverage moved across
   the boundary — the prompt is not the only variable and it says so.
 
+${bold('OPTIONS FOR semantic')}
+  --yes                       Required to send anything. Without it the command
+                              prints what the call would cost and stops.
+  --model <id>                Which model to ask. Priced from the catalogue.
+
+  Finds what a dictionary cannot: the same rule taught twice in different
+  words, an instruction restated far away, a policy a later clause contradicts.
+  Every quoted passage is checked character for character against the prompt,
+  pairs the rules engine already catches are dropped, and every token figure is
+  counted rather than believed. Optional, and always will be.
+
 ${bold('OPTIONS FOR prune')}
   --cases <file>              One input per line, or a JSON array. Required.
   --yes                       Actually spend the calls. Without it the estimate is
@@ -626,6 +639,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
+    owners    { "patterns": { "payments": ["billing-*"] },
+              "shared": { "search": { "payments": 0.6, "support": 0.4 } },
+              "budgets": { "payments": 400 } } — whose budget each workload
+              lands on. Spend matching no owner is its own line and is NEVER
+              divided between the others; a shared split must sum to 1, and the
+              rule travels with the report so the argument is about the rule
     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.
@@ -992,6 +1011,65 @@ ${bold('EXAMPLES')}
       `${path} exists and could not be parsed, so nothing was written over it. Fix or move it first.`,
   },
 
+  owners: {
+    heading: () => 'Whose money',
+    noOwners: () =>
+      'No owners configured. Add "owners" to trazum.config.json to attribute spend, for example {"patterns": {"payments": ["billing-*"]}, "budgets": {"payments": 400}}.',
+    columns: { owner: 'owner', spend: 'spend', budget: 'budget', calls: 'calls' },
+    verdict: (kind) =>
+      kind === 'over' ? 'over' : kind === 'within' ? 'within' : kind === 'not-measured' ? 'not measured' : '\u2014',
+    unallocated: (usd, share, labels) =>
+      `Unallocated: ${usd} (${share} of the bill), from ${labels}.`,
+    neverSpread: () =>
+      'It is not divided between the owners above, and it never will be. Spreading unattributed spend proportionally is the most common lie in cost reporting: it makes every line add up and every team\u2019s number wrong by an amount nobody can see \u2014 hardest on whoever instruments best, because their known spend is largest and they absorb the biggest share of somebody else\u2019s mystery. Claim it with a pattern.',
+    nothingUnallocated: () => 'Every workload in this log has an owner.',
+    sharedHeading: () => 'Shared, by a rule somebody wrote',
+    sharedRule: (label, rule) => `${label}: ${rule}`,
+    problemsHeading: () => 'This ownership config will not do what it looks like it does',
+    problem: (kind, detail) =>
+      kind === 'split-does-not-sum'
+        ? `${detail} \u2014 a split that does not sum to 1 loses money or invents it, silently. That workload is left whole in the unallocated line until this is fixed.`
+        : kind === 'split-names-unknown-owner'
+          ? `${detail} names an owner that "owners.patterns" does not declare.`
+          : kind === 'split-has-one-owner'
+            ? `${detail} is "shared" with one owner \u2014 that is a pattern written the long way, and reading it as a share invites a second owner to be added without the first being adjusted.`
+            : kind === 'negative-share'
+              ? `${detail} has a negative share.`
+              : `${detail} has a budget but no patterns, so nothing can ever land on it.`,
+    notMeasured: (owner) =>
+      `${owner} has a budget and no measured calls. That is NOT under budget \u2014 a team whose logs never arrived passes every budget it has, forever, and a green tick beside their name says the opposite of the truth.`,
+  },
+
+  semantic: {
+    heading: (path) => `Semantic pass on ${path}`,
+    willCost: (usd, input, output, model) =>
+      `This will send the prompt to ${model}: about ${input} tokens in and ${output} out, roughly ${usd}. Estimated, not measured \u2014 a tool that spends your money to tell you how to spend less should be the first thing audited by its own arithmetic. Pass --yes to run it.`,
+    needsYes: () => 'Nothing was sent. Add --yes once you have read the price above.',
+    finding: (kind, because) =>
+      `${kind === 'contradiction' ? 'Contradiction' : kind === 'restated-instruction' ? 'Restated' : 'Same thing, different words'}: ${because}`,
+    span: (line, text) => `line ${line}: ${text}`,
+    ceiling: (tokens) =>
+      `At most ${tokens} tokens \u2014 a ceiling, not a saving. Merging these two means writing one passage that does the work of both, and nobody knows yet how long that is.`,
+    noCeiling: () =>
+      'No tokens attached. A contradiction is worth fixing because the prompt is wrong, not because it is long, and putting a figure on it would sell the wrong reason.',
+    nothingFound: () => 'Nothing survived checking. That is a real answer.',
+    rejected: (count) => `${count} proposals did not survive checking against the prompt.`,
+    rejectedLine: (reason, span) =>
+      reason === 'span-not-found'
+        ? `paraphrased its own evidence: ${span}`
+        : reason === 'already-detected'
+          ? `already found without a model: ${span}`
+          : reason === 'contradiction-of-a-copy'
+            ? `called a near-copy a contradiction: ${span}`
+            : reason === 'spans-identical' || reason === 'spans-overlap'
+              ? `quoted the same passage twice: ${span}`
+              : `covers ground an accepted finding covers: ${span}`,
+    disposes: () =>
+      'The model proposes and the deterministic layer disposes: every quoted passage is checked character for character against the prompt, pairs the rules engine already catches are dropped, and every token figure is counted here rather than believed.',
+    optIn: () =>
+      'This pass is optional and always will be. Trazum works with no key, no network and no model \u2014 that has been true since 0.1.0 and this does not change it.',
+  },
+
   quality: {
     heading: (label) => `Quality across the change: ${label}`,
     needsLabel: () => 'Name the workload with --label: this compares one label before and after a change, and a mixture of workloads would average a regression away.',

package/src/i18n/es.ts

@@ -47,6 +47,8 @@ ${bold('USO')}
   trazum gateway <anthropic|openai> --on-cannot-tell <fail-open|fail-closed>
   trazum experiment <log> --a <label> --b <label> --min-outcomes <n>
   trazum quality <log> --label <name> --at <iso> [--gate]
+  trazum semantic <prompt> [--yes]
+  trazum owners <log>
   trazum ladder <log>
   trazum feedback
   trazum --version
@@ -137,6 +139,17 @@ ${bold('OPCIONES DE quality')}
   siempre que la mezcla de modelos, el volumen o la cobertura se movieran a
   través de la frontera — el prompt no es la única variable y lo dice.
 
+${bold('OPCIONES DE semantic')}
+  --yes                       Obligatorio para enviar nada. Sin él, el comando
+                              imprime lo que costaría la llamada y para.
+  --model <id>                Qué modelo preguntar. Se tarifa del catálogo.
+
+  Encuentra lo que un diccionario no puede: la misma regla enseñada dos veces
+  con otras palabras, una instrucción repetida lejos, una política que una
+  cláusula posterior contradice. Cada pasaje citado se comprueba carácter a
+  carácter contra el prompt, los pares que el motor de reglas ya caza se
+  descartan, y toda cifra de tokens se cuenta en vez de creérsela.
+
 ${bold('OPCIONES DE prune')}
   --cases <fichero>           Una entrada por línea, o un array JSON. Obligatorio.
   --yes                       Gasta las llamadas de verdad. Sin él se imprime la
@@ -646,6 +659,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
+    owners    { "patterns": { "payments": ["billing-*"] },
+              "shared": { "search": { "payments": 0.6, "support": 0.4 } },
+              "budgets": { "payments": 400 } } — de quién es el presupuesto de
+              cada carga. El gasto sin propietario es su propia línea y NUNCA se
+              reparte entre los demás; un reparto compartido debe sumar 1, y la
+              regla viaja con el informe para que se discuta la regla
     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.
@@ -1028,6 +1047,65 @@ ${bold('EJEMPLOS')}
       `${path} existe y no se pudo interpretar, así que no se escribió nada encima. Arréglalo o muévelo primero.`,
   },
 
+  owners: {
+    heading: () => 'De qui\u00e9n es el dinero',
+    noOwners: () =>
+      'No hay propietarios configurados. A\u00f1ade "owners" a trazum.config.json para atribuir gasto, por ejemplo {"patterns": {"payments": ["billing-*"]}, "budgets": {"payments": 400}}.',
+    columns: { owner: 'propietario', spend: 'gasto', budget: 'presupuesto', calls: 'llamadas' },
+    verdict: (kind) =>
+      kind === 'over' ? 'pasado' : kind === 'within' ? 'dentro' : kind === 'not-measured' ? 'sin medir' : '\u2014',
+    unallocated: (usd, share, labels) =>
+      `Sin asignar: ${usd} (${share} de la factura), de ${labels}.`,
+    neverSpread: () =>
+      'No se reparte entre los propietarios de arriba, y nunca se har\u00e1. Repartir el gasto sin atribuir de forma proporcional es la mentira m\u00e1s com\u00fan en informes de coste: hace que todas las l\u00edneas cuadren y que el n\u00famero de cada equipo est\u00e9 mal en una cantidad que nadie puede ver \u2014 y castiga m\u00e1s a quien mejor instrumenta, porque su gasto conocido es el mayor y absorbe la mayor parte del misterio ajeno. Recl\u00e1malo con un patr\u00f3n.',
+    nothingUnallocated: () => 'Todas las cargas de este log tienen propietario.',
+    sharedHeading: () => 'Compartido, por una regla que escribi\u00f3 alguien',
+    sharedRule: (label, rule) => `${label}: ${rule}`,
+    problemsHeading: () => 'Esta configuraci\u00f3n de propiedad no va a hacer lo que parece',
+    problem: (kind, detail) =>
+      kind === 'split-does-not-sum'
+        ? `${detail} \u2014 un reparto que no suma 1 pierde dinero o lo inventa, en silencio. Esa carga se deja entera en la l\u00ednea sin asignar hasta que se arregle.`
+        : kind === 'split-names-unknown-owner'
+          ? `${detail} nombra un propietario que "owners.patterns" no declara.`
+          : kind === 'split-has-one-owner'
+            ? `${detail} est\u00e1 "compartido" con un solo propietario \u2014 eso es un patr\u00f3n escrito largo, y leerlo como reparto invita a a\u00f1adir un segundo sin ajustar el primero.`
+            : kind === 'negative-share'
+              ? `${detail} tiene un reparto negativo.`
+              : `${detail} tiene presupuesto pero no patrones, as\u00ed que nunca podr\u00e1 caerle nada.`,
+    notMeasured: (owner) =>
+      `${owner} tiene presupuesto y ninguna llamada medida. Eso NO es estar dentro del presupuesto \u2014 un equipo cuyos logs nunca llegaron pasa todos sus presupuestos, siempre, y un tic verde junto a su nombre dice lo contrario de la verdad.`,
+  },
+
+  semantic: {
+    heading: (path) => `Pase sem\u00e1ntico sobre ${path}`,
+    willCost: (usd, input, output, model) =>
+      `Esto enviar\u00e1 el prompt a ${model}: unos ${input} tokens de entrada y ${output} de salida, aproximadamente ${usd}. Estimado, no medido \u2014 una herramienta que gasta tu dinero para decirte c\u00f3mo gastar menos deber\u00eda ser lo primero que audite su propia aritm\u00e9tica. Pasa --yes para ejecutarlo.`,
+    needsYes: () => 'No se envi\u00f3 nada. A\u00f1ade --yes cuando hayas le\u00eddo el precio de arriba.',
+    finding: (kind, because) =>
+      `${kind === 'contradiction' ? 'Contradicci\u00f3n' : kind === 'restated-instruction' ? 'Repetido' : 'Lo mismo con otras palabras'}: ${because}`,
+    span: (line, text) => `l\u00ednea ${line}: ${text}`,
+    ceiling: (tokens) =>
+      `Como mucho ${tokens} tokens \u2014 un techo, no un ahorro. Fundir los dos significa escribir un pasaje que haga el trabajo de ambos, y nadie sabe todav\u00eda cu\u00e1nto ocupa.`,
+    noCeiling: () =>
+      'Sin tokens asociados. Una contradicci\u00f3n merece arreglarse porque el prompt est\u00e1 mal, no porque sea largo, y ponerle una cifra vender\u00eda el motivo equivocado.',
+    nothingFound: () => 'Nada sobrevivi\u00f3 a la comprobaci\u00f3n. Esa es una respuesta real.',
+    rejected: (count) => `${count} propuestas no sobrevivieron a la comprobaci\u00f3n contra el prompt.`,
+    rejectedLine: (reason, span) =>
+      reason === 'span-not-found'
+        ? `parafrase\u00f3 su propia evidencia: ${span}`
+        : reason === 'already-detected'
+          ? `ya se encuentra sin modelo: ${span}`
+          : reason === 'contradiction-of-a-copy'
+            ? `llam\u00f3 contradicci\u00f3n a una casi copia: ${span}`
+            : reason === 'spans-identical' || reason === 'spans-overlap'
+              ? `cit\u00f3 el mismo pasaje dos veces: ${span}`
+              : `cubre terreno que ya cubre un hallazgo aceptado: ${span}`,
+    disposes: () =>
+      'El modelo propone y la capa determinista dispone: cada pasaje citado se comprueba car\u00e1cter a car\u00e1cter contra el prompt, los pares que el motor de reglas ya caza se descartan, y toda cifra de tokens se cuenta aqu\u00ed en vez de cre\u00e9rsela.',
+    optIn: () =>
+      'Este pase es opcional y siempre lo ser\u00e1. Trazum funciona sin clave, sin red y sin modelo \u2014 eso es cierto desde 0.1.0 y esto no lo cambia.',
+  },
+
   quality: {
     heading: (label) => `Calidad a trav\u00e9s del cambio: ${label}`,
     needsLabel: () => 'Nombra la carga con --label: esto compara una etiqueta antes y despu\u00e9s de un cambio, y una mezcla de cargas promediar\u00eda una regresi\u00f3n hasta hacerla desaparecer.',

package/src/i18n/types.ts

@@ -268,6 +268,36 @@ export interface CliMessages {
    * 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.
    */
+  owners: {
+    heading(): string;
+    noOwners(): string;
+    columns: { owner: string; spend: string; budget: string; calls: string };
+    verdict(kind: string): string;
+    unallocated(usd: string, share: string, labels: string): string;
+    neverSpread(): string;
+    nothingUnallocated(): string;
+    sharedHeading(): string;
+    sharedRule(label: string, rule: string): string;
+    problemsHeading(): string;
+    problem(kind: string, detail: string): string;
+    notMeasured(owner: string): string;
+  };
+
+  semantic: {
+    heading(path: string): string;
+    willCost(usd: string, input: string, output: string, model: string): string;
+    needsYes(): string;
+    finding(kind: string, because: string): string;
+    span(line: string, text: string): string;
+    ceiling(tokens: string): string;
+    noCeiling(): string;
+    nothingFound(): string;
+    rejected(count: string): string;
+    rejectedLine(reason: string, span: string): string;
+    disposes(): string;
+    optIn(): string;
+  };
+
   quality: {
     heading(label: string): string;
     needsLabel(): string;

package/src/index.ts

@@ -40,8 +40,12 @@ import {
   budgetPositions,
   conform,
   BREAK_EVEN_BAND,
+  allocate,
   runExperiment,
   qualityGate,
+  semanticPassCost,
+  verifySemanticProposals,
+  SEMANTIC_SYSTEM_PROMPT,
   ladderPosition,
   validateLadder,
   outcomeReport,
@@ -143,6 +147,7 @@ import type {
   ContractName,
   ExperimentArm,
   GateSide,
+  SemanticProposal,
   FailurePolicy,
   GatewayStanding,
   UsageProfileReport,
@@ -584,6 +589,8 @@ const COMMAND_FLAGS: Record<string, string[]> = {
   ladder: ['pricing', 'pricing-live', 'since', 'until', 'label'],
   experiment: ['a', 'b', 'min-outcomes', 'pricing', 'pricing-live'],
   quality: ['label', 'at', 'gate', 'pricing', 'pricing-live'],
+  semantic: ['yes', 'model', 'pricing', 'pricing-live'],
+  owners: ['pricing', 'pricing-live', 'since', 'until'],
   where: [],
   rules: [],
   blame: ['limit', 'model', 'calls', 'output-tokens', 'batch', 'prompt', 'markdown-out'],
@@ -2609,6 +2616,266 @@ async function commandQuality(
   console.log();
 }
 
+/**
+ * `trazum semantic <prompt> [--yes]` — the findings a dictionary cannot see.
+ *
+ * The rules engine has deferred these since 0.1.0 for one honest reason: a
+ * dictionary cannot see meaning, and a model that hallucinates a finding is
+ * worse than a rule that misses one.
+ *
+ * **The price is printed before anything is sent, and `--yes` is required.** A
+ * tool that spends somebody's money to tell them how to spend less has to be
+ * the first thing audited by its own arithmetic, and it has to ask.
+ */
+async function commandSemantic(
+  args: Args,
+  config: TrazumConfig,
+  pricing: PricingCatalogue,
+  t: CliMessages,
+): Promise<void> {
+  const prompt = await readInput(args.positional[0], t);
+  const modelId = stringFlag(args, 'model') ?? config.usage?.model ?? DEFAULT_USAGE.model;
+  const model = pricing.byId.get(modelId) ?? getModel(DEFAULT_USAGE.model);
+  const rates = { inputPerMTok: model.inputPerMTok, outputPerMTok: model.outputPerMTok };
+  const cost = semanticPassCost(prompt, rates);
+  const n = (value: number): string => value.toLocaleString(t.numberLocale);
+
+  console.log();
+  console.log(c.bold(t.semantic.heading(args.positional[0] ?? '-')));
+  console.log();
+  console.log(
+    `  ${wrap(
+      t.semantic.willCost(formatUsd(cost.usd), n(cost.inputTokens), n(cost.outputTokens), model.displayName),
+      74,
+      '  ',
+    )}`,
+  );
+
+  if (!boolFlag(args, 'yes')) {
+    // Nothing has been sent at this point, and nothing will be. The price
+    // above is the whole output of a run without --yes.
+    console.log();
+    console.log(`  ${c.dim(t.semantic.needsYes())}`);
+    console.log();
+    return;
+  }
+
+  const provider = providerFromEnv();
+  if (!provider) throw new Error(t.errors.llmNotConfigured());
+
+  const answer = await provider.complete({ system: SEMANTIC_SYSTEM_PROMPT, user: prompt });
+  let proposals: SemanticProposal[] = [];
+  try {
+    const parsed: unknown = JSON.parse(
+      /^(?:```|~~~)[a-zA-Z]*\n([\s\S]*?)\n?(?:```|~~~)$/.exec(answer.trim())?.[1] ?? answer.trim(),
+    );
+    /**
+     * A response that is not the shape asked for is **no proposals**, never a
+     * crash and never a partial read. The model was told exactly what to
+     * return; anything else is a response this layer cannot check, and an
+     * unchecked finding is the one thing this whole module exists to prevent.
+     */
+    if (Array.isArray(parsed)) {
+      proposals = parsed.filter(
+        (entry): entry is SemanticProposal =>
+          typeof entry === 'object' &&
+          entry !== null &&
+          Array.isArray((entry as SemanticProposal).spans) &&
+          (entry as SemanticProposal).spans.length === 2 &&
+          (entry as SemanticProposal).spans.every((span) => typeof span === 'string'),
+      );
+    }
+  } catch {
+    proposals = [];
+  }
+
+  const result = verifySemanticProposals(prompt, proposals);
+  const lineOf = (offset: number): number => prompt.slice(0, offset).split('\n').length;
+
+  console.log();
+  if (result.findings.length === 0) {
+    console.log(`  ${c.dim(t.semantic.nothingFound())}`);
+  }
+  for (const finding of result.findings) {
+    console.log(`  ${c.bold(t.semantic.finding(finding.kind, finding.because))}`);
+    finding.spans.forEach((span, index) => {
+      const shown = span.length > 90 ? `${span.slice(0, 87)}…` : span;
+      console.log(`    ${c.dim(t.semantic.span(String(lineOf(finding.offsets[index] ?? 0)), shown))}`);
+    });
+    console.log(
+      `    ${c.dim(
+        wrap(
+          finding.ceilingTokens > 0 ? t.semantic.ceiling(n(finding.ceilingTokens)) : t.semantic.noCeiling(),
+          70,
+          '    ',
+        ),
+      )}`,
+    );
+    console.log();
+  }
+
+  /**
+   * What did **not** survive, counted and reasoned.
+   *
+   * A pass that showed only its accepted findings would hide its own hit
+   * rate, and the hit rate is the most useful thing a reader can know about
+   * whether to run it again.
+   */
+  if (result.rejected.length > 0) {
+    console.log(`  ${c.dim(t.semantic.rejected(n(result.rejected.length)))}`);
+    for (const { proposal, reason } of result.rejected.slice(0, 5)) {
+      const span = proposal.spans[0];
+      const shown = span.length > 50 ? `${span.slice(0, 47)}…` : span;
+      console.log(`    ${c.dim(t.semantic.rejectedLine(reason, shown))}`);
+    }
+    console.log();
+  }
+
+  console.log(`  ${c.dim(wrap(t.semantic.disposes(), 74, '  '))}`);
+  console.log(`  ${c.dim(wrap(t.semantic.optIn(), 74, '  '))}`);
+  console.log();
+}
+
+/**
+ * `trazum owners <log>` — whose budget each workload lands on.
+ *
+ * The fleet answered *which service* in 1.37. This answers *whose money*,
+ * which is the question that decides whether anything on the list gets done: a
+ * report saying "the bill is $40,000 and here is $9,000 of savings" is read by
+ * four people who each assume it is one of the other three's problem.
+ *
+ * **The unallocated is its own line and is never spread.** See `owners.ts` for
+ * why that is worth breaking a module over.
+ */
+async function commandOwners(
+  args: Args,
+  config: TrazumConfig,
+  pricing: PricingCatalogue,
+  t: CliMessages,
+): Promise<void> {
+  const path = args.positional[0];
+  if (path === undefined) throw new Error(t.errors.missingInputFile());
+
+  console.log();
+  console.log(c.bold(t.owners.heading()));
+  if (config.owners === undefined) {
+    console.log(`  ${c.dim(wrap(t.owners.noOwners(), 74, '  '))}`);
+    console.log();
+    return;
+  }
+
+  const report = profileUsage(await readUsageLog(path, t), { catalogue: pricing });
+  const result = allocate(
+    report.byLabel.map((entry) => ({
+      label: entry.label,
+      usd: entry.breakdown.totalUsd,
+      calls: entry.breakdown.calls,
+    })),
+    config.owners,
+  );
+  const n = (value: number): string => value.toLocaleString(t.numberLocale);
+  const pct = (value: number): string => `${(value * 100).toFixed(1)}%`;
+
+  /**
+   * Problems first, before any figure.
+   *
+   * A split that does not sum to one sends a whole workload to unallocated,
+   * and a reader who saw the table before the explanation would go looking for
+   * a bug in their logs.
+   */
+  if (result.problems.length > 0) {
+    console.log();
+    console.log(`  ${c.red('✗')} ${c.bold(t.owners.problemsHeading())}`);
+    for (const problem of result.problems) {
+      const detail =
+        problem.kind === 'budget-for-unknown-owner'
+          ? problem.owner
+          : problem.kind === 'split-does-not-sum'
+            ? `"${problem.label}" sums to ${problem.total}`
+            : problem.kind === 'negative-share' || problem.kind === 'split-names-unknown-owner'
+              ? `"${problem.label}" → ${problem.owner}`
+              : `"${problem.label}"`;
+      console.log(`      ${wrap(t.owners.problem(problem.kind, detail), 70, '      ')}`);
+    }
+    process.exitCode = 1;
+  }
+
+  console.log();
+  const col = t.owners.columns;
+  const rows = result.owners.map((line) => ({
+    owner: line.owner,
+    spend: formatUsd(line.usd),
+    budget: line.budgetUsd === null ? '—' : formatUsd(line.budgetUsd),
+    calls: n(Math.round(line.calls)),
+    verdict: t.owners.verdict(line.verdict),
+    kind: line.verdict,
+  }));
+  const w = {
+    owner: Math.max(...rows.map((r) => r.owner.length), col.owner.length),
+    spend: Math.max(...rows.map((r) => r.spend.length), col.spend.length),
+    budget: Math.max(...rows.map((r) => r.budget.length), col.budget.length),
+    calls: Math.max(...rows.map((r) => r.calls.length), col.calls.length),
+  };
+  console.log(
+    c.dim(
+      `  ${col.owner.padEnd(w.owner)}  ${col.spend.padStart(w.spend)}  ` +
+        `${col.budget.padStart(w.budget)}  ${col.calls.padStart(w.calls)}`,
+    ),
+  );
+  for (const row of rows) {
+    const tint = row.kind === 'over' ? c.red : row.kind === 'not-measured' ? c.yellow : c.dim;
+    console.log(
+      `  ${row.owner.padEnd(w.owner)}  ${row.spend.padStart(w.spend)}  ` +
+        `${row.budget.padStart(w.budget)}  ${row.calls.padStart(w.calls)}  ${tint(row.verdict)}`,
+    );
+  }
+
+  // The 1.37 refusal, applied to people, said in full for each owner it hits.
+  for (const line of result.owners) {
+    if (line.verdict === 'not-measured') {
+      console.log();
+      console.log(`  ${c.yellow('!')} ${wrap(t.owners.notMeasured(line.owner), 74, '    ')}`);
+    }
+  }
+
+  console.log();
+  if (result.unallocated.usd > 0) {
+    console.log(
+      `  ${c.yellow('!')} ${wrap(
+        t.owners.unallocated(
+          formatUsd(result.unallocated.usd),
+          report.total.totalUsd > 0 ? pct(result.unallocated.usd / report.total.totalUsd) : '—',
+          result.unallocated.labels.slice(0, 6).join(', '),
+        ),
+        74,
+        '    ',
+      )}`,
+    );
+    console.log(`    ${c.dim(wrap(t.owners.neverSpread(), 72, '    '))}`);
+  } else {
+    console.log(`  ${c.dim(t.owners.nothingUnallocated())}`);
+  }
+
+  /**
+   * The shared rules, printed with the report.
+   *
+   * The whole design: the argument then happens about the rule — "why is
+   * search 60/40?" — rather than about the number, which is an argument nobody
+   * can win because nobody can see where the number came from.
+   */
+  if (result.sharedApplied.length > 0) {
+    console.log();
+    console.log(`  ${c.bold(t.owners.sharedHeading())}`);
+    for (const { label, split } of result.sharedApplied) {
+      const rule = Object.entries(split)
+        .map(([owner, share]) => `${owner} ${pct(share)}`)
+        .join(', ');
+      console.log(`    ${c.dim(t.owners.sharedRule(label, rule))}`);
+    }
+  }
+  console.log();
+}
+
 function commandModels(t: CliMessages, pricing: PricingCatalogue): void {
   const n = (value: number): string => value.toLocaleString(t.numberLocale);
   const col = t.models.columns;
@@ -8809,6 +9076,12 @@ async function main(): Promise<void> {
     case 'models':
       commandModels(t, pricing);
       break;
+    case 'owners':
+      await commandOwners(args, config, pricing, t);
+      break;
+    case 'semantic':
+      await commandSemantic(args, config, pricing, t);
+      break;
     case 'quality':
       await commandQuality(args, config, pricing, t);
       break;