@trazum/cli 1.35.0 → 1.37.0

package/dist/index.js

@@ -2,7 +2,7 @@
 import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { join, resolve as resolvePath } from 'node:path';
 import { gunzipSync } from 'node:zlib';
-import { applyRewrites, BASELINE_FILENAME, BASELINE_VERSION, breaches, cacheableMinimum, analyzeCachePrefix, billLevers, cacheEconomics, cacheHitRate, contextPressure, comparePrompts, compareToBaseline, computeSavings, countTokensAnthropic, DEFAULT_USAGE, detectFromSource, coverageDrift, driversBetween, explainGateFailure, gateMargin, GATE_MARGIN_TIGHT, estimateTokens, evaluate, extractPrompts, findExamples, formatBaseline, formatSignedUsd, formatUsd, getMessages, getModel, hasMarker, LOCALES, MAX_BASELINE_BYTES, moneyIsComparable, mostSpecificMatch, nearestName, optimize, parseBaseline, PHRASE_LANGUAGES, plannedCalls, profilePrompt, profileToCsv, profileUsage, promptId, providerFromEnv, pruneExamples, refineWithLlm, rejectionText, reorderForCache, repriceProfile, reviewAgeDays, reviewExamples, RULES, sharedPrefixes, sharesOf, SOURCE_EXTENSIONS, suggestRewrites, toOtlpMetrics, toPromptfoo, TTL_1H_MS, UNLABELLED, withExactTokenCounts, } from '@trazum/core';
+import { applyRewrites, BASELINE_FILENAME, BASELINE_VERSION, breaches, cacheableMinimum, analyzeCachePrefix, billLevers, cacheEconomics, cacheHitRate, contextPressure, comparePrompts, compareToBaseline, computeSavings, countTokensAnthropic, DEFAULT_USAGE, detectFromSource, coverageDrift, driversBetween, explainGateFailure, assignSources, fleetRollup, labelCoverage, measuredUsage, gateMargin, GATE_MARGIN_TIGHT, estimateTokens, evaluate, extractPrompts, findExamples, formatBaseline, formatSignedUsd, formatUsd, getMessages, getModel, hasMarker, LOCALES, MAX_BASELINE_BYTES, moneyIsComparable, mostSpecificMatch, nearestName, optimize, parseBaseline, PHRASE_LANGUAGES, plannedCalls, profilePrompt, profileToCsv, profileUsage, promptId, providerFromEnv, pruneExamples, refineWithLlm, rejectionText, reorderForCache, repriceProfile, reviewAgeDays, reviewExamples, RULES, sharedPrefixes, sharesOf, SOURCE_EXTENSIONS, suggestRewrites, toOtlpMetrics, toPromptfoo, TTL_1H_MS, UNLABELLED, withExactTokenCounts, } from '@trazum/core';
 import { cacheDir, cacheStats, cachingProvider, clearCache } from './suggest-cache.js';
 import { dayOf, formatGap, median, spanDays } from './time.js';
 // Everything that reads the filesystem, on its own entry point so the web
