@phnx-labs/agents-cli 1.22.26 → 1.22.28

package/dist/lib/session/db.js

@@ -26,7 +26,7 @@ const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. Exported so tests
  * assert against the constant instead of hardcoding a number that every bump
  * then has to chase (docs/05-sessions.md calls the constant the source of truth). */
-export const SCHEMA_VERSION = 36;
+export const SCHEMA_VERSION = 37;
 /**
  * Bump to force `agents sessions backfill resources` to re-derive every
  * session's skill/slash-command tallies on its next run (resource_scan_ledger
@@ -81,7 +81,11 @@ CREATE TABLE IF NOT EXISTS sessions (
   message_count INTEGER,
   token_count INTEGER,
   output_tokens INTEGER,
+  input_tokens INTEGER,
+  cache_read_tokens INTEGER,
+  cache_write_tokens INTEGER,
   cost_usd REAL,
+  cost_usd_nocache REAL,
   duration_ms INTEGER,
   model TEXT,
   tool_call_count INTEGER,
@@ -308,7 +312,8 @@ CREATE TABLE IF NOT EXISTS session_insights (
  * re-derives on the next `agents insights` instead of silently reporting stale
  * numbers alongside fresh ones. Same role as RESOURCE_INDEX_VERSION.
  */
-export const INSIGHTS_EXTRACTOR_VERSION = 4;
+/** Bump when facet extraction changes so cached rows recompute (stalls-by-model v6). */
+export const INSIGHTS_EXTRACTOR_VERSION = 6;
 let dbInstance = null;
 /**
  * Apply schema migrations from `fromVersion` → SCHEMA_VERSION. The new
@@ -875,6 +880,25 @@ function migrateSchema(db, fromVersion) {
       FROM tool_calls;
     `);
     }
+    if (fromVersion < 37) {
+        // v36 -> v37: persist the burn SPLIT (uncached input / cache-read /
+        // cache-write) and a second "no-cache" cost per session, so `agents output`
+        // can report the token split and a --pricing no-cache scenario (RUSH-2287).
+        // These are new nullable columns — do NOT flush scan_ledger (adding a column
+        // must keep warm session ledgers warm, the contract the v33->v34 note above
+        // states). Pre-upgrade rows stay NULL for the split until their transcript is
+        // re-scanned; `agents output` reports the split only where it is present, so
+        // an absent split reads as "not available for this session", never as zero.
+        const cols = new Set(db.prepare(`PRAGMA table_info(sessions)`).all().map((c) => c.name));
+        if (!cols.has('input_tokens'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN input_tokens INTEGER`);
+        if (!cols.has('cache_read_tokens'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN cache_read_tokens INTEGER`);
+        if (!cols.has('cache_write_tokens'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN cache_write_tokens INTEGER`);
+        if (!cols.has('cost_usd_nocache'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN cost_usd_nocache REAL`);
+    }
 }
 /**
  * Stamp `account_key` / `account_org` / `account` on every Claude row from its
@@ -1019,6 +1043,7 @@ export function getDB() {
 }
 /** Close the cached database connection. */
 export function closeDB() {
+    clearSessionExistenceCache();
     if (dbInstance) {
         dbInstance.close();
         dbInstance = null;
@@ -1369,7 +1394,8 @@ const upsertSessionStmt = (db) => db.prepare(`
     id, short_id, agent, origin, routine_name, routine_run_id,
     version, account, account_key, account_org, mode, timestamp, last_activity,
     project, cwd, git_branch, topic, label, message_count, token_count,
-    output_tokens, cost_usd, duration_ms, model, tool_call_count,
+    output_tokens, input_tokens, cache_read_tokens, cache_write_tokens,
+    cost_usd, cost_usd_nocache, duration_ms, model, tool_call_count,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
     pr_url, pr_number, worktree_slug, ticket_id, spawned_team, plan, todos,
     recent_directories_touched, linear_project, linear_project_url, machine,
@@ -1378,7 +1404,8 @@ const upsertSessionStmt = (db) => db.prepare(`
     @id, @short_id, @agent, @origin, @routine_name, @routine_run_id,
     @version, @account, @account_key, @account_org, @mode, @timestamp, @last_activity,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
-    @output_tokens, @cost_usd, @duration_ms, @model, @tool_call_count,
+    @output_tokens, @input_tokens, @cache_read_tokens, @cache_write_tokens,
+    @cost_usd, @cost_usd_nocache, @duration_ms, @model, @tool_call_count,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
     @pr_url, @pr_number, @worktree_slug, @ticket_id, @spawned_team, @plan, @todos,
     @recent_directories_touched, @linear_project, @linear_project_url, @machine,
@@ -1413,7 +1440,11 @@ const upsertSessionStmt = (db) => db.prepare(`
     message_count = excluded.message_count,
     token_count = excluded.token_count,
     output_tokens = excluded.output_tokens,
+    input_tokens = excluded.input_tokens,
+    cache_read_tokens = excluded.cache_read_tokens,
+    cache_write_tokens = excluded.cache_write_tokens,
     cost_usd = excluded.cost_usd,
+    cost_usd_nocache = excluded.cost_usd_nocache,
     duration_ms = excluded.duration_ms,
     model = excluded.model,
     tool_call_count = excluded.tool_call_count,
@@ -1652,7 +1683,11 @@ export function upsertSession(meta, content, scan) {
         message_count: meta.messageCount ?? null,
         token_count: meta.tokenCount ?? null,
         output_tokens: meta.outputTokens ?? null,
+        input_tokens: meta.inputTokens ?? null,
+        cache_read_tokens: meta.cacheReadTokens ?? null,
+        cache_write_tokens: meta.cacheWriteTokens ?? null,
         cost_usd: meta.costUsd ?? null,
+        cost_usd_nocache: meta.costUsdNoCache ?? null,
         duration_ms: meta.durationMs ?? null,
         model: meta.model ?? null,
         tool_call_count: meta.toolCallCount ?? null,
@@ -1832,7 +1867,11 @@ export function upsertSessionsBatch(entries) {
                     message_count: meta.messageCount ?? null,
                     token_count: meta.tokenCount ?? null,
                     output_tokens: meta.outputTokens ?? null,
+                    input_tokens: meta.inputTokens ?? null,
+                    cache_read_tokens: meta.cacheReadTokens ?? null,
+                    cache_write_tokens: meta.cacheWriteTokens ?? null,
                     cost_usd: meta.costUsd ?? null,
+                    cost_usd_nocache: meta.costUsdNoCache ?? null,
                     duration_ms: meta.durationMs ?? null,
                     model: meta.model ?? null,
                     tool_call_count: meta.toolCallCount ?? null,
@@ -2046,7 +2085,11 @@ function rowToMeta(row) {
         messageCount: row.message_count ?? undefined,
         tokenCount: row.token_count ?? undefined,
         outputTokens: row.output_tokens ?? undefined,
+        inputTokens: row.input_tokens ?? undefined,
+        cacheReadTokens: row.cache_read_tokens ?? undefined,
+        cacheWriteTokens: row.cache_write_tokens ?? undefined,
         costUsd: row.cost_usd ?? undefined,
+        costUsdNoCache: row.cost_usd_nocache ?? undefined,
         durationMs: row.duration_ms ?? undefined,
         model: row.model ?? undefined,
         toolCallCount: row.tool_call_count ?? undefined,
@@ -2235,17 +2278,18 @@ function buildSessionWhere(options) {
     const clause = where.length > 0 ? `WHERE ${where.join(' AND ')}` : '';
     return { clause, params };
 }
-/**
- * Resolve which of the given file paths no longer exist, batching the check
- * per directory instead of one `fs.existsSync` stat syscall per file.
- * Transcript trees put many sessions in the same directory (one Claude
- * `~/.claude/projects/<slug>/` holds every session for that project), so
- * `readdirSync` once per directory and a Set membership test collapses what
- * used to be N stat syscalls into (number of distinct directories) readdir
- * syscalls — the same existence answer, far fewer syscalls on a large index
- * (RUSH-2211). Falls back to per-file existsSync only when the directory
- * itself can't be listed (permissions, race with a concurrent delete).
- */
+const directoryMembershipCache = new Map();
+let directoryMembershipSweepCount = 0;
+const DIRECTORY_MTIME_SETTLE_MS = 2_000;
+/** Process-local diagnostics for the real-filesystem existence-cache tests. */
+export function getSessionExistenceCacheStats() {
+    return { sweeps: directoryMembershipSweepCount };
+}
+/** Clear process-local directory membership state when the session DB closes. */
+function clearSessionExistenceCache() {
+    directoryMembershipCache.clear();
+    directoryMembershipSweepCount = 0;
+}
 function findMissingFilePaths(filePaths) {
     const byDir = new Map();
     for (const p of filePaths) {
@@ -2261,21 +2305,36 @@ function findMissingFilePaths(filePaths) {
     for (const [dir, basenames] of byDir) {
         let entries;
         try {
-            entries = new Set(fs.readdirSync(dir));
+            const stat = fs.statSync(dir);
+            const cached = directoryMembershipCache.get(dir);
+            const now = Date.now();
+            const settled = now - stat.mtimeMs > DIRECTORY_MTIME_SETTLE_MS;
+            const fresh = cached && now - cached.cachedAtMs <= DIRECTORY_MTIME_SETTLE_MS;
+            if (settled && fresh && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+                entries = cached.entries;
+            }
+            else {
+                entries = new Set(fs.readdirSync(dir));
+                directoryMembershipCache.set(dir, { mtimeMs: stat.mtimeMs, size: stat.size, cachedAtMs: now, entries });
+                directoryMembershipSweepCount++;
+            }
         }
         catch {
+            directoryMembershipCache.delete(dir);
             // Directory itself is gone (or unreadable) — every file in it is missing.
             // Also covers the race where readdir loses to a concurrent delete: fall
             // back to a direct stat rather than assuming existence.
             for (const base of basenames) {
-                if (!fs.existsSync(path.join(dir, base)))
-                    missing.add(path.join(dir, base));
+                const filePath = path.join(dir, base);
+                if (!fs.existsSync(filePath))
+                    missing.add(filePath);
             }
             continue;
         }
         for (const base of basenames) {
+            const filePath = path.join(dir, base);
             if (!entries.has(base))
-                missing.add(path.join(dir, base));
+                missing.add(filePath);
         }
     }
     return missing;
@@ -2494,10 +2553,17 @@ export function queryUsageRollup(options) {
                     THEN account_org || ' <' || account || '>' END) AS label,`
         : ''}
       IFNULL(SUM(cost_usd), 0) AS costUsd,
+      -- A session with a cost but no persisted no-cache figure records no cache
+      -- split, so its no-cache cost equals its actual cost — fall back to cost_usd
+      -- so it still contributes to the scenario total rather than dropping to 0.
+      IFNULL(SUM(COALESCE(cost_usd_nocache, cost_usd)), 0) AS costUsdNoCache,
       IFNULL(SUM(duration_ms), 0) AS durationMs,
       COUNT(*) AS sessionCount,
       IFNULL(SUM(token_count), 0) AS tokenCount,
-      IFNULL(SUM(output_tokens), 0) AS outputTokens
+      IFNULL(SUM(output_tokens), 0) AS outputTokens,
+      IFNULL(SUM(input_tokens), 0) AS inputTokens,
+      IFNULL(SUM(cache_read_tokens), 0) AS cacheReadTokens,
+      IFNULL(SUM(cache_write_tokens), 0) AS cacheWriteTokens
     FROM sessions
     ${clause}
     GROUP BY key

package/dist/lib/session/discover.d.ts

@@ -71,8 +71,14 @@ interface ClaudeSessionScan {
     tokenCount?: number;
     /** Real generated (output) tokens, excluding cache-read/-write context. */
     outputTokens?: number;
+    /** Burn split — uncached input / cache-read / cache-write tokens (RUSH-2287). */
+    inputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
     /** Total USD cost accumulated from per-(model, direction) token usage. */
     costUsd?: number;
+    /** USD cost with cache read/write repriced at the input rate (RUSH-2287). */
+    costUsdNoCache?: number;
     /** Wall-clock duration in ms between the first and last timestamped event. */
     durationMs?: number;
     /** ISO time of the last timestamped event — the session's last activity. */
@@ -122,7 +128,13 @@ interface CodexSessionScan {
     tokenCount?: number;
     /** Real generated (output) tokens, excluding cache-read/-write context. */
     outputTokens?: number;
+    /** Burn split — uncached input / cache-read tokens (Codex has no cache-write) (RUSH-2287). */
+    inputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
     costUsd?: number;
+    /** USD cost with cache read repriced at the input rate (RUSH-2287). */
+    costUsdNoCache?: number;
     durationMs?: number;
     lastActivity?: string;
     contentText?: string;
@@ -417,8 +429,12 @@ export interface ClaudeParseState {
     toolCallCount: number;
     tokenCount: number;
     outputTokens: number;
+    inputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
     sawTokenCount: boolean;
     costUsd: number;
+    costUsdNoCache: number;
     sawCost: boolean;
     firstTsMs?: number;
     lastTsMs?: number;
@@ -468,7 +484,7 @@ export declare function scanClaudeSession(filePath: string): Promise<ClaudeSessi
  * exact even when the recent window is smaller than the true count.
  */
 export interface ClaudeParserState {
-    v: 2;
+    v: 3;
     offset: number;
     jsonlDroppingOversizedLine?: boolean;
     timestamp?: string;
@@ -487,9 +503,13 @@ export interface ClaudeParserState {
     toolCallCount: number;
     tokenCount: number;
     outputTokens: number;
+    inputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
     sawTokenCount: boolean;
     sawCost: boolean;
     costUsd: number;
+    costUsdNoCache: number;
     seenIdsSize: number;
     seenIdsRecent: string[];
     sawPrCreate: boolean;

package/dist/lib/session/discover.js

@@ -20,6 +20,8 @@ import { parseTimeFilter } from './relative-time.js';
 const execFileAsync = promisify(execFile);
 import { AGENTS, agentConfigDirName, getCliVersion } from '../agents.js';
 import { walkForFilesWithStat } from '../fs-walk.js';
+import { hasCommand } from '../cli-resources.js';
+import { execFileShellSpec } from '../platform/exec.js';
 import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { deriveShortId } from './short-id.js';
@@ -28,7 +30,7 @@ import { extractSessionTopic, extractSlashCommandName, extractSlashCommandFromTo
 import { isSkillInvocation, extractSkills, extractSlashCommands } from './highlights.js';
 import { parseAntigravity, parseCursor } from './parse.js';
 import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket, extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
-import { costOfUsage } from '../pricing/index.js';
+import { costOfUsage, costOfUsageNoCache } from '../pricing/index.js';
 import { machineForSessionFile } from './origin-machine.js';
 export { machineForSessionFile } from './origin-machine.js';
 import { mapBounded } from '../concurrency.js';
@@ -1096,7 +1098,11 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
             toolCallCount: scan.toolCallCount,
             tokenCount: scan.tokenCount,
             outputTokens: scan.outputTokens,
+            inputTokens: scan.inputTokens,
+            cacheReadTokens: scan.cacheReadTokens,
+            cacheWriteTokens: scan.cacheWriteTokens,
             costUsd: scan.costUsd,
+            costUsdNoCache: scan.costUsdNoCache,
             durationMs: scan.durationMs,
             isTeamOrigin,
             prUrl: scan.prUrl,
@@ -1130,7 +1136,11 @@ async function readClaudeMeta(filePath, sessionId, scanStamp, priorRow, label) {
             toolCallCount: scan.toolCallCount,
             tokenCount: scan.tokenCount,
             outputTokens: scan.outputTokens,
+            inputTokens: scan.inputTokens,
+            cacheReadTokens: scan.cacheReadTokens,
+            cacheWriteTokens: scan.cacheWriteTokens,
             costUsd: scan.costUsd,
+            costUsdNoCache: scan.costUsdNoCache,
             durationMs: scan.durationMs,
             topic: scan.topic,
             isTeamOrigin,
@@ -1438,7 +1448,11 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion, sc
         messageCount: scan.messageCount,
         tokenCount: scan.tokenCount,
         outputTokens: scan.outputTokens,
+        inputTokens: scan.inputTokens,
+        cacheReadTokens: scan.cacheReadTokens,
+        cacheWriteTokens: scan.cacheWriteTokens,
         costUsd: scan.costUsd,
+        costUsdNoCache: scan.costUsdNoCache,
         durationMs: scan.durationMs,
         account: resolveAccount?.(),
         prUrl: scan.prUrl,
@@ -1576,8 +1590,11 @@ function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
     let messageCount = 0;
     let tokenCount = 0;
     let outputTokens = 0;
+    let inputTokens = 0;
+    let cacheReadTokens = 0;
     let sawTokenCount = false;
     let costUsd = 0;
+    let costUsdNoCache = 0;
     let sawCost = false;
     let firstTsMs;
     let lastTsMs;
@@ -1622,21 +1639,28 @@ function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
                 (typeof gtk.output === 'number' ? gtk.output : 0) +
                     (typeof gtk.thoughts === 'number' ? gtk.thoughts : 0) +
                     (typeof gtk.tool === 'number' ? gtk.tool : 0);
+            // Burn split (RUSH-2287): Gemini has uncached input + cache-read, no cache-write.
+            if (typeof gtk.input === 'number')
+                inputTokens += gtk.input;
+            if (typeof gtk.cached === 'number')
+                cacheReadTokens += gtk.cached;
         }
         // Per-message cost: directional tokens × this message's model price.
         const msgModel = (typeof message.model === 'string' ? message.model : undefined) || sessionModel;
         const tk = message.tokens;
         if (msgModel && tk && typeof tk === 'object') {
-            const c = costOfUsage({
+            const usage = {
                 model: msgModel,
                 inputTokens: typeof tk.input === 'number' ? tk.input : undefined,
                 outputTokens: (typeof tk.output === 'number' ? tk.output : 0) +
                     (typeof tk.thoughts === 'number' ? tk.thoughts : 0) +
                     (typeof tk.tool === 'number' ? tk.tool : 0),
                 cacheReadTokens: typeof tk.cached === 'number' ? tk.cached : undefined,
-            });
+            };
+            const c = costOfUsage(usage);
             if (c > 0) {
                 costUsd += c;
+                costUsdNoCache += costOfUsageNoCache(usage);
                 sawCost = true;
             }
         }
@@ -1659,7 +1683,10 @@ function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
         messageCount,
         tokenCount: sawTokenCount ? tokenCount : undefined,
         outputTokens: sawTokenCount ? outputTokens : undefined,
+        inputTokens: sawTokenCount ? inputTokens : undefined,
+        cacheReadTokens: sawTokenCount ? cacheReadTokens : undefined,
         costUsd: sawCost ? costUsd : undefined,
+        costUsdNoCache: sawCost ? costUsdNoCache : undefined,
         durationMs,
     };
     return { meta, content: userTexts.join('\n') };
@@ -2053,13 +2080,12 @@ async function scanOpenCodeIncremental() {
 // ---------------------------------------------------------------------------
 /** Scan active OpenClaw channels and cron jobs via the openclaw CLI. */
 async function scanOpenClawIncremental() {
-    // Check if openclaw is installed — silently skip if not.
-    try {
-        await execFileAsync('which', ['openclaw']);
-    }
-    catch {
+    // Check if openclaw is installed — silently skip if not. `which` is POSIX-only
+    // (Windows resolves PATH with `where`), so a bare `which` throws ENOENT on every
+    // Windows run and silently disabled the entire OpenClaw scan there — its sessions
+    // never reached the index (RUSH-2286). hasCommand() probes cross-platform.
+    if (!hasCommand('openclaw'))
         return;
-    }
     // TTL cache: skip subprocess calls if we scanned recently. Stored in the
     // meta table so we skip even when no channels/cron exist to produce rows.
     const db = getDB();
@@ -2073,8 +2099,13 @@ async function scanOpenClawIncremental() {
     const scan = { fileMtimeMs: now, fileSize: 0 };
     const entries = [];
     try {
-        const { stdout: output } = await execFileAsync('openclaw', ['channels', 'status'], {
+        // On Windows `openclaw` resolves to a .cmd/.ps1 shim that execFile can't launch
+        // directly; execFileShellSpec composes a shell-safe invocation there and is a
+        // no-op passthrough on POSIX (RUSH-2286).
+        const channelsSpec = execFileShellSpec('openclaw', ['channels', 'status']);
+        const { stdout: output } = await execFileAsync(channelsSpec.command, channelsSpec.args, {
             encoding: 'utf-8',
+            shell: channelsSpec.shell,
         });
         for (const line of output.split('\n')) {
             const match = line.match(/^-\s+\w+\s+(\S+)\s+\((\w+)\):\s*(.+)/);
@@ -2103,8 +2134,10 @@ async function scanOpenClawIncremental() {
         /* channels command failed */
     }
     try {
-        const { stdout: output } = await execFileAsync('openclaw', ['cron', 'list'], {
+        const cronSpec = execFileShellSpec('openclaw', ['cron', 'list']);
+        const { stdout: output } = await execFileAsync(cronSpec.command, cronSpec.args, {
             encoding: 'utf-8',
+            shell: cronSpec.shell,
         });
         const lines = output.split('\n');
         for (let i = 1; i < lines.length; i++) {
@@ -2610,15 +2643,19 @@ async function readDroidMeta(filePath, currentVersion) {
     const settings = readDroidSettings(filePath.replace(/\.jsonl$/, '.settings.json'));
     const model = settings.model || scan.model;
     const tokenCount = settings.tokenCount;
-    const costUsd = model && settings.usage
-        ? costOfUsage({
+    // Droid records a full split (input / cache-read / cache-write / output) in its
+    // settings sidecar, so both the actual and no-cache cost are derivable (RUSH-2287).
+    const usageForCost = model && settings.usage
+        ? {
             model,
             inputTokens: settings.usage.inputTokens,
             outputTokens: settings.usage.outputTokens,
             cacheReadTokens: settings.usage.cacheReadTokens,
             cacheCreationTokens: settings.usage.cacheCreationTokens,
-        })
-        : 0;
+        }
+        : undefined;
+    const costUsd = usageForCost ? costOfUsage(usageForCost) : 0;
+    const costUsdNoCache = usageForCost ? costOfUsageNoCache(usageForCost) : 0;
     const stat = safeStatSync(filePath);
     const cwd = normalizeCwd(scan.cwd || '');
     const meta = {
@@ -2636,7 +2673,11 @@ async function readDroidMeta(filePath, currentVersion) {
         messageCount: scan.messageCount,
         tokenCount,
         outputTokens: settings.usage?.outputTokens,
+        inputTokens: settings.usage?.inputTokens,
+        cacheReadTokens: settings.usage?.cacheReadTokens,
+        cacheWriteTokens: settings.usage?.cacheCreationTokens,
         costUsd: costUsd > 0 ? costUsd : undefined,
+        costUsdNoCache: costUsd > 0 ? costUsdNoCache : undefined,
         durationMs: scan.durationMs,
     };
     return { meta, content: scan.contentText || '' };
@@ -2784,8 +2825,12 @@ export function initClaudeParseState() {
         toolCallCount: 0,
         tokenCount: 0,
         outputTokens: 0,
+        inputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
         sawTokenCount: false,
         costUsd: 0,
+        costUsdNoCache: 0,
         sawCost: false,
         firstTsMs: undefined,
         lastTsMs: undefined,
@@ -2982,21 +3027,34 @@ export function applyClaudeLine(state, parsed) {
     }
     if (typeof usageObj?.output_tokens === 'number')
         state.outputTokens += usageObj.output_tokens;
+    // Burn split (RUSH-2287): accumulate the raw directional counts so `agents
+    // output` can report uncached-input / cache-read / cache-write separately.
+    if (usageObj && typeof usageObj === 'object') {
+        if (typeof usageObj.input_tokens === 'number')
+            state.inputTokens += usageObj.input_tokens;
+        if (typeof usageObj.cache_read_input_tokens === 'number')
+            state.cacheReadTokens += usageObj.cache_read_input_tokens;
+        if (typeof usageObj.cache_creation_input_tokens === 'number')
+            state.cacheWriteTokens += usageObj.cache_creation_input_tokens;
+    }
     // Per-assistant-message cost: each event carries its own model, so we
     // multiply that event's raw token directions by that model's price.
     const model = parsed.message?.model;
     if (typeof model === 'string' && model)
         state.model = model;
     if (model && usageObj && typeof usageObj === 'object') {
-        const eventCost = costOfUsage({
+        const usageForCost = {
             model,
             inputTokens: usageObj.input_tokens,
             outputTokens: usageObj.output_tokens,
             cacheReadTokens: usageObj.cache_read_input_tokens,
             cacheCreationTokens: usageObj.cache_creation_input_tokens,
-        });
+        };
+        const eventCost = costOfUsage(usageForCost);
         if (eventCost > 0) {
             state.costUsd += eventCost;
+            // No-cache scenario: reprice this same event's cache tokens at the input rate.
+            state.costUsdNoCache += costOfUsageNoCache(usageForCost);
             state.sawCost = true;
         }
     }
@@ -3026,7 +3084,11 @@ export function finalizeClaudeScan(state) {
         toolCallCount: state.toolCallCount,
         tokenCount: state.sawTokenCount ? state.tokenCount : undefined,
         outputTokens: state.sawTokenCount ? state.outputTokens : undefined,
+        inputTokens: state.sawTokenCount ? state.inputTokens : undefined,
+        cacheReadTokens: state.sawTokenCount ? state.cacheReadTokens : undefined,
+        cacheWriteTokens: state.sawTokenCount ? state.cacheWriteTokens : undefined,
         costUsd: state.sawCost ? state.costUsd : undefined,
+        costUsdNoCache: state.sawCost ? state.costUsdNoCache : undefined,
         durationMs,
         lastActivity: state.lastTsMs !== undefined ? new Date(state.lastTsMs).toISOString() : undefined,
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
@@ -3082,7 +3144,7 @@ export function serializeClaudeParserState(state, offset, jsonlDroppingOversized
         : allIds;
     const ticket = detectTicket(state.userTexts.join('\n') || undefined, state.gitBranch);
     return {
-        v: 2,
+        v: 3,
         offset,
         jsonlDroppingOversizedLine: jsonlDroppingOversizedLine || undefined,
         timestamp: state.timestamp,
@@ -3101,9 +3163,13 @@ export function serializeClaudeParserState(state, offset, jsonlDroppingOversized
         toolCallCount: state.toolCallCount,
         tokenCount: state.tokenCount,
         outputTokens: state.outputTokens,
+        inputTokens: state.inputTokens,
+        cacheReadTokens: state.cacheReadTokens,
+        cacheWriteTokens: state.cacheWriteTokens,
         sawTokenCount: state.sawTokenCount,
         sawCost: state.sawCost,
         costUsd: state.costUsd,
+        costUsdNoCache: state.costUsdNoCache,
         seenIdsSize: state.seenAssistantIds.size,
         seenIdsRecent,
         sawPrCreate: state.sawPrCreate,
@@ -3163,8 +3229,12 @@ export function hydrateClaudeParseState(prior) {
         toolCallCount: prior.toolCallCount ?? 0,
         tokenCount: prior.tokenCount,
         outputTokens: prior.outputTokens,
+        inputTokens: prior.inputTokens ?? 0,
+        cacheReadTokens: prior.cacheReadTokens ?? 0,
+        cacheWriteTokens: prior.cacheWriteTokens ?? 0,
         sawTokenCount: prior.sawTokenCount,
         costUsd: prior.costUsd,
+        costUsdNoCache: prior.costUsdNoCache ?? 0,
         sawCost: prior.sawCost,
         firstTsMs: prior.firstTsMs,
         lastTsMs: prior.lastTsMs,
@@ -3313,7 +3383,7 @@ function parsePriorClaudeState(row) {
         return null;
     try {
         const parsed = JSON.parse(row.parserState);
-        if (parsed?.v !== 2 || typeof parsed.offset !== 'number' || parsed.toolCalls?.v !== 1)
+        if (parsed?.v !== 3 || typeof parsed.offset !== 'number' || parsed.toolCalls?.v !== 1)
             return null;
         return parsed;
     }
@@ -3469,17 +3539,34 @@ export function applyCodexLine(state, parsed) {
  * exact return-building {@link scanCodexSession} used to run inline.
  */
 export function finalizeCodexScan(state) {
-    // Price the final cumulative token snapshot once, against the session model.
+    // Codex reports one cumulative snapshot: uncached input, cached (cache-read)
+    // input, and output+reasoning. It has no cache-write bucket. Derive the burn
+    // split and both costs (actual + no-cache) from that final snapshot (RUSH-2287).
+    const snap = state.lastTotalTokenUsage;
+    const outputTokens = snap
+        ? (snap.output_tokens ?? 0) + (snap.reasoning_output_tokens ?? 0)
+        : undefined;
     let costUsd;
-    if (state.model && state.lastTotalTokenUsage) {
-        const c = costOfUsage({
+    let costUsdNoCache;
+    let inputTokens;
+    let cacheReadTokens;
+    if (snap) {
+        inputTokens = typeof snap.input_tokens === 'number' ? snap.input_tokens : undefined;
+        cacheReadTokens = typeof snap.cached_input_tokens === 'number' ? snap.cached_input_tokens : undefined;
+    }
+    // Price the final cumulative token snapshot once, against the session model.
+    if (state.model && snap) {
+        const usage = {
             model: state.model,
-            inputTokens: state.lastTotalTokenUsage.input_tokens,
-            outputTokens: (state.lastTotalTokenUsage.output_tokens ?? 0) + (state.lastTotalTokenUsage.reasoning_output_tokens ?? 0),
-            cacheReadTokens: state.lastTotalTokenUsage.cached_input_tokens,
-        });
-        if (c > 0)
+            inputTokens: snap.input_tokens,
+            outputTokens,
+            cacheReadTokens: snap.cached_input_tokens,
+        };
+        const c = costOfUsage(usage);
+        if (c > 0) {
             costUsd = c;
+            costUsdNoCache = costOfUsageNoCache(usage);
+        }
     }
     const durationMs = state.firstTsMs !== undefined && state.lastTsMs !== undefined && state.lastTsMs > state.firstTsMs
         ? state.lastTsMs - state.firstTsMs
@@ -3496,10 +3583,12 @@ export function finalizeCodexScan(state) {
         topic: state.topic,
         messageCount: state.messageCount,
         tokenCount: state.tokenCount,
-        outputTokens: state.lastTotalTokenUsage
-            ? (state.lastTotalTokenUsage.output_tokens ?? 0) + (state.lastTotalTokenUsage.reasoning_output_tokens ?? 0)
-            : undefined,
+        outputTokens,
+        inputTokens,
+        cacheReadTokens,
+        cacheWriteTokens: undefined,
         costUsd,
+        costUsdNoCache,
         durationMs,
         lastActivity: state.lastTsMs !== undefined ? new Date(state.lastTsMs).toISOString() : undefined,
         contentText: state.userTexts.length > 0 ? state.userTexts.join('\n') : undefined,
@@ -4457,10 +4546,13 @@ export function readGrokMeta(filePath, currentVersion) {
             ? summary.num_messages
             : undefined;
     // Grok records its managed home in summary.grok_home
-    // (…/versions/grok/<version>/home/.grok) — recover the version from it.
+    // (…/versions/grok/<version>/home/.grok) — recover the version from it. The
+    // value is written by the Grok CLI in the writing host's native separators, so
+    // a Windows-authored summary is backslash-separated; normalize to `/` before
+    // matching or the version never resolves on Windows (RUSH-2286).
     let embeddedVersion;
     if (typeof summary?.grok_home === 'string') {
-        embeddedVersion = summary.grok_home.match(/versions\/grok\/([^/]+)\//)?.[1];
+        embeddedVersion = summary.grok_home.replace(/\\/g, '/').match(/versions\/grok\/([^/]+)\//)?.[1];
     }
     const meta = {
         id: sessionId,