@trazum/cli 1.48.0 → 1.50.0

package/package.json

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

package/src/i18n/en.ts

@@ -54,6 +54,7 @@ ${bold('USAGE')}
   trazum blame <file> [options]
   trazum prune <file> --cases <file> --yes
   trazum where [file]
+  trazum conform <file|-> [--contract <name>]
   trazum models
   trazum rules
 
@@ -73,6 +74,20 @@ ${bold('OPTIONS FOR init')}
   measured figure and leaves the limit to you — a generated config full of
   guessed numbers is one nobody trusts.
 
+${bold('OPTIONS FOR conform')}
+  --contract <name>           Check against a named contract instead of
+                              detecting one: usage-log, profile, plan,
+                              verification, history, connected, cost-answer.
+  --json                      The report as data.
+
+  Answers two questions and keeps them apart. Does this document conform —
+  required fields, present and the right type, exits 1 when not. And what can a
+  valid document of this shape not answer, with the field that would unlock
+  each.
+
+  The second never gates. Choosing not to log sessions is a decision, not a
+  defect. See docs/format.md.
+
 ${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
@@ -904,6 +919,23 @@ ${bold('EXAMPLES')}
       `${path} exists and could not be parsed, so nothing was written over it. Fix or move it first.`,
   },
 
+  conform: {
+    noTarget: () =>
+      'Pass a file to check — a usage log, or any document Trazum emits. Use "-" to read from stdin.',
+    badContract: (given, known) => `"${given}" is not a contract. Known contracts: ${known}.`,
+    unrecognised: (path) => `${path} does not match any contract Trazum knows.`,
+    heading: (path, contract) => `${path} reads as a ${contract} document`,
+    headingLog: (path, contract, records) =>
+      `${path} reads as a ${contract}: ${records} ${records === 1 ? 'record' : 'records'}`,
+    conforms: () => 'It conforms. Every required field is present and the right type.',
+    problem: (at, kind, detail) => `${at}: ${detail} (${kind})`,
+    moreProblems: (count) => `…and ${count} more. Fix these first; they are often the same mistake.`,
+    unavailableHeading: () => 'What this cannot answer, and what would unlock it',
+    unavailable: (finding, because, unlockedBy) => `${finding} — ${because}. Add ${unlockedBy}.`,
+    unavailableNeverGates: () =>
+      'None of those failed anything. Choosing not to record a field is a decision, not a defect, and a gate that failed on it would be this tool telling you what to log.',
+  },
+
   where: {
     hostHeading: () => 'Running inside',
     subscription: (host) =>
@@ -1666,7 +1698,9 @@ ${bold('EXAMPLES')}
     nothingMeasured: (dir) =>
       `Nothing is measured yet (the store at ${dir} is empty), so the budget half of every answer will say so. The cost half still answers from the catalogue: offline is a mode, not a failure.`,
     noBudget: () =>
-      'No spend.maxUsd is configured, so "is there budget left" has no subject and every answer says so rather than guessing one.',
+      'No spend.monthlyUsd is configured, so "is there budget left" has no subject and every answer says so rather than guessing one. spend.maxUsd is deliberately not read here: it gates whatever period a log covers, and reading it as a monthly limit is how two surfaces of this tool come to disagree.',
+    partialCoverage: (measuredDays, elapsedDays, period) =>
+      `Only ${measuredDays} of the ${elapsedDays} elapsed days of ${period} carry any measurement, so the consumed figure is a floor on the period rather than the period. Pull the missing days with trazum connect before treating what is left as headroom.`,
     badPort: (value) => `"${value}" is not a port. Give a whole number from 0 to 65535, or use --socket.`,
   },
 
@@ -1742,6 +1776,27 @@ ${bold('EXAMPLES')}
       span === null
         ? `Nothing was older than ${days} days. ${kept} measurements kept, and the append log compacted.`
         : `Deleted ${count} measurements older than ${days} days, covering ${span} and ${usd} of measured spend. ${kept} kept, and the append log compacted to what the store already resolved to.`,