@@ -25,6 +25,7 @@ const c = {
 };
 const VALUE_FLAGS = new Set([
     'against',
+    'from-log',
     // `route` takes a path here, and the flag is deliberately not `--prompt`:
     // everywhere else in this tool `--prompt` names a marked prompt *inside* a
     // source file, and reusing it for a path would be a trap laid for the reader.
@@ -158,6 +159,24 @@ function levelFlag(args, config, t) {
  * model id. It beats the default because reading the code is better than
  * assuming, and loses to config because being told is better than reading.
  */
+/**
+ * One usage log, gzip included, shared by every command that reads one.
+ *
+ * A `.gz` that will not decompress is an error naming the file — skipping it
+ * would be a figure quietly missing a day, the failure this repository
+ * refuses everywhere it can occur.
+ */
+async function readUsageLog(file, t) {
+    if (!file.endsWith('.gz'))
+        return readFile(file, 'utf8');
+    const compressed = await readFile(file);
+    try {
+        return gunzipSync(compressed).toString('utf8');
+    }
+    catch (error) {
+        throw new Error(t.profile.badGzip(file, error instanceof Error ? error.message : String(error)));
+    }
+}
 function usageFrom(args, config, t, detected) {
     const fromConfig = config.usage ?? {};
     const model = stringFlag(args, 'model') ?? fromConfig.model ?? detected ?? DEFAULT_USAGE.model;
@@ -255,11 +274,11 @@ const COMMAND_FLAGS = {
         'level', 'model', 'calls', 'output-tokens', 'cache-hit-rate', 'batch',
         'disable', 'llm', 'exact-tokens', 'diff', 'reorder', 'out', 'o',
         'tokens-only', 'cost', 'prompt', 'suggest', 'apply-suggestions',
-        'cache-suggestions',
+        'cache-suggestions', 'from-log', 'label', 'all-labels',
     ],
     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', 'against', 'what-if', 'markdown-out', 'csv-out', 'csv-shape', 'max-usd', 'max-growth-usd', 'max-cache-loss-usd', 'max-day-usd', 'max-session-usd', 'label', 'since', 'until', 'dry-run', 'markdown-summary'],
+    profile: ['json', 'pricing', 'pricing-live', 'against', 'what-if', 'markdown-out', 'csv-out', 'csv-shape', 'max-usd', 'max-growth-usd', 'max-cache-loss-usd', 'max-day-usd', 'max-session-usd', 'label', 'since', 'until', 'dry-run', 'markdown-summary', 'by-source'],
     route: ['prompt-file', 'cases', 'label', 'concurrency', 'json', 'yes', 'pricing', 'pricing-live'],
     eval: ['cases', 'level', 'concurrency', 'export', 'out', 'o', 'model'],
     prune: ['cases', 'concurrency', 'json', 'yes'],
@@ -420,7 +439,9 @@ function biggestLever(result, tokensOnly, t) {
 }
 function printReport(result, showDiff, t, examplesReview = null, reorder = null, tokensOnly = false, host = { id: 'terminal', displayName: 'terminal', billing: 'unknown', evidence: null }, suggestions = null, 
 /** They named a scenario, and the host is suppressing the money anyway. */
-namedScenario = false) {
+namedScenario = false, 
+/** Present when the usage came from a log rather than from typing. */
+measured = null) {
     const n = (value) => value.toLocaleString(t.numberLocale);
     const sourceNote = result.tokenSource === 'heuristic'
         ? c.dim(t.report.estimated(offFamilyName(result.usage.model)))
@@ -542,7 +563,7 @@ namedScenario = false) {
         printTokensOnly(result, host, t, n, namedScenario);
     }
     else {
-        printMoney(result, t, n);
+        printMoney(result, t, n, measured);
     }
     // On a subscription, an advisory whose entire pitch is money is not weaker
     // advice — it is not advice. "Use a cheaper model" saves nothing on a flat
@@ -606,11 +627,36 @@ namedScenario = false) {
     console.log(`  ${c.dim(wrap(tokensOnly ? t.report.beyondThisPromptTokensOnly() : t.report.beyondThisPrompt(), 74, '  '))}`);
 }
 /** The cost section, for anyone billed by the token. */
-function printMoney(result, t, n) {
+function printMoney(result, t, n, 
+/** Present when the usage came from a log rather than from typing. */
+measured = null) {
     const { savings } = result;
     console.log();
     console.log(c.bold(t.report.costWith(savings.modelDisplayName)));
-    console.log(`  ${t.report.usageLine(n(result.usage.callsPerMonth), result.usage.avgOutputTokens, result.usage.batchEligible)}`);
+    /**
+     * The usage line names its provenance. "1,000 calls/month" typed and
+     * "1,043 calls measured over 12 days, scaled" are different claims about
+     * the same multiplication, and the reader budgeting on the result must
+     * know which one they are holding. Under the week floor nothing is scaled
+     * and nothing says "month": the figures cover exactly the period measured.
+     */
+    if (measured !== null) {
+        if (measured.scaled !== null) {
+            console.log(`  ${t.report.usageLineMeasured(n(measured.calls), measured.scaled.fromDays.toFixed(1), n(result.usage.callsPerMonth), result.usage.avgOutputTokens, result.usage.batchEligible)}`);
+        }
+        else {
+            console.log(`  ${t.report.usageLineMeasuredPeriod(n(measured.calls), measured.spanDays === null ? null : measured.spanDays.toFixed(1), result.usage.avgOutputTokens, result.usage.batchEligible)}`);
+        }
+        if (measured.models.count > 1) {
+            console.log(`  ${c.dim(wrap(t.report.measuredModelShare(measured.models.chosen, `${(measured.models.chosenShareOfSpend * 100).toFixed(0)}%`, n(measured.models.count)), 74, '  '))}`);
+        }
+        if (measured.outputUnmeasured) {
+            console.log(`  ${c.dim(wrap(t.report.measuredNoOutput(), 74, '  '))}`);
+        }
+    }
+    else {
+        console.log(`  ${t.report.usageLine(n(result.usage.callsPerMonth), result.usage.avgOutputTokens, result.usage.batchEligible)}`);
+    }
     // Said, not assumed. Once prices can be overlaid locally, a figure from the
     // bundled catalogue and a figure from somebody's JSON file look identical, and
     // the reader has to be able to tell which one they are about to budget against.
@@ -621,9 +667,15 @@ function printMoney(result, t, n) {
     if (touched.length > 0) {
         console.log(`  ${c.yellow(t.report.pricingOverlaid(touched.join(', '), result.pricingSource.lastReviewed))}`);
     }
+    const periodOnly = measured !== null && measured.scaled === null;
     console.log(`  ${formatUsd(savings.perMonth.before.totalUsd)} → ` +
         `${c.green(formatUsd(savings.perMonth.after.totalUsd))}   ` +
-        c.bold(t.report.perMonthSaving(formatUsd(savings.monthlySavingsUsd), savings.monthlySavingsPct.toFixed(1))));
+        c.bold(periodOnly
+            ? t.report.perPeriodSaving(formatUsd(savings.monthlySavingsUsd), savings.monthlySavingsPct.toFixed(1))
+            : t.report.perMonthSaving(formatUsd(savings.monthlySavingsUsd), savings.monthlySavingsPct.toFixed(1))));
+    if (periodOnly) {
+        console.log(`  ${c.dim(wrap(t.report.periodNotScaled(measured.spanDays === null ? null : measured.spanDays.toFixed(1)), 74, '  '))}`);
+    }
 }
 /**
  * What the saving buys when there is no bill: room.
@@ -998,6 +1050,80 @@ async function readInput(source, t) {
     return readFile(source, 'utf8');
 }
 async function commandOptimize(args, config, pricing, t, locale) {
+    /**
+     * `--all-labels`: every mapped prompt against its own measured traffic,
+     * ranked by what the change is worth — the list a person actually wants,
+     * which is "which prompt do I edit first".
+     *
+     * Requires `--from-log`, because ranking estimated savings that were all
+     * multiplied by the same typed guess ranks the prompts by length, and calls
+     * that a priority. And it renders both coverage mismatches at the end: a
+     * prompt mapped to a label with no traffic is dead weight or a rename, and
+     * a label carrying real money with no prompt mapped is the workload nobody
+     * can optimise because nobody said where it lives.
+     */
+    if (boolFlag(args, 'all-labels')) {
+        const fromLogPath = stringFlag(args, 'from-log');
+        if (fromLogPath === undefined)
+            throw new Error(t.errors.allLabelsNeedsLog());
+        const labelsMap = config.labels ?? {};
+        if (Object.keys(labelsMap).length === 0)
+            throw new Error(t.errors.allLabelsNeedsMap());
+        const report = profileUsage(await readUsageLog(fromLogPath, t), { catalogue: pricing });
+        const coverage = labelCoverage(report, labelsMap);
+        const level = levelFlag(args, config, t);
+        const rows = [];
+        const unreadable = [];
+        for (const { label, promptPath } of coverage.joined) {
+            const m = measuredUsage(report, label, { batchEligible: config.usage?.batchEligible ?? false });
+            if (m === null)
+                continue;
+            let text;
+            try {
+                text = await readFile(promptPath, 'utf8');
+            }
+            catch {
+                unreadable.push({ label, path: promptPath });
+                continue;
+            }
+            const r = optimize(text, { level, usage: m.profile, locale, pricing });
+            rows.push({
+                label,
+                path: promptPath,
+                tokensBefore: r.tokensBefore,
+                tokensAfter: r.tokensAfter,
+                savingUsd: r.savings.monthlySavingsUsd,
+                periodOnly: m.scaled === null,
+                spentUsd: m.spentUsd,
+            });
+        }
+        rows.sort((a, b) => b.savingUsd - a.savingUsd);
+        const n = (value) => value.toLocaleString(t.numberLocale);
+        console.log(c.bold(t.report.allLabelsHeading(n(rows.length))));
+        for (const row of rows) {
+            const saving = row.periodOnly
+                ? t.report.allLabelsRowPeriod(formatUsd(row.savingUsd))
+                : t.report.allLabelsRow(formatUsd(row.savingUsd));
+            console.log(`  ${row.savingUsd > 0 ? c.green('→') : c.dim('·')} ${c.bold(row.label)}  ${saving}  ${c.dim(`${row.path} · ${n(row.tokensBefore)} → ${n(row.tokensAfter)} tokens · ${formatUsd(row.spentUsd)} measured`)}`);
+        }
+        if (rows.length > 0) {
+            console.log(`  ${c.dim(wrap(t.report.allLabelsFooter(), 74, '  '))}`);
+        }
+        /**
+         * The mismatches, both directions, never silently. These are the two
+         * failures neither side can see alone.
+         */
+        for (const gap of coverage.trafficWithoutPrompt.slice(0, 5)) {
+            console.log(`  ${c.yellow('!')} ${wrap(t.report.allLabelsUnmapped(gap.label, formatUsd(gap.spentUsd)), 74, '    ')}`);
+        }
+        for (const dead of coverage.mappedWithoutTraffic) {
+            console.log(`  ${c.dim(wrap(t.report.allLabelsDead(dead.label, dead.promptPath), 74, '    '))}`);
+        }
+        for (const miss of unreadable) {
+            console.log(`  ${c.yellow('!')} ${wrap(t.report.allLabelsUnreadable(miss.label, miss.path), 74, '    ')}`);
+        }
+        return;
+    }
     const target = args.positional[0];
     const raw = await readInput(target, t);
     const level = levelFlag(args, config, t);
@@ -1016,7 +1142,59 @@ async function commandOptimize(args, config, pricing, t, locale) {
     // Detection sits between config and defaults, as everywhere: a flag beats
     // config, config beats what the code says, and what the code says beats a
     // built-in default that has no idea which provider you use.
-    const usage = usageFrom(args, config, t, source?.model);
+    let usage = usageFrom(args, config, t, source?.model);
+    /**
+     * `--from-log`: the multiplication stops guessing.
+     *
+     * The saving printed below is `token delta × usage`, and until now every
+     * part of `usage` was typed by a human. A usage log knows the real call
+     * count, the real output size, the real cache share and the model the
+     * calls actually went to — so `--from-log` measures them, and the typed
+     * flags are refused beside it rather than merged: measuring and typing the
+     * same figure is a contradiction, not a preference order.
+     */
+    const fromLog = stringFlag(args, 'from-log');
+    let measured = null;
+    if (fromLog !== undefined) {
+        for (const flag of ['calls', 'output-tokens', 'cache-hit-rate', 'model']) {
+            if (args.flags.get(flag) !== undefined) {
+                throw new Error(t.errors.fromLogConflict(flag));
+            }
+        }
+        const report = profileUsage(await readUsageLog(fromLog, t), { catalogue: pricing });
+        /**
+         * Which label this prompt is. `--label` says it outright; otherwise the
+         * config's `labels` map is read in reverse — it maps labels to prompt
+         * files, and the file on the command line is looked up among its values.
+         * Ambiguity (two labels mapped to one file) is an error naming both,
+         * never a silent first match.
+         */
+        let label = stringFlag(args, 'label');
+        if (label === undefined && target !== undefined && config.labels !== undefined) {
+            const hits = Object.entries(config.labels)
+                .filter(([, path]) => resolvePath(path) === resolvePath(target))
+                .map(([name]) => name);
+            if (hits.length > 1)
+                throw new Error(t.errors.fromLogAmbiguousLabel(target, hits.join(', ')));
+            label = hits[0];
+        }
+        if (label === undefined) {
+            const available = report.byLabel
+                .map((row) => (row.label === UNLABELLED ? t.profile.unlabelled() : row.label))
+                .join(', ');
+            throw new Error(t.errors.fromLogNeedsLabel(available || '—'));
+        }
+        measured = measuredUsage(report, label, {
+            batchEligible: boolFlag(args, 'batch', config.usage?.batchEligible ?? false),
+        });
+        if (measured === null) {
+            const available = report.byLabel
+                .map((row) => (row.label === UNLABELLED ? t.profile.unlabelled() : row.label))
+                .join(', ');
+            throw new Error(t.errors.fromLogLabelEmpty(label, available || '—'));
+        }
+        usage = measured.profile;
+    }
     const disableRules = disabledRules(args, config) ?? [];
     for (const id of disableRules) {
         if (!RULES.some((r) => r.id === id)) {
@@ -1176,7 +1354,15 @@ async function commandOptimize(args, config, pricing, t, locale) {
     // Cursor wants the dollars, and they should not have to leave the editor to
     // see them.
     const host = detectHost();
-    const tokensOnly = boolFlag(args, 'cost')
+    /**
+     * `--from-log` implies `--cost`, and the reasoning is different from the
+     * `--calls` case documented below: `--calls` is a typed scenario parameter,
+     * but a usage log with billed token counts is *evidence* — proof this
+     * prompt's traffic goes to a metered API, whatever the terminal running
+     * the command bills like. Withholding the money there would suppress
+     * exactly the figures the person measured in order to see.
+     */
+    const tokensOnly = boolFlag(args, 'cost') || measured !== null
         ? false
         : boolFlag(args, 'tokens-only') || host.billing === 'subscription';
     /**
@@ -1195,7 +1381,7 @@ async function commandOptimize(args, config, pricing, t, locale) {
     const namedScenario = args.flags.has('calls') || args.flags.has('output-tokens');
     printReport(result, boolFlag(args, 'diff'), t, examplesReview, reorder, tokensOnly, host, suggestions
         ? { result: suggestions, applied: boolFlag(args, 'apply-suggestions'), locale }
-        : null, namedScenario);
+        : null, namedScenario, measured);
     if (outPath) {
         console.log(c.dim(t.report.wroteTo(outPath)));
         console.log();
@@ -1489,10 +1675,17 @@ async function commandProfile(args, config, pricing, t) {
     const target = await stat(path).catch(() => null);
     let logFiles = [path];
     if (target?.isDirectory()) {
-        const entries = await readdir(path, { withFileTypes: true });
+        /**
+         * Recursive under `--by-source`, flat otherwise. The fleet's whole point
+         * is one directory per service, so the walk must descend; the flat mode
+         * keeps its long-standing behaviour because a directory of rotated logs
+         * with an unrelated subfolder should not quietly absorb it.
+         */
+        const bySourceMode = boolFlag(args, 'by-source');
+        const entries = await readdir(path, { withFileTypes: true, recursive: bySourceMode });
         logFiles = entries
             .filter((entry) => entry.isFile() && READABLE.some((ext) => entry.name.endsWith(ext)))
-            .map((entry) => join(path, entry.name))
+            .map((entry) => join(entry.parentPath ?? path, entry.name))
             .sort((a, b) => a.localeCompare(b));
         if (logFiles.length === 0) {
             throw new Error(t.profile.noLogsInDirectory(path, READABLE.join(', ')));
@@ -1510,18 +1703,7 @@ async function commandProfile(args, config, pricing, t) {
      * alternative — skipping it — is a total quietly missing a day, which is
      * the failure this repository refuses in every other place it can occur.
      */
-    const readLog = async (file) => {
-        if (!file.endsWith('.gz'))
-            return readFile(file, 'utf8');
-        const compressed = await readFile(file);
-        try {
-            return gunzipSync(compressed).toString('utf8');
-        }
-        catch (error) {
-            throw new Error(t.profile.badGzip(file, error instanceof Error ? error.message : String(error)));
-        }
-    };
-    const logTexts = await Promise.all(logFiles.map((file) => readLog(file)));
+    const logTexts = await Promise.all(logFiles.map((file) => readUsageLog(file, t)));
     // A file that does not end in a newline would otherwise glue its last record
     // to the next file's first one, and both would be reported as unreadable.
     const raw = logTexts.map((text) => (text.endsWith('\n') ? text : `${text}\n`)).join('');
@@ -1626,6 +1808,109 @@ async function commandProfile(args, config, pricing, t) {
     }
     const n = (value) => value.toLocaleString(t.numberLocale);
     const pct = (share) => `${(share * 100).toFixed(1)}%`;
+    /**
+     * `--by-source`: one report per service, plus the rollup — the fleet.
+     *
+     * A merged bill is right for one service and wrong for twelve: it hides
+     * which service the money comes from, per-service budgets cannot exist,
+     * and the findings a comparison between services could make are invisible.
+     * Files are assigned to sources by the most specific matching glob from the
+     * config's `sources` block; a file matching no source is named loudly,
+     * because a log that silently joined no report is spend missing from every
+     * bill.
+     */
+    if (boolFlag(args, 'by-source')) {
+        const sourceDefs = config.sources;
+        if (sourceDefs === undefined || Object.keys(sourceDefs).length === 0) {
+            throw new Error(t.profile.bySourceNeedsConfig());
+        }
+        const { bySource, unmatched } = assignSources(logFiles, sourceDefs);
+        if (bySource.size === 0) {
+            throw new Error(t.profile.bySourceNothingMatched(Object.keys(sourceDefs).join(', ')));
+        }
+        const textByFile = new Map(logFiles.map((file, i) => [file, logTexts[i]]));
+        const fleetSources = [];
+        const cacheDeltas = new Map();
+        for (const [name, files] of [...bySource.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+            const text = files
+                .map((file) => textByFile.get(file))
+                .map((chunk) => (chunk.endsWith('\n') ? chunk : `${chunk}\n`))
+                .join('');
+            const sourceReport = profileUsage(text, { catalogue: pricing, label: onlyLabel, sinceMs, untilMs });
+            fleetSources.push({ name, report: sourceReport });
+            cacheDeltas.set(name, cacheEconomics(sourceReport.total).deltaUsd);
+        }
+        const aggregate = profileUsage(raw, { catalogue: pricing, label: onlyLabel, sinceMs, untilMs });
+        const rollup = fleetRollup(fleetSources, {
+            cacheDeltas,
+            aggregateCacheDelta: cacheEconomics(aggregate.total).deltaUsd,
+        });
+        if (boolFlag(args, 'json')) {
+            console.log(JSON.stringify({
+                schemaVersion: 1,
+                bySource: fleetSources.map((source) => ({ name: source.name, report: source.report })),
+                rollup: {
+                    totalUsd: rollup.totalUsd,
+                    calls: rollup.calls,
+                    sources: rollup.sources,
+                    worst: rollup.worst,
+                    mismatchedSpans: rollup.mismatchedSpans,
+                    splitBrains: rollup.splitBrains,
+                    cacheUnderwater: rollup.cacheUnderwater,
+                    unmatchedFiles: unmatched,
+                },
+            }, (key, value) => (value instanceof Map ? undefined : value), 2));
+        }
+        else {
+            console.log(c.bold(t.profile.fleetHeading(n(rollup.sources.length), formatUsd(rollup.totalUsd), t.profile.calls(rollup.calls))));
+            for (const row of rollup.sources) {
+                const span = row.spanDays === null ? t.profile.fleetNoClock() : t.profile.fleetSpan(row.spanDays.toFixed(1));
+                console.log(`  ${t.profile.fleetRow(row.name, formatUsd(row.usd), pct(row.share), t.profile.calls(row.calls), span)}`);
+            }
+            if (rollup.worst !== null && rollup.sources.length > 1) {
+                console.log();
+                console.log(`  ${c.yellow('!')} ${c.bold(wrap(t.profile.fleetWorst(rollup.worst.name, formatUsd(rollup.worst.usd), pct(rollup.worst.share)), 74, '    '))}`);
+            }
+            if (rollup.mismatchedSpans) {
+                console.log(`  ${c.dim(wrap(t.profile.fleetMismatchedSpans(), 74, '  '))}`);
+            }
+            for (const split of rollup.splitBrains.slice(0, 3)) {
+                console.log();
+                console.log(`  ${c.yellow('!')} ${wrap(t.profile.fleetSplitBrain(split.label, split.sources.map((v) => `${v.name} → ${v.model} (${formatUsd(v.usd)})`).join(', ')), 74, '    ')}`);
+            }
+            for (const under of rollup.cacheUnderwater.slice(0, 3)) {
+                console.log(`  ${c.yellow('!')} ${wrap(t.profile.fleetCacheUnderwater(under.name, formatUsd(under.deltaUsd)), 74, '    ')}`);
+            }
+            for (const file of unmatched) {
+                console.log(`  ${c.yellow('!')} ${wrap(t.profile.fleetUnmatched(file), 74, '    ')}`);
+            }
+            console.log();
+            console.log(`  ${c.dim(wrap(t.profile.fleetFooter(), 74, '  '))}`);
+        }
+        /**
+         * The per-source gates. Each budget judges its own service and the run
+         * fails naming the service — a total that hides which source crossed its
+         * line is the rendering this mode exists to end. Waivable per source
+         * through `bySource:<name>`, under the same expiry discipline.
+         */
+        const bySourceBudgets = config.spend?.bySource ?? {};
+        for (const [name, limit] of Object.entries(bySourceBudgets)) {
+            const found = fleetSources.find((source) => source.name === name);
+            if (found === undefined) {
+                console.error(c.dim(t.profile.fleetBudgetMissing(name)));
+                continue;
+            }
+            const usd = found.report.total.totalUsd;
+            if (usd > limit) {
+                console.error(c.red(t.profile.fleetBudgetFailed(name, formatUsd(usd), formatUsd(limit))));
+                process.exitCode = 1;
+            }
+            else {
+                console.error(c.dim(t.profile.fleetBudgetOk(name, formatUsd(usd), formatUsd(limit))));
+            }
+        }
+        return;
+    }
     /**
      * `--dry-run`: what this log could and could not answer, and no bill.
      *
@@ -1686,7 +1971,7 @@ async function commandProfile(args, config, pricing, t) {
         // The same reader as the log itself, so `--against last-month.jsonl.gz`
         // works: a comparison that could only read one of the two formats would
         // be a flag that fails on exactly the rotated file it exists to read.
-        ? profileUsage(await readLog(againstPath), {
+        ? profileUsage(await readUsageLog(againstPath, t), {
             catalogue: pricing,
             label: onlyLabel,
             // The same window on both sides, for the same reason as the label: