@phnx-labs/agents-cli 1.22.25 → 1.22.27

package/dist/commands/insights.js

@@ -1,23 +1,26 @@
 /**
- * Insights command — how you actually work, split by the account that did the work.
+ * Insights command — one observe verb for "how work looks".
  *
- * The behavioural sibling of the existing rollups, and deliberately not a duplicate of
- * any of them:
+ * Two data paths under one name (do not re-split into peer top-level commands):
  *
- *   agents cost      what you spent            ($ and duration)
- *   agents output    what shipped              (burn vs PRs and commits)
- *   agents usage     live quota headroom       (rate-limit windows, right now)
- *   agents trends    aggregate distributions   (harness mix, tools-per-session, token ratios)
- *   agents sessions  browse individual work    (search, resume, render)
- *   agents insights  HOW you work              (tools, friction, rhythm, per account)
+ *   agents insights              HOW you work (transcript content: tools, friction,
+ *                                rhythm, edits) — split by Claude account by default
+ *   agents insights mix          COUNTERS (sessions index + usage.db recipes:
+ *                                harness/model mix, token ratios, secrets, browser)
+ *   agents insights <recipe>     One baked mix recipe (harness-mix, tools-per-session, …)
+ *   agents insights query        Raw usage.db rows
  *
- * The closest neighbour is `agents trends`, and the boundary is the data path: trends
- * reads counters — `tool_scan_ledger` call counts and the analytics warehouse — to
- * produce distributions ("how many tool calls per session, by harness"). This reads
- * transcript CONTENT through `parseSession` to produce behaviour ("which tools, which
- * languages, where it went wrong, when you were working"), and splits all of it by
- * account, a dimension trends does not have. They overlap in spirit on tool and model
- * mix; they do not read the same store or answer the same question.
+ * Sibling observe verbs (stay separate — different questions):
+ *
+ *   agents cost       what you spent ($ and duration)
+ *   agents output     what shipped (burn vs PRs and commits)
+ *   agents usage      live quota headroom
+ *   agents perf       latency (hooks, CLI commands, agent.run) — not popularity
+ *   agents sessions stats  which skills/slash-commands were explicitly invoked
+ *
+ * Why mix lives here (not a second top-level `trends`): two abstract "analytics"
+ * nouns taught agents and humans to guess. One verb, two engines — cheap SQL mix
+ * vs transcript facets. Latency stays on `perf` so it is never confused with mix.
  *
  * Modelled on Claude Code's `/insights`, with the difference that motivated it: that
  * command reads one account's directory, while `balanced` rotation sprays sessions
@@ -27,6 +30,8 @@
  * The deterministic report makes zero network calls. `--narrative` is opt-in and adds
  * the coaching prose by piping the AGGREGATE (never raw transcripts) through a headless
  * `claude -p`.
+ *
+ * `agents trends` is a thin deprecated alias of the mix tree only (see commands/trends.ts).
  */
 import * as fs from 'fs';
 import chalk from 'chalk';
@@ -37,11 +42,25 @@ import { setHelpSections } from '../lib/help.js';
 import { discoverSessions, parseTimeFilter } from '../lib/session/discover.js';
 import { querySessions, readSessionInsights, writeSessionInsights, clearSessionInsights, } from '../lib/session/db.js';
 import { parseSession } from '../lib/session/parse.js';
-import { computeInsightFacets, mergeFacets, newFacetAccumulator, detectOverlap, percentile, bucketGaps, topEntries, } from '../lib/session/insights.js';
+import { computeInsightFacets, mergeFacets, newFacetAccumulator, detectOverlap, percentile, bucketGaps, topEntries, buildInsightActions, } from '../lib/session/insights.js';
 import { formatUsd } from '../lib/pricing/index.js';
 import { formatDuration } from '../lib/session/render.js';
 import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/session/width.js';
+import { registerMixCommands } from '../lib/analytics/mix-commands.js';
 const execFileAsync = promisify(execFile);