+    budgetHeading: (period) => `Budget for ${period}`,
+    budgetStanding: (consumed, limit, share, measuredDays, periodDays) =>
+      `${consumed} of ${limit} (${share}), measured over ${measuredDays} of the month's ${periodDays} days.`,
+    budgetShape: (shape, elapsedPct, coverage) =>
+      shape === 'ahead'
+        ? `The money is going faster than the calendar: ${elapsedPct}% of the month has elapsed.`
+        : shape === 'behind'
+          ? `The money is going slower than the calendar: ${elapsedPct}% of the month has elapsed.`
+          : shape === 'on-pace'
+            ? `Tracking the calendar: ${elapsedPct}% of the month has elapsed.`
+            : coverage === 'partial'
+              ? 'Whether that is fast or slow for the month cannot be told from a floor: the unmeasured days spent something, and only an overrun would be unarguable.'
+              : 'There is nothing to compare the spend against yet.',
+    budgetNeverForecast: () =>
+      'That is a shape, not a forecast. Where this goes next depends on what you do next, and no arithmetic here knows that.',
+    budgetNothingMeasured: (elapsedDays) =>
+      `Nothing has been measured this month, across ${elapsedDays} elapsed ${elapsedDays === 1 ? 'day' : 'days'}. That is not a budget under control — it is a budget nobody is watching. Run trazum connect to pull what the provider has.`,
+    budgetPartial: (measuredDays, elapsedDays, days) =>
+      `Only ${measuredDays} of ${elapsedDays} elapsed days carry any measurement, so the figure below is a floor on the month rather than the month. Missing: ${days}.`,
+    budgetScopesUnmeasured: (count) =>
+      `${count} budgeted ${count === 1 ? 'scope' : 'scopes'} (per label or per service) cannot be answered from the store: a store record carries a provider and a model, not a workload label. Gate those with trazum profile against a per-call log.`,
   },
 
   connect: {

package/src/i18n/es.ts

@@ -41,6 +41,7 @@ ${bold('USO')}
   trazum blame <fichero> [opciones]
   trazum prune <fichero> --cases <fichero> --yes
   trazum where [fichero]
+  trazum conform <fichero|-> [--contract <nombre>]
   trazum models
   trazum rules
 
@@ -60,6 +61,20 @@ ${bold('OPCIONES DE init')}
   cifra medida y te deja el límite a ti — una configuración generada llena de
   números adivinados no se la cree nadie.
 
+${bold('OPCIONES DE conform')}
+  --contract <nombre>         Comprueba contra un contrato concreto en vez de
+                              detectarlo: usage-log, profile, plan,
+                              verification, history, connected, cost-answer.
+  --json                      El informe como datos.
+
+  Responde dos preguntas y las mantiene separadas. ¿Cumple este documento —
+  campos obligatorios, presentes y del tipo correcto; sale con 1 si no. Y qué no
+  puede responder un documento válido de esta forma, con el campo que lo
+  desbloquearía.
+
+  La segunda nunca hace fallar nada. Decidir no registrar sesiones es una
+  decisión, no un defecto. Ver docs/format.md.
+
 ${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
@@ -937,6 +952,23 @@ ${bold('EJEMPLOS')}
       `${path} existe y no se pudo interpretar, así que no se escribió nada encima. Arréglalo o muévelo primero.`,
   },
 
+  conform: {
+    noTarget: () =>
+      'Pasa un archivo para comprobar — un registro de consumo, o cualquier documento que emita Trazum. Usa "-" para leer de la entrada estándar.',
+    badContract: (given, known) => `"${given}" no es un contrato. Contratos conocidos: ${known}.`,
+    unrecognised: (path) => `${path} no encaja con ningún contrato que Trazum conozca.`,
+    heading: (path, contract) => `${path} se lee como un documento ${contract}`,
+    headingLog: (path, contract, records) =>
+      `${path} se lee como ${contract}: ${records} ${records === 1 ? 'registro' : 'registros'}`,
+    conforms: () => 'Cumple. Todos los campos obligatorios están y son del tipo correcto.',
+    problem: (at, kind, detail) => `${at}: ${detail} (${kind})`,
+    moreProblems: (count) => `…y ${count} más. Arregla estos primero; suelen ser el mismo error.`,
+    unavailableHeading: () => 'Lo que esto no puede responder, y qué lo desbloquearía',
+    unavailable: (finding, because, unlockedBy) => `${finding} — ${because}. Añade ${unlockedBy}.`,
+    unavailableNeverGates: () =>
+      'Nada de eso ha hecho fallar nada. Decidir no registrar un campo es una decisión, no un defecto, y una puerta que fallara por ello sería esta herramienta diciéndote qué registrar.',
+  },
+
   where: {
     hostHeading: () => 'Ejecutándose dentro de',
     subscription: (host) =>
@@ -1696,7 +1728,9 @@ ${bold('EJEMPLOS')}
     nothingMeasured: (dir) =>
       `Todavía no hay nada medido (el almacén de ${dir} está vacío), así que la mitad de presupuesto de cada respuesta lo dirá. La mitad del coste sigue respondiendo desde el catálogo: sin conexión es un modo, no un fallo.`,
     noBudget: () =>
-      'No hay spend.maxUsd configurado, así que "queda presupuesto" no tiene sujeto y cada respuesta lo dice en vez de inventarse uno.',
+      'No hay spend.monthlyUsd configurado, así que "queda presupuesto" no tiene sujeto y cada respuesta lo dice en vez de inventarse uno. spend.maxUsd no se lee aquí a propósito: ese controla el periodo que cubra un registro, y leerlo como límite mensual es justo como dos superficies de esta herramienta acaban en desacuerdo.',
+    partialCoverage: (measuredDays, elapsedDays, period) =>
+      `Solo ${measuredDays} de los ${elapsedDays} días transcurridos de ${period} tienen alguna medición, así que la cifra consumida es un suelo del periodo y no el periodo. Descarga los días que faltan con trazum connect antes de tratar lo que queda como margen.`,
     badPort: (value) => `"${value}" no es un puerto. Da un número entero de 0 a 65535, o usa --socket.`,
   },
 
@@ -1772,6 +1806,27 @@ ${bold('EJEMPLOS')}
       span === null
         ? `Nada era más antiguo que ${days} días. ${kept} mediciones conservadas, y el log compactado.`
         : `Borradas ${count} mediciones de más de ${days} días, que cubren ${span} y ${usd} de gasto medido. ${kept} conservadas, y el log compactado a lo que el almacén ya resolvía.`,
+    budgetHeading: (period) => `Presupuesto de ${period}`,
+    budgetStanding: (consumed, limit, share, measuredDays, periodDays) =>
+      `${consumed} de ${limit} (${share}), medido sobre ${measuredDays} de los ${periodDays} días del mes.`,
+    budgetShape: (shape, elapsedPct, coverage) =>
+      shape === 'ahead'
+        ? `El dinero va más rápido que el calendario: ha transcurrido el ${elapsedPct}% del mes.`
+        : shape === 'behind'
+          ? `El dinero va más lento que el calendario: ha transcurrido el ${elapsedPct}% del mes.`
+          : shape === 'on-pace'
+            ? `Al ritmo del calendario: ha transcurrido el ${elapsedPct}% del mes.`
+            : coverage === 'partial'
+              ? 'Si eso es rápido o lento para el mes no se puede saber desde un suelo: los días sin medir gastaron algo, y solo un exceso sería incontestable.'
+              : 'Todavía no hay nada con lo que comparar el gasto.',
+    budgetNeverForecast: () =>
+      'Eso es una forma, no un pronóstico. A dónde va esto después depende de lo que hagas después, y ninguna aritmética de aquí lo sabe.',
+    budgetNothingMeasured: (elapsedDays) =>
+      `No se ha medido nada este mes, en ${elapsedDays} ${elapsedDays === 1 ? 'día transcurrido' : 'días transcurridos'}. Eso no es un presupuesto bajo control — es un presupuesto que nadie está mirando. Ejecuta trazum connect para descargar lo que tenga el proveedor.`,
+    budgetPartial: (measuredDays, elapsedDays, days) =>
+      `Solo ${measuredDays} de ${elapsedDays} días transcurridos tienen alguna medición, así que la cifra de abajo es un suelo del mes y no el mes. Faltan: ${days}.`,
+    budgetScopesUnmeasured: (count) =>
+      `${count} ${count === 1 ? 'ámbito presupuestado' : 'ámbitos presupuestados'} (por etiqueta o por servicio) no se pueden responder desde el almacén: un registro del almacén lleva un proveedor y un modelo, no una etiqueta de flujo. Contrólalos con trazum profile contra un registro por llamada.`,
   },
 
   connect: {

package/src/i18n/types.ts

@@ -246,6 +246,26 @@ export interface CliMessages {
     existingUnparseable(path: string): string;
   };
 
+  /**
+   * The conformance check.
+   *
+   * Two halves, and the copy keeps them apart everywhere: problems gate, gaps
+   * do not. Choosing not to log sessions is a decision, not a defect.
+   */
+  conform: {
+    noTarget(): string;
+    badContract(given: string, known: string): string;
+    unrecognised(path: string): string;
+    heading(path: string, contract: string): string;
+    headingLog(path: string, contract: string, records: number): string;
+    conforms(): string;
+    problem(at: string, kind: string, detail: string): string;
+    moreProblems(count: number): string;
+    unavailableHeading(): string;
+    unavailable(finding: string, because: string, unlockedBy: string): string;
+    unavailableNeverGates(): string;
+  };
+
   where: {
     hostHeading(): string;
     subscription(host: string): string;
@@ -1151,6 +1171,12 @@ export interface CliMessages {
     measuredFrom(usd: string): string;
     nothingMeasured(dir: string): string;
     noBudget(): string;
+    /**
+     * The period is only partly measured — said out loud, because a position
+     * standing on three days out of thirty must not read as a comfortable
+     * ninety per cent remaining.
+     */
+    partialCoverage(measuredDays: number, elapsedDays: number, period: string): string;
     badPort(value: string): string;
   };
 
@@ -1205,6 +1231,15 @@ export interface CliMessages {
     pruneNeedsPolicy(): string;
     pruneDryRun(count: string, days: string, span: string | null, usd: string): string;
     pruned(count: string, days: string, span: string | null, usd: string, kept: string): string;
+    /** The live budget — the one number `serve` and the MCP guard also read. */
+    budgetHeading(period: string): string;
+    budgetStanding(consumed: string, limit: string, share: string, measuredDays: string, periodDays: string): string;
+    /** The shape of the burn, named. Never a date — see `budgetNeverForecast`. */
+    budgetShape(shape: string, elapsedPct: number, coverage: string): string;
+    budgetNeverForecast(): string;
+    budgetNothingMeasured(elapsedDays: number): string;
+    budgetPartial(measuredDays: number, elapsedDays: number, days: string): string;
+    budgetScopesUnmeasured(count: number): string;
   };
 
   /**

package/src/index.ts

@@ -35,6 +35,8 @@ import {
   computeSavings,
   countTokensAnthropic,
   DEFAULT_USAGE,
+  budgetPositions,
+  conform,
   detectFromSource,
   matchLocale,
   parsePlanDocument,
@@ -127,6 +129,8 @@ import type {
   UsageProfile,
 } from '@trazum/core';
 import type {
+  BudgetReport,
+  ContractName,
   UsageProfileReport,
   WaiverUse,
   InitDecline,
@@ -226,6 +230,7 @@ interface Args {
 
 const VALUE_FLAGS = new Set([
   'against',
+  'contract',
   'from-log',
   'min-usd',
   'payload',
@@ -548,6 +553,7 @@ const COMMAND_FLAGS: Record<string, string[]> = {
   models: [],
   rank: ['level', 'model', 'calls', 'output-tokens', 'batch', 'disable', 'prompt', 'markdown-out'],
   init: ['dry-run', 'yes', 'json', 'pricing', 'pricing-live'],
+  conform: ['contract', 'json'],
   where: [],
   rules: [],
   blame: ['limit', 'model', 'calls', 'output-tokens', 'batch', 'prompt', 'markdown-out'],
@@ -1470,6 +1476,20 @@ const INIT_LOG_CANDIDATES = [
  * nobody has vouched for.
  */
 
+/** Problems listed before the rest are counted. A wall of them helps nobody. */
+const MAX_CONFORM_PROBLEMS = 20;
+
+/** The contracts `--contract` accepts, so a typo is refused with the list. */
+const CONTRACT_NAMES = [
+  'usage-log',
+  'profile',
+  'plan',
+  'verification',
+  'history',
+  'connected',
+  'cost-answer',
+];
+
 /** How many source files, and how large each may be. Both reported when they bite. */
 const INIT_MAX_SOURCE_FILES = 400;
 const INIT_MAX_SOURCE_BYTES = 256 * 1024;
@@ -1848,6 +1868,87 @@ async function commandInit(
   console.log();
 }
 
+/**
+ * `trazum conform <file>` — does this document conform, and what will it not
+ * be able to answer?
+ *
+ * The command that makes the five contracts something to build against rather
+ * than something to read about. An emitter — a logging wrapper somebody wrote
+ * this afternoon, a connector for a provider this repository has never heard
+ * of, a dashboard writing profile documents of its own — points this at what
+ * it produced and finds out before shipping.
+ *
+ * **The second half is the useful half.** "Valid" is a yes or no. "Here is
+ * what a valid document of this shape cannot tell you, and the field that
+ * would unlock each" is the answer somebody acts on: a usage log with no
+ * `session` is perfectly conformant and simply has no conversation growth in
+ * it, and an emitter that only ever hears "valid" ships it and never finds out
+ * why half the report is empty.
+ *
+ * Exits 1 on a problem, so it gates. It never exits 1 on an *unavailable
+ * finding*: choosing not to log sessions is a decision, not a defect, and a
+ * gate that failed on it would be this tool telling somebody what to record.
+ */
+async function commandConform(args: Args, t: CliMessages): Promise<void> {
+  const target = args.positional[0];
+  if (target === undefined) throw new Error(t.conform.noTarget());
+
+  const named = stringFlag(args, 'contract');
+  if (named !== undefined && !CONTRACT_NAMES.includes(named)) {
+    throw new Error(t.conform.badContract(named, CONTRACT_NAMES.join(', ')));
+  }
+
+  const text = target === '-' ? await readInput('-', t) : await readUsageLog(target, t);
+  const report = conform(text, named === undefined ? {} : { contract: named as ContractName });
+
+  if (boolFlag(args, 'json')) {
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.conforms) process.exitCode = 1;
+    return;
+  }
+
+  console.log();
+  if (report.contract === null) {
+    console.log(c.red(t.conform.unrecognised(target)));
+    console.log(`  ${c.dim(wrap(report.because ?? '', 74, '    '))}`);
+    console.log();
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(
+    c.bold(
+      report.records === null
+        ? t.conform.heading(target, report.contract)
+        : t.conform.headingLog(target, report.contract, report.records),
+    ),
+  );
+
+  if (report.problems.length === 0) {
+    console.log(`  ${c.green(t.conform.conforms())}`);
+  } else {
+    for (const problem of report.problems.slice(0, MAX_CONFORM_PROBLEMS)) {
+      console.log(`  ${c.red(t.conform.problem(problem.at, problem.kind, problem.detail))}`);
+    }
+    if (report.problems.length > MAX_CONFORM_PROBLEMS) {
+      console.log(`  ${c.dim(t.conform.moreProblems(report.problems.length - MAX_CONFORM_PROBLEMS))}`);
+    }
+    process.exitCode = 1;
+  }
+
+  if (report.unavailable.length > 0) {
+    console.log();
+    console.log(c.bold(t.conform.unavailableHeading()));
+    for (const gap of report.unavailable) {
+      console.log(`  ${c.dim(wrap(t.conform.unavailable(gap.finding, gap.because, gap.unlockedBy), 74, '    '))}`);
+    }
+    // Said out loud, because the exit code says it silently and somebody
+    // reading a red-and-yellow screen will assume both halves gated.
+    console.log(`  ${c.dim(wrap(t.conform.unavailableNeverGates(), 74, '    '))}`);
+  }
+  console.log();
+}
+
 function commandModels(t: CliMessages, pricing: PricingCatalogue): void {
   const n = (value: number): string => value.toLocaleString(t.numberLocale);
   const col = t.models.columns;
@@ -2747,41 +2848,39 @@ async function commandServe(
   t: CliMessages,
 ): Promise<void> {
   const root = process.cwd();
-  const limitUsd = config.spend?.maxUsd;
 
   const { resolved } = await readStore(root);
-  const measured = resolved.records.length > 0;
+
   /**
-   * The window the measurement covers, carried into every answer.
+   * The live budget, from `budgetPositions` — the same number `store` prints
+   * and the same one the MCP guard consults.
    *
-   * The position is read once at start, so a caller has to be able to see how
-   * old it is. A null window here would let a figure from last month read as
-   * current, which is the staleness this endpoint is otherwise honest about.
+   * **This used to read `spend.maxUsd` against the whole store**, which is a
+   * per-log gate compared against however much history the store happened to
+   * hold. A year of records against a monthly limit reported as a budget
+   * position, with a straight face and no way for a caller to tell. Same
+   * units, different denominators, and the two surfaces disagreed by exactly
+   * as much history as the machine had. `spend.monthlyUsd` is the key for a
+   * calendar month and nothing infers one key from the other: a repository
+   * with a per-log gate and no monthly budget has no monthly position, and
+   * this says so rather than picking a number that is the right shape.
    */
-  const window = measured
-    ? {
-        fromMs: Math.min(...resolved.records.map((record) => record.fromMs)),
-        toMs: Math.max(...resolved.records.map((record) => record.toMs)),
-      }
-    : null;
-  const report = bucketedProfile(
-    {
-      provider: 'store',
-      granularity: 'bucketed',
-      buckets: bucketsFromRecords(resolved.records),
-      window,
-      gaps: [],
-      unavailable: [],
-    },
-    { catalogue: pricing },
-  );
+  const budget = budgetPositions(resolved.records, config.spend, { catalogue: pricing });
+  const standing = budget.positions[0] ?? null;
+  const limitUsd = config.spend?.monthlyUsd;
+  const measured = standing !== null && standing.coverage !== 'none';
 
   const server = buildServer({
     catalogue: pricing,
     position: () => ({
-      consumedUsd: measured ? report.total.totalUsd : undefined,
+      // Nothing measured inside the period is `undefined`, never zero: the
+      // endpoint's `cannot-tell` exists for exactly this, and a $0 consumed
+      // would be the healthiest-looking budget a dead store can produce.
+      consumedUsd: measured ? standing.consumedUsd : undefined,
       limitUsd,
-      window: report.span,
+      // The period, not the store's span. A caller judging staleness needs to
+      // know which month the figure is about.
+      window: standing === null ? null : { fromMs: standing.period.fromMs, toMs: standing.period.toMs },
     }),
   });
 
@@ -2796,8 +2895,13 @@ async function commandServe(
   console.log(c.bold(t.serve.listening(where)));
   console.log(`  ${c.dim(wrap(t.serve.loopbackOnly(), 74, '    '))}`);
   console.log(
-    `  ${c.dim(wrap(measured ? t.serve.measuredFrom(formatUsd(report.total.totalUsd)) : t.serve.nothingMeasured(STORE_DIR), 74, '    '))}`,
+    `  ${c.dim(wrap(measured ? t.serve.measuredFrom(formatUsd(standing.consumedUsd)) : t.serve.nothingMeasured(STORE_DIR), 74, '    '))}`,
   );
+  if (standing !== null && standing.coverage === 'partial') {
+    console.log(
+      `  ${c.yellow(wrap(t.serve.partialCoverage(standing.measuredDays, standing.elapsedDays, standing.period.id), 74, '    '))}`,
+    );
+  }
   if (limitUsd === undefined) {
     console.log(`  ${c.dim(wrap(t.serve.noBudget(), 74, '    '))}`);
   }
@@ -3164,6 +3268,72 @@ async function commandStore(
   console.log(
     `  ${c.dim(wrap(keepDays === undefined ? t.store.noRetention() : t.store.retention(String(keepDays)), 74, '    '))}`,
   );
+
+  /**
+   * The live budget, printed here because this is where the measurement lives.
+   *
+   * The same call `serve` makes and the same call the MCP guard makes, so the
+   * three cannot disagree about how much of the month is gone — which is the
+   * whole point of the number existing in one place.
+   */
+  renderBudget(budgetPositions(resolved.records, config.spend, { catalogue: pricing }), t, n);
+}
+
+/**
+ * One budget standing, rendered.
+ *
+ * Coverage before the money, deliberately. A reader who sees "$61 of $100"
+ * first has already formed a view by the time they reach "over three of
+ * nineteen elapsed days", and the second sentence has to undo the first.
+ */
+function renderBudget(report: BudgetReport, t: CliMessages, n: (value: number) => string): void {
+  const standing = report.positions[0];
+  if (standing === undefined) {
+    if (report.unmeasuredScopes.length > 0) {
+      console.log();
+      console.log(
+        `  ${c.dim(wrap(t.store.budgetScopesUnmeasured(report.unmeasuredScopes.length), 74, '    '))}`,
+      );
+    }
+    return;
+  }
+
+  console.log();
+  console.log(c.bold(t.store.budgetHeading(standing.period.id)));
+
+  if (standing.coverage === 'none') {
+    // Nothing measured is never rendered as nothing spent. A dead store and a
+    // quiet month produce the same zero, and only one of them is good news.
+    console.log(`  ${c.red(wrap(t.store.budgetNothingMeasured(standing.elapsedDays), 74, '    '))}`);
+    return;
+  }
+  if (standing.coverage === 'partial') {
+    console.log(
+      `  ${c.yellow(wrap(t.store.budgetPartial(standing.measuredDays, standing.elapsedDays, standing.unmeasuredDays.join(', ')), 74, '    '))}`,
+    );
+  }
+
+  const share = standing.burn.consumedShare;
+  console.log(
+    `  ${t.store.budgetStanding(
+      formatUsd(standing.consumedUsd),
+      formatUsd(standing.limitUsd),
+      share === null ? '—' : `${Math.round(share * 100)}%`,
+      n(standing.measuredDays),
+      n(standing.period.days),
+    )}`,
+  );
+  const line = t.store.budgetShape(
+    standing.burn.shape,
+    Math.round(standing.burn.elapsedShare * 100),
+    standing.coverage,
+  );
+  console.log(`  ${standing.verdict === 'over' ? c.red(line) : c.dim(wrap(line, 74, '    '))}`);
+  // Only where there is a shape to disclaim. "That is a shape, not a forecast"
+  // under "nothing to compare against" is a disclaimer about nothing.
+  if (standing.burn.shape !== 'cannot-tell') {
+    console.log(`  ${c.dim(wrap(t.store.budgetNeverForecast(), 74, '    '))}`);
+  }
 }
 
 /**
@@ -7772,6 +7942,9 @@ async function main(): Promise<void> {
     case 'models':
       commandModels(t, pricing);
       break;
+    case 'conform':
+      await commandConform(args, t);
+      break;
     case 'init':
       await commandInit(args, config, pricing, t);
       break;