+function collectAgent(value, previous) {
+    return [...previous, value];
+}
+function agentsFromArgv(argv) {
+    const values = [];
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === '--agent' && argv[i + 1])
+            values.push(argv[++i]);
+        else if (argv[i].startsWith('--agent='))
+            values.push(argv[i].slice('--agent='.length));
+    }
+    return values;
+}
 function resolveGroup(by) {
     if (by === undefined)
         return 'account';
@@ -187,7 +206,7 @@ function renderHours(hours, out) {
     out.push(`  ${chalk.cyan(spark)}`);
     out.push(`  ${chalk.gray('0h'.padEnd(6))}${chalk.gray('6h'.padEnd(6))}${chalk.gray('12h'.padEnd(6))}${chalk.gray('18h'.padEnd(5))}${chalk.gray('23h')}`);
 }
-function renderReport(groups, dim, meta) {
+function renderReport(groups, dim, meta, actions, harnesses) {
     const out = [];
     const scope = meta.since ? `last ${meta.since}` : 'all time';
     out.push(chalk.bold('Insights') + chalk.gray(`  ${scope} · ${meta.analyzed} of ${meta.scanned} sessions`));
@@ -198,16 +217,27 @@ function renderReport(groups, dim, meta) {
         return;
     }
     // Per-group table — the headline, and the thing no sibling command produces.
+    // Includes silent-stall counts so harness/account laziness is visible without --json.
     out.push('');
     out.push(chalk.bold(`By ${dim}`));
-    const labelW = Math.min(Math.max(...groups.map((g) => stringWidth(g.label)), 5), Math.max(20, terminalWidth() - 46));
+    const labelW = Math.min(Math.max(...groups.map((g) => stringWidth(g.label)), 5), Math.max(16, terminalWidth() - 58));
     const sessW = Math.max(...groups.map((g) => String(g.sessions).length), 3);
+    const stallOf = (g) => Object.entries(g.facets.frictionSignals)
+        .filter(([k]) => k.startsWith('silent stall:'))
+        .reduce((n, [, c]) => n + c, 0);
+    const resumeOf = (g) => g.facets.correctionSignals['resume after silent stall'] ?? 0;
+    const stallW = Math.max(...groups.map((g) => String(stallOf(g)).length), 5);
+    out.push(chalk.gray(`  ${padToWidth('', labelW)}  ${''.padStart(sessW)}       ` +
+        `${''.padStart(9)}  ${''.padStart(8)}  ${'stalls'.padStart(stallW)}  resume`));
     for (const g of groups) {
         const cost = g.costUsd > 0 ? formatUsd(g.costUsd) : '—';
         const dur = g.durationMs > 0 ? formatDuration(g.durationMs) : '—';
+        const stalls = stallOf(g);
+        const resumes = resumeOf(g);
         out.push(`  ${padToWidth(truncateToWidth(g.label, labelW), labelW)}  ` +
             `${chalk.gray(String(g.sessions).padStart(sessW))} ${chalk.gray('sess')}  ` +
-            `${chalk.green(padToWidth(cost, 9))}  ${chalk.gray(dur)}`);
+            `${chalk.green(padToWidth(cost, 9))}  ${chalk.gray(padToWidth(dur, 8))}  ` +
+            `${chalk.cyan(String(stalls).padStart(stallW))}  ${chalk.cyan(String(resumes))}`);
     }
     // Everything below is the whole scope folded together; per-group detail is in --json.
     const all = newFacetAccumulator();
@@ -216,22 +246,54 @@ function renderReport(groups, dim, meta) {
     renderCounts('Top tools', topEntries(all.toolCounts, 8), out);
     renderCounts('Languages', topEntries(all.languages, 6), out);
     renderCounts('Models', topEntries(all.models, 6), out);
+    renderCounts('Silent stalls by model', topEntries(all.silentStallsByModel ?? {}, 8), out);
     // Friction — the section that earns the command.
     const gaps = all.responseGaps;
+    const silentStalls = Object.entries(all.frictionSignals)
+        .filter(([k]) => k.startsWith('silent stall:'))
+        .reduce((n, [, c]) => n + c, 0);
+    const resumeNudges = all.correctionSignals['resume after silent stall'] ?? 0;
     out.push('');
     out.push(chalk.bold('Friction'));
     out.push(`  ${padToWidth('interruptions', 18)}  ${chalk.cyan(String(all.interruptions))}` +
         chalk.gray('   turns you cut short'));
     out.push(`  ${padToWidth('tool errors', 18)}  ${chalk.cyan(String(all.errorCount))}`);
     if (gaps.length > 0) {
-        out.push(`  ${padToWidth('your reply time', 18)}  ` +
-            chalk.cyan(`p50 ${Math.round(percentile(gaps, 50))}s`) + chalk.gray(` · p90 ${Math.round(percentile(gaps, 90))}s`));
+        // Same timestamps as silent stalls; this line is the distribution. Silent
+        // stalls (below) are the agent-attributed long gaps after the model stopped.
+        out.push(`  ${padToWidth('gap until next msg', 18)}  ` +
+            chalk.cyan(`p50 ${Math.round(percentile(gaps, 50))}s`) + chalk.gray(` · p90 ${Math.round(percentile(gaps, 90))}s`) +
+            chalk.gray('   after assistant last spoke'));
+    }
+    if (silentStalls > 0) {
+        out.push(`  ${padToWidth('silent stalls', 18)}  ${chalk.cyan(String(silentStalls))}` +
+            chalk.gray('   agent idle ≥5m until you resumed (also in By ' + dim + ' table)'));
+    }
+    if (resumeNudges > 0) {
+        out.push(`  ${padToWidth('resume nudges', 18)}  ${chalk.cyan(String(resumeNudges))}` +
+            chalk.gray('   "continue"/"keep going" after a silent stall'));
     }
     const errs = topEntries(all.errorCategories, 6);
     if (errs.length > 0) {
         for (const e of errs)
             out.push(`    ${chalk.gray('·')} ${padToWidth(e.name, 16)} ${chalk.gray(String(e.count))}`);
     }
+    renderCounts('Friction / thrash', topEntries(all.frictionSignals, 10), out);
+    renderCounts('Dissatisfaction / corrections', topEntries(all.correctionSignals, 10), out);
+    renderCounts('Automatable repeats', topEntries(all.automationSignals, 10), out);
+    renderCounts('Harness split', harnesses, out);
+    out.push('');
+    out.push(chalk.bold('Actions'));
+    if (actions.length === 0) {
+        out.push(chalk.gray('  No repeated action pattern met the evidence threshold in this window.'));
+    }
+    else {
+        out.push(chalk.gray('  pri     category    evidence  sample sessions  action'));
+        for (const action of actions.slice(0, 12)) {
+            out.push(`  ${padToWidth(action.priority, 7)} ${padToWidth(action.category, 11)} ` +
+                `${String(action.evidenceCount).padStart(8)}  ${padToWidth(action.sampleSessionIds.join(', '), 25)} ${action.action}`);
+        }
+    }
     // Output
     out.push('');
     out.push(chalk.bold('What you changed'));
@@ -286,7 +348,7 @@ function renderReport(groups, dim, meta) {
         out.push(chalk.yellow(`  ${meta.unreadable} transcripts could not be read; their behaviour is missing from these totals.`));
     }
     if (all.gapsOverCeiling > 0) {
-        out.push(chalk.gray(`  ${all.gapsOverCeiling} reply gaps over an hour excluded from the percentiles.`));
+        out.push(chalk.gray(`  ${all.gapsOverCeiling} gaps over an hour excluded from p50/p90 (still counted as silent stall: 1h+ when the assistant last spoke).`));
     }
     out.push('');
     out.push(chalk.gray('  `agents insights --by project` to see it per repo'));
@@ -306,6 +368,13 @@ async function renderNarrative(payload) {
         '2. What is costing you — split into the assistant\'s fault vs your own workflow.',
         '3. Quick wins — concrete, tied to a number in the data.',
         '4. Worth trying — one more ambitious workflow change.',
+        '',
+        'Silent stalls (required): if frictionSignals contain "silent stall: …" or',
+        'correctionSignals contain "resume after silent stall" / "continue / keep going",',
+        'call that out explicitly in section 2 or 3 with the counts. Those mean the model',
+        'stopped mid-session and sat idle until the human pinged it (timestamps: last',
+        'assistant event → next user message ≥ 5 minutes). Do not reframe them as the',
+        'user being slow unless the data only shows short reply gaps.',
         'Be specific and cite the numbers. No preamble, no flattery, no bullet padding.',
         '',
         JSON.stringify(payload),
@@ -351,11 +420,11 @@ async function insightsAction(options) {
     if (options.refresh)
         clearSessionInsights();
     const filter = { sinceMs };
-    if (options.agent)
-        filter.agent = options.agent;
     const scanned = querySessions(filter);
     const wanted = options.account?.toLowerCase();
     const inScope = scanned.filter((m) => {
+        if (options.agent?.length && !options.agent.includes(m.agent))
+            return false;
         if (!wanted)
             return true;
         return [m.accountKey, m.account, m.accountOrg]
@@ -381,6 +450,15 @@ async function insightsAction(options) {
     });
     const overlap = detectOverlap(spans);
     const groups = buildGroups(substantive, facetsById, dim);
+    const evidence = substantive.flatMap((m) => {
+        const facets = facetsById.get(m.id);
+        return facets ? [{ id: m.id, facets }] : [];
+    });
+    const actions = buildInsightActions(evidence);
+    const harnesses = topEntries(substantive.reduce((counts, row) => {
+        counts[row.agent] = (counts[row.agent] ?? 0) + 1;
+        return counts;
+    }, {}), 20);
     if (options.json) {
         const payload = {
             generatedAt: new Date().toISOString(),
@@ -392,6 +470,8 @@ async function insightsAction(options) {
             minMessages,
             by: dim,
             overlap,
+            actions,
+            harnesses,
             groups: groups.map((g) => ({
                 key: g.key,
                 label: g.label,
@@ -420,7 +500,7 @@ async function insightsAction(options) {
         unreadable,
         minMessages,
         overlap,
-    });
+    }, actions, harnesses);
     if (options.narrative) {
         await renderNarrative(groups.map((g) => ({
             account: g.label, sessions: g.sessions, costUsd: g.costUsd,
@@ -434,49 +514,77 @@ async function insightsAction(options) {
         })));
     }
 }
-export function registerInsightsCommand(program) {
-    const cmd = addHostOption(program.command('insights'))
-        .description('How you work — tools, friction, and rhythm, split by the account that did the work')
+function configureInsightsCommand(cmd) {
+    addHostOption(cmd)
+        .description('How work looks — behavioural report (default) or counter mix (`mix`, recipes)')
         .option('--json', 'Output the full report as JSON')
         .option('--since <time>', 'Window: 7d, 4w, 3mo, an ISO date, or "all" (default 30d)')
         .option('--all', 'Every session ever indexed. Alias for --since all')
         .option('--by <dimension>', 'Group by: account (default), agent, project, or day')
         .option('--account <match>', 'Only sessions whose account key, email, or org contains this')
-        .option('--agent <id>', 'Only one harness (claude, codex, droid, …)')
+        .option('--agent <id>', 'Only these harnesses; repeat for more than one', collectAgent, [])
         .option('--min-messages <n>', 'Skip sessions under this many messages, both roles counted (default 2)')
         .option('--refresh', 'Discard cached facets and re-read every transcript')
         .option('--narrative', 'Add a written read on the numbers via a headless `claude -p`')
         .action(async (options) => {
-        await insightsAction(options);
+        const inherited = cmd.parent?.name() === 'sessions'
+            ? cmd.parent.opts()
+            : {};
+        const inheritedAgent = typeof inherited.agent === 'string' ? [inherited.agent] : [];
+        const rawAgents = agentsFromArgv(process.argv.slice(2));
+        await insightsAction({
+            ...inherited,
+            ...options,
+            agent: rawAgents.length > 0 ? rawAgents : [...inheritedAgent, ...(options.agent ?? [])],
+            json: options.json ?? inherited.json,
+            since: options.since ?? inherited.since,
+        });
     });
+    // Cheap counter recipes (former top-level `agents trends`) — same parent, no peer verb.
+    registerMixCommands(cmd);
     setHelpSections(cmd, {
         examples: `
-      # Last 30 days, split by Claude account — the default
+      # Behavioural report — last 30 days, split by Claude account (default)
       agents insights
 
       # Which repo is eating the time
       agents insights --by project --since 90d
 
+      # Counter mix board (harness/model/token/secrets recipes) — former agents trends
+      agents insights mix
+      agents insights mix --days 30
+      agents insights harness-mix --json
+      agents insights query --kind secret --days 7
+
       # One account only, all of its history
       agents insights --account "Turing Labs" --all
 
       # Machine-readable, for a dashboard or a slash command
-      agents insights --json
+      agents sessions insights --agent claude --agent codex --json
 
       # Add a written read on what to change
       agents insights --narrative
     `,
         notes: `
-      Answers "how do you work". For "what did it cost" use \`agents cost\`, for "what
-      shipped" use \`agents output\`, for live quota use \`agents usage\`.
+      Two paths under one verb:
+        bare \`agents insights\`     — transcript behaviour (tools, friction, rhythm, by account)
+        \`agents insights mix\`      — cheap counters from sessions.db + usage.db
+      Latency is \`agents perf\` (not mix). Quota is \`agents usage\`. Skill/slash popularity
+      is \`agents sessions stats\`. \`agents trends\` is a deprecated alias of the mix tree.
 
-      The first run parses every in-scope transcript and caches the result; later runs
+      The behavioural report parses in-scope transcripts once and caches facets; later runs
       re-read only files that changed. \`--refresh\` forces a full re-read.
 
-      Account attribution is Claude-only today. Sessions from other harnesses group
-      under \`unattributed:<agent>\`.
+      \`agents insights\` is the top-level alias of \`agents sessions insights\`.
+      Repeat \`--agent\` to compare several harnesses in one report.
 
       Everything except \`--narrative\` is local and makes no network calls.
     `,
     });
 }
+export function registerInsightsCommand(program) {
+    configureInsightsCommand(program.command('insights'));
+}
+export function registerSessionsInsightsCommand(sessions) {
+    configureInsightsCommand(sessions.command('insights'));
+}

package/dist/commands/output.js

@@ -12,6 +12,7 @@ import { terminalWidth, truncateToWidth, padToWidth } from '../lib/session/width
 import { collectGitOutput } from '../lib/output/git-output.js';
 import { loadDevices, isControlDevice } from '../lib/devices/registry.js';
 import { machineId } from '../lib/session/sync/config.js';
+import { stripClixml } from '../lib/hosts/remote-cmd.js';
 const execFileAsync = promisify(execFile);
 export function registerOutputCommand(program) {
     addHostOption(program.command('output'))
@@ -24,16 +25,21 @@ export function registerOutputCommand(program) {
         .option('--login <login...>', 'Count PRs for these GitHub logins (default: current gh user)')
         .option('--no-prs', 'Skip the GitHub PR lookup (commits only)')
         .option('--all-hosts', 'Aggregate across every online device (ag devices) over SSH')
+        .option('--pricing <scenario>', 'Cost scenario: actual (default, cache-discounted) or no-cache (cache read/write billed at the full input rate)')
         .addHelpText('after', `
 Examples:
   agents output                       Last 7 days: burn, output tokens, PRs, commits, ratios
   agents output --since 24h           Last 24 hours
   agents output --since 1mo           Last month  (units: 1h 24h 7d 4w 1mo 1y, or ISO date)
+  agents output --pricing no-cache    Model the burn as if prompt caching were off
   agents output --all-hosts           Fleet-wide, folding in every online machine
   agents output --by day --json       Machine-readable daily burn/output rollup
 
 Burn (cost) is computed offline from a versioned per-model price table (${PRICING_VERSION}).
 Output tokens are the real generated tokens — NOT the cache-inflated total token count.
+The burn is split into input / cache-read / cache-write where the harness records it
+(Claude/Codex/Gemini/Droid). --pricing no-cache reprices cached tokens at the input rate,
+so you can see what caching is saving. --json always carries both actual and no-cache costs.
 `)
         .action(async (options) => {
         await outputAction(options);
@@ -47,6 +53,14 @@ function resolveGroup(by) {
     console.error(chalk.red('error: --by must be one of: agent, project, day, account'));
     process.exit(1);
 }
+function resolvePricing(pricing) {
+    if (pricing === undefined || pricing === 'actual')
+        return 'actual';
+    if (pricing === 'no-cache')
+        return 'no-cache';
+    console.error(chalk.red('error: --pricing must be one of: actual, no-cache'));
+    process.exit(1);
+}
 /** Compact token formatter: 38.6M, 4.1K, 10.6B. */
 function formatCompact(n) {
     const abs = Math.abs(n);
@@ -59,13 +73,27 @@ function formatCompact(n) {
     return String(n);
 }
 function emptyBurn() {
-    return { costUsd: 0, outputTokens: 0, tokenCount: 0, sessionCount: 0, durationMs: 0 };
+    return {
+        costUsd: 0,
+        costUsdNoCache: 0,
+        outputTokens: 0,
+        tokenCount: 0,
+        inputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        sessionCount: 0,
+        durationMs: 0,
+    };
 }
 function sumBurn(rows) {
     return rows.reduce((acc, r) => {
         acc.costUsd += r.costUsd;
+        acc.costUsdNoCache += r.costUsdNoCache;
         acc.outputTokens += r.outputTokens;
         acc.tokenCount += r.tokenCount;
+        acc.inputTokens += r.inputTokens;
+        acc.cacheReadTokens += r.cacheReadTokens;
+        acc.cacheWriteTokens += r.cacheWriteTokens;
         acc.sessionCount += r.sessionCount;
         acc.durationMs += r.durationMs;
         return acc;
@@ -122,7 +150,9 @@ async function fetchRemotePayload(device, options) {
             timeout: 120_000,
             maxBuffer: 64 * 1024 * 1024,
         });
-        const parsed = JSON.parse(stdout);
+        // A Windows device relays its payload through PowerShell, which can prefix a
+        // CLIXML banner ahead of the JSON — strip it before parsing (RUSH-2286).
+        const parsed = JSON.parse(stripClixml(stdout));
         parsed.machine = parsed.machine || device;
         return parsed;
     }
@@ -141,13 +171,17 @@ async function fetchRemotePayload(device, options) {
 }
 async function outputAction(options) {
     const includePrs = options.prs !== false;
+    // Validate --pricing up front so a bad value errors even under --json. The JSON
+    // payload always carries BOTH costs regardless of the scenario — the flag only
+    // chooses which one the text renderer leads with.
+    const scenario = resolvePricing(options.pricing);
     if (!options.allHosts) {
         const payload = await computeLocalPayload(options, includePrs);
         if (options.json) {
             process.stdout.write(JSON.stringify(withRatios(payload, [payload]), null, 2) + '\n');
             return;
         }
-        renderSingle(payload);
+        renderSingle(payload, scenario);
         return;
     }
     // Fleet: local payload + every online device, folded in over SSH.
@@ -166,7 +200,7 @@ async function outputAction(options) {
         process.stdout.write(JSON.stringify(withRatios(mergeMachines(machines, options), machines), null, 2) + '\n');
         return;
     }
-    renderFleet(machines, options);
+    renderFleet(machines, options, scenario);
 }
 /** Merge per-machine payloads into a combined one (burn + commits summed; PRs local-only). */
 function mergeMachines(machines, options) {
@@ -179,8 +213,12 @@ function mergeMachines(machines, options) {
     const uncosted = new Set();
     for (const m of machines) {
         burn.costUsd += m.burn.costUsd;
+        burn.costUsdNoCache += m.burn.costUsdNoCache;
         burn.outputTokens += m.burn.outputTokens;
         burn.tokenCount += m.burn.tokenCount;
+        burn.inputTokens += m.burn.inputTokens;
+        burn.cacheReadTokens += m.burn.cacheReadTokens;
+        burn.cacheWriteTokens += m.burn.cacheWriteTokens;
         burn.sessionCount += m.burn.sessionCount;
         burn.durationMs += m.burn.durationMs;
         for (const s of m.output.commitShas)
@@ -188,15 +226,23 @@ function mergeMachines(machines, options) {
         for (const a of m.uncostedAgents)
             uncosted.add(a);
         for (const r of m.breakdown.rows) {
-            const cur = byKey.get(r.key) ?? { key: r.key, label: r.label, costUsd: 0, durationMs: 0, sessionCount: 0, tokenCount: 0, outputTokens: 0 };
+            const cur = byKey.get(r.key) ?? {
+                key: r.key, label: r.label, costUsd: 0, costUsdNoCache: 0, durationMs: 0,
+                sessionCount: 0, tokenCount: 0, outputTokens: 0,
+                inputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0,
+            };
             // Peers resolve their own labels; keep the first non-empty one so a machine that
             // has not indexed an account yet does not blank a label another machine supplied.
             cur.label ??= r.label;
             cur.costUsd += r.costUsd;
+            cur.costUsdNoCache += r.costUsdNoCache;
             cur.durationMs += r.durationMs;
             cur.sessionCount += r.sessionCount;
             cur.tokenCount += r.tokenCount;
             cur.outputTokens += r.outputTokens;
+            cur.inputTokens += r.inputTokens;
+            cur.cacheReadTokens += r.cacheReadTokens;
+            cur.cacheWriteTokens += r.cacheWriteTokens;
             byKey.set(r.key, cur);
         }
     }
@@ -226,47 +272,76 @@ function withRatios(payload, machines) {
         machines: machines.length > 1 ? machines.map(m => ({ machine: m.machine, burn: m.burn, commits: m.output.commits, error: m.error })) : undefined,
     };
 }
-/** Shared header line: burned · output tokens · PRs · commits, plus ratios. */
-function headerLines(payload) {
+/** The cost the text renderer leads with for the chosen scenario. */
+function scenarioCost(x, scenario) {
+    return scenario === 'no-cache' ? x.costUsdNoCache : x.costUsd;
+}
+/** Shared header line: burned · output tokens · PRs · commits, plus ratios + burn split. */
+function headerLines(payload, scenario) {
     const prsTotal = payload.output.prsOpened + payload.output.prsMerged;
+    const burn = payload.burn;
+    const cost = scenarioCost(burn, scenario);
     const out = [];
     out.push('  ' +
-        `${chalk.green(formatUsd(payload.burn.costUsd))} burned` +
+        `${chalk.green(formatUsd(cost))} burned${scenario === 'no-cache' ? chalk.gray(' (no-cache)') : ''}` +
         chalk.gray('  ·  ') +
-        `${chalk.cyan(formatCompact(payload.burn.outputTokens))} output tokens` +
+        `${chalk.cyan(formatCompact(burn.outputTokens))} output tokens` +
         chalk.gray('  ·  ') +
         `${chalk.yellow(String(prsTotal))} PRs ${chalk.gray(`(${payload.output.prsMerged} merged)`)}` +
         chalk.gray('  ·  ') +
         `${chalk.yellow(String(payload.output.commits))} commits`);
     const ratios = [];
     if (prsTotal > 0)
-        ratios.push(`${formatUsd(payload.burn.costUsd / prsTotal)}/PR`);
+        ratios.push(`${formatUsd(cost / prsTotal)}/PR`);
     if (payload.output.commits > 0)
-        ratios.push(`${formatUsd(payload.burn.costUsd / payload.output.commits)}/commit`);
-    if (payload.burn.costUsd > 0)
-        ratios.push(`${formatCompact(Math.round(payload.burn.outputTokens / payload.burn.costUsd))} out-tok/$`);
+        ratios.push(`${formatUsd(cost / payload.output.commits)}/commit`);
+    if (cost > 0)
+        ratios.push(`${formatCompact(Math.round(burn.outputTokens / cost))} out-tok/$`);
     if (ratios.length > 0)
         out.push(chalk.gray('  ' + ratios.join('  ·  ')));
+    // Burn split — only for harnesses that recorded one (input/cache totals > 0).
+    const splitTotal = burn.inputTokens + burn.cacheReadTokens + burn.cacheWriteTokens;
+    if (splitTotal > 0) {
+        out.push(chalk.gray('  burn split: ') +
+            `${chalk.cyan(formatCompact(burn.inputTokens))} input` +
+            chalk.gray('  ·  ') +
+            `${chalk.cyan(formatCompact(burn.cacheReadTokens))} cache-read` +
+            chalk.gray('  ·  ') +
+            `${chalk.cyan(formatCompact(burn.cacheWriteTokens))} cache-write`);
+    }
+    // No-cache comparison — shown whenever caching actually moved the number, so an
+    // operator sees the saving in `actual` mode too (RUSH-2287: "both if useful").
+    if (burn.costUsdNoCache > burn.costUsd && burn.costUsd > 0) {
+        const saved = burn.costUsdNoCache - burn.costUsd;
+        const pct = Math.round((saved / burn.costUsdNoCache) * 100);
+        out.push(chalk.gray('  caching: ') +
+            `actual ${chalk.green(formatUsd(burn.costUsd))}` +
+            chalk.gray('  vs  ') +
+            `no-cache ${chalk.yellow(formatUsd(burn.costUsdNoCache))}` +
+            chalk.gray(`  (saved ${formatUsd(saved)}, ${pct}%)`));
+    }
     return out;
 }
 /** Render the per-group burn/output table. */
-function renderBreakdown(rows, groupBy) {
+function renderBreakdown(rows, groupBy, scenario) {
     const out = [chalk.bold(`By ${groupBy}`)];
     if (rows.length === 0)
         return out;
+    const rowCost = (r) => scenarioCost(r, scenario);
     const cols = terminalWidth();
-    const burnW = Math.max(...rows.map(r => formatUsd(r.costUsd).length), 4);
+    const burnHeader = scenario === 'no-cache' ? 'burn(nc)' : 'burn';
+    const burnW = Math.max(...rows.map(r => formatUsd(rowCost(r)).length), burnHeader.length);
     const outW = Math.max(...rows.map(r => formatCompact(r.outputTokens).length), 6);
     const sessW = Math.max(...rows.map(r => String(r.sessionCount).length), 3);
     const fixedW = 2 + 2 + burnW + 2 + outW + 2 + sessW + 8;
     const display = (r) => r.label ?? r.key;
     const keyW = Math.max(8, Math.min(Math.max(...rows.map(r => display(r).length), groupBy.length), cols - fixedW));
-    out.push('  ' + chalk.gray(padToWidth('', keyW)) + '  ' + chalk.gray(padToWidth('burn', burnW)) + '  ' + chalk.gray(padToWidth('output', outW)) + '  ' + chalk.gray('sessions'));
+    out.push('  ' + chalk.gray(padToWidth('', keyW)) + '  ' + chalk.gray(padToWidth(burnHeader, burnW)) + '  ' + chalk.gray(padToWidth('output', outW)) + '  ' + chalk.gray('sessions'));
     for (const r of rows) {
         out.push('  ' +
             padToWidth(truncateToWidth(display(r), keyW), keyW) +
             '  ' +
-            chalk.green(padToWidth(formatUsd(r.costUsd), burnW)) +
+            chalk.green(padToWidth(formatUsd(rowCost(r)), burnW)) +
             '  ' +
             chalk.cyan(padToWidth(formatCompact(r.outputTokens), outW)) +
             '  ' +
@@ -274,17 +349,17 @@ function renderBreakdown(rows, groupBy) {
     }
     return out;
 }
-function renderSingle(payload) {
+function renderSingle(payload, scenario) {
     const out = [];
     out.push(chalk.bold('Output') + chalk.gray(`  ·  pricing ${payload.pricingVersion}  ·  since ${payload.since}`));
-    out.push(...headerLines(payload));
+    out.push(...headerLines(payload, scenario));
     out.push('');
     if (payload.burn.sessionCount === 0) {
         out.push(chalk.gray('No sessions with cost data found. Run `agents sessions --all` to index, then retry.'));
         console.log(out.join('\n'));
         return;
     }
-    out.push(...renderBreakdown(payload.breakdown.rows, payload.breakdown.by));
+    out.push(...renderBreakdown(payload.breakdown.rows, payload.breakdown.by, scenario));
     out.push('');
     out.push(chalk.bold('Shipped'));
     out.push(`  ${chalk.yellow(String(payload.output.commits))} commits across ${payload.output.reposScanned} repos` + chalk.gray(`  (authors: ${payload.output.authors.length > 0 ? payload.output.authors.join(', ') : 'none detected'})`));
@@ -300,22 +375,22 @@ function renderSingle(payload) {
         out.push(chalk.gray(`agent wall-clock: ${formatDuration(payload.burn.durationMs)}`));
     console.log(out.join('\n'));
 }
-function renderFleet(machines, options) {
+function renderFleet(machines, options, scenario) {
     const merged = mergeMachines(machines, options);
     const out = [];
     out.push(chalk.bold('Output') + chalk.gray(`  ·  fleet (${machines.length} machines)  ·  pricing ${merged.pricingVersion}  ·  since ${merged.since}`));
-    out.push(...headerLines(merged));
+    out.push(...headerLines(merged, scenario));
     out.push('');
     // By machine.
     out.push(chalk.bold('By machine'));
     const nameW = Math.max(...machines.map(m => m.machine.length), 7);
-    const burnW = Math.max(...machines.map(m => formatUsd(m.burn.costUsd).length), 4);
+    const burnW = Math.max(...machines.map(m => formatUsd(scenarioCost(m.burn, scenario)).length), 4);
     for (const m of machines) {
         const note = m.error ? chalk.red(`  (${m.error})`) : '';
         out.push('  ' +
             padToWidth(m.machine, nameW) +
             '  ' +
-            chalk.green(padToWidth(formatUsd(m.burn.costUsd), burnW)) +
+            chalk.green(padToWidth(formatUsd(scenarioCost(m.burn, scenario)), burnW)) +
             '  ' +
             chalk.cyan(padToWidth(formatCompact(m.burn.outputTokens), 7)) +
             '  ' +
@@ -323,7 +398,7 @@ function renderFleet(machines, options) {
             note);
     }
     out.push('');
-    out.push(...renderBreakdown(merged.breakdown.rows, merged.breakdown.by));
+    out.push(...renderBreakdown(merged.breakdown.rows, merged.breakdown.by, scenario));
     out.push('');
     out.push(chalk.gray(notCountedLine(merged.uncostedAgents)));
     console.log(out.join('\n'));