@phnx-labs/agents-cli 1.22.25 → 1.22.27

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';
@@ -877,6 +879,7 @@ async function scanRoutineArchivesIncremental(agent, onProgress) {
                     meta: result.meta,
                     content: result.content,
                     scan,
+                    events: result.events,
                     toolCalls: result.toolCalls,
                     toolIndexMode: result.toolIndexMode,
                 });
@@ -1095,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,
@@ -1129,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,
@@ -1437,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,
@@ -1575,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;
@@ -1621,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;
             }
         }
@@ -1658,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') };
@@ -1756,7 +1784,7 @@ async function scanAntigravityIncremental(onProgress) {
             const result = readAntigravityMeta(filePath, currentVersion);
             if (result && !seen.has(result.meta.id)) {
                 seen.add(result.meta.id);
-                entries.push({ meta: result.meta, content: result.content, scan });
+                entries.push({ meta: result.meta, content: result.content, scan, events: result.events });
             }
             else {
                 touched.push({ filePath, scan });
@@ -1802,23 +1830,28 @@ function readAntigravityMeta(filePath, currentVersion) {
         topic: topic ? topic.slice(0, 120) : undefined,
         messageCount: events.length,
     };
-    return { meta, content: contentParts.join('\n') };
+    return { meta, content: contentParts.join('\n'), events };
 }
 // ---------------------------------------------------------------------------
 // OpenCode
 // ---------------------------------------------------------------------------
 const OPENCODE_DB = path.join(HOME, '.local', 'share', 'opencode', 'opencode.db');
 let cachedOpenCodeAccount;
-/** Query the active OpenCode account email from its SQLite database. */
-async function getOpenCodeAccount() {
+/**
+ * Query the active OpenCode account email from its SQLite database.
+ *
+ * Takes the scan's already-open handle so a scan opens `opencode.db` exactly
+ * once (RUSH-2210); opens its own only when called without one.
+ */
+function getOpenCodeAccount(handle) {
     if (cachedOpenCodeAccount !== undefined)
         return cachedOpenCodeAccount || undefined;
     // Read through the node/bun SQLite wrapper (not the `sqlite3` CLI) so this
     // works on every OS — the CLI is absent on Windows.
-    let db;
+    let owned;
     try {
-        if (fs.existsSync(OPENCODE_DB)) {
-            db = new Database(OPENCODE_DB);
+        const db = handle ?? (fs.existsSync(OPENCODE_DB) ? (owned = new Database(OPENCODE_DB)) : undefined);
+        if (db) {
             const row = db
                 .prepare('SELECT email FROM control_account WHERE active=1 LIMIT 1;')
                 .get();
@@ -1832,13 +1865,63 @@ async function getOpenCodeAccount() {
     catch { /* DB not accessible, sqlite module unavailable, or query failed */ }
     finally {
         try {
-            db?.close();
+            owned?.close();
         }
         catch { /* best-effort close */ }
     }
     cachedOpenCodeAccount = '';
     return undefined;
 }
+/**
+ * The per-session ledger stamp for an OpenCode row: the newest write time across
+ * the session's own row, its messages, and its parts, paired with the total byte
+ * length of that session's message + part payloads.
+ *
+ * OpenCode keeps every session in ONE shared SQLite file, so that file's
+ * mtime/size changes whenever *any* session is written. Stamping each session
+ * with the whole-DB stat therefore invalidated every indexed session on every
+ * scan: up to `LIMIT 1000` sessions were re-emitted into `upsertSessionsBatch`,
+ * and its enrichment step re-opened `opencode.db` once per re-emitted entry via
+ * `parseSession` (RUSH-2210).
+ *
+ * `s.time_updated` alone is NOT that session's change signal, which is the trap
+ * this shape exists to avoid. On a real database, parts land long after the
+ * session row was last touched — e.g. `ses_3955202dfffe…` carried
+ * `time_updated = 1771316403087` with its newest part at `1771331512162`, over
+ * four hours later. So the stamp maxes `time_updated` with the newest message
+ * and part times, and pairs it with a byte total that also moves when an
+ * existing part's `data` is rewritten in place (a streaming turn) without any
+ * new row or timestamp.
+ *
+ * The byte total is a REAL size, not a repurposed counter, because
+ * `sessions.file_size` is read back as bytes elsewhere: `ensureToolIndex` uses
+ * it as the tool-backfill byte budget and `toolCallsForBackfill` as the 16 MiB
+ * in-memory parser cap (`tool-index.ts`). A message/part byte total is the
+ * honest cost of parsing that session — strictly better than the whole-DB size
+ * this column used to hold for every OpenCode row.
+ *
+ * The size is `LENGTH(CAST(data AS BLOB))`, not `LENGTH(data)`: SQLite's
+ * `LENGTH()` on a TEXT column counts CHARACTERS, so a CJK/emoji-heavy transcript
+ * would under-report its real size by up to 4x — and this number is a byte
+ * budget downstream.
+ *
+ * A degenerate row — nothing but zeros/NaN for every time AND no payload at all
+ * — falls back to the whole-DB stat, keeping the pre-RUSH-2210 always-rescan
+ * behavior for exactly those rows rather than pinning them to a stamp that never
+ * changes.
+ */
+function openCodeSessionStamp(times, bytes, dbScan) {
+    // A positive time, not merely a finite one: the SQL COALESCEs the aggregates
+    // to 0, so `Number.isFinite` alone would accept a row that told us nothing and
+    // this branch could never fire.
+    const known = [times.timeUpdated, times.lastMessageAt, times.lastPartAt, times.timeCreated]
+        .filter(t => Number.isFinite(t) && t > 0);
+    const size = (Number.isFinite(bytes.messageBytes) ? bytes.messageBytes : 0)
+        + (Number.isFinite(bytes.partBytes) ? bytes.partBytes : 0);
+    if (known.length === 0 && size === 0)
+        return dbScan;
+    return { fileMtimeMs: known.length === 0 ? 0 : Math.floor(Math.max(...known)), fileSize: size };
+}
 /** Scan OpenCode sessions from its SQLite database when the DB file has changed. */
 async function scanOpenCodeIncremental() {
     if (!fs.existsSync(OPENCODE_DB))
@@ -1846,8 +1929,9 @@ async function scanOpenCodeIncremental() {
     const stat = safeStatSync(OPENCODE_DB);
     if (!stat)
         return;
-    // OpenCode is one big DB; we use its mtime/size as the ledger for the
-    // entire fleet of OpenCode sessions.
+    // OpenCode is one big DB. Its mtime/size is the cheap "did ANYTHING change"
+    // short-circuit for the whole harness — not the per-session stamp, which each
+    // row carries itself (see openCodeSessionStamp, RUSH-2210).
     const currentScan = {
         fileMtimeMs: Math.floor(stat.mtimeMs),
         fileSize: stat.size,
@@ -1856,7 +1940,6 @@ async function scanOpenCodeIncremental() {
     if (prev && prev.fileMtimeMs === currentScan.fileMtimeMs && prev.fileSize === currentScan.fileSize) {
         return;
     }
-    const account = await getOpenCodeAccount();
     const currentVersion = await getCurrentAgentVersion('opencode');
     // Read through the node/bun SQLite wrapper (not the `sqlite3` CLI) so this
     // works on every OS — the CLI is absent on Windows.
@@ -1871,14 +1954,28 @@ async function scanOpenCodeIncremental() {
         s.time_created AS time_created,
         s.time_updated AS time_updated,
         COALESCE(stats.message_count, 0) AS message_count,
+        COALESCE(stats.last_message_at, 0) AS last_message_at,
+        COALESCE(stats.message_bytes, 0) AS message_bytes,
+        COALESCE(parts.last_part_at, 0) AS last_part_at,
+        COALESCE(parts.part_bytes, 0) AS part_bytes,
         stats.token_count AS token_count,
         stats.output_tokens AS output_tokens,
         COALESCE(stats.has_token_data, 0) AS has_token_data
       FROM session s
+      LEFT JOIN (
+        SELECT
+          session_id,
+          MAX(time_created) AS last_part_at,
+          SUM(LENGTH(CAST(data AS BLOB))) AS part_bytes
+        FROM part
+        GROUP BY session_id
+      ) parts ON parts.session_id = s.id
       LEFT JOIN (
         SELECT
           session_id,
           COUNT(*) AS message_count,
+          MAX(time_created) AS last_message_at,
+          SUM(LENGTH(CAST(data AS BLOB))) AS message_bytes,
           SUM(
             COALESCE(json_extract(data, '$.tokens.input'), 0) +
             COALESCE(json_extract(data, '$.tokens.output'), 0) +
@@ -1896,16 +1993,42 @@ async function scanOpenCodeIncremental() {
       LIMIT 1000;
     `.replace(/\n/g, ' ');
         db = new Database(OPENCODE_DB);
+        const account = getOpenCodeAccount(db);
         const rows = db.prepare(query).all();
-        const entries = [];
-        for (const row of rows) {
+        // Two passes. First derive each row's identity + per-session stamp, then
+        // bulk-load the prior stamps in ONE query and keep only the rows that
+        // actually changed. Skipped rows never reach upsertSessionsBatch, so they
+        // never pay its per-entry `parseSession` re-open of this same DB.
+        const asInt = (v) => typeof v === 'number' ? v : parseInt(String(v), 10);
+        const candidates = rows.flatMap(row => {
             const id = typeof row.id === 'string' ? row.id : '';
             if (!id)
-                continue;
+                return [];
+            const filePath = `${OPENCODE_DB}#${id}`;
+            return [{
+                    row,
+                    id,
+                    filePath,
+                    scan: openCodeSessionStamp({
+                        timeUpdated: asInt(row.time_updated),
+                        timeCreated: asInt(row.time_created),
+                        lastMessageAt: asInt(row.last_message_at),
+                        lastPartAt: asInt(row.last_part_at),
+                    }, { messageBytes: asInt(row.message_bytes), partBytes: asInt(row.part_bytes) }, currentScan),
+                }];
+        });
+        const priorStamps = getScanStampsForPaths(candidates.map(c => c.filePath));
+        const changed = candidates.filter(c => {
+            const prevStamp = priorStamps.get(c.filePath);
+            return !prevStamp
+                || prevStamp.fileMtimeMs !== c.scan.fileMtimeMs
+                || prevStamp.fileSize !== c.scan.fileSize;
+        });
+        const entries = [];
+        for (const { row, id, filePath, scan } of changed) {
             const title = typeof row.title === 'string' ? row.title : '';
             const directory = typeof row.directory === 'string' ? row.directory : '';
             const version = typeof row.version === 'string' ? row.version : '';
-            const asInt = (v) => typeof v === 'number' ? v : parseInt(String(v), 10);
             const timeCreated = asInt(row.time_created);
             const timeUpdated = asInt(row.time_updated);
             const messageCount = asInt(row.message_count);
@@ -1926,7 +2049,7 @@ async function scanOpenCodeIncremental() {
                 lastActivity,
                 project: directory ? path.basename(directory) : undefined,
                 cwd: directory ? normalizeCwd(directory) : undefined,
-                filePath: `${OPENCODE_DB}#${id}`,
+                filePath,
                 version: resolveSessionVersion('opencode', OPENCODE_DB, version || undefined, currentVersion),
                 account,
                 topic,
@@ -1934,7 +2057,7 @@ async function scanOpenCodeIncremental() {
                 tokenCount: hasTokenData && !Number.isNaN(tokenCount) ? tokenCount : undefined,
                 outputTokens: hasTokenData && !Number.isNaN(outputTokens) ? outputTokens : undefined,
             };
-            entries.push({ meta, content: topic || '', scan: currentScan });
+            entries.push({ meta, content: topic || '', scan });
         }
         upsertSessionsBatch(entries);
         // Stamp the OpenCode DB itself so we can short-circuit on the next run.
@@ -1957,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();
@@ -1977,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*(.+)/);
@@ -2007,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++) {
@@ -2514,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 = {
@@ -2540,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 || '' };
@@ -2688,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,
@@ -2886,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;
         }
     }
@@ -2930,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,
@@ -2986,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,
@@ -3005,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,
@@ -3067,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,
@@ -3217,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;
     }
@@ -3373,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
@@ -3400,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,
@@ -3902,7 +4087,7 @@ async function scanCursorIncremental(onProgress) {
             const result = readCursorMeta(filePath, currentVersion);
             if (result && !seen.has(result.meta.id)) {
                 seen.add(result.meta.id);
-                entries.push({ meta: result.meta, content: result.content, scan });
+                entries.push({ meta: result.meta, content: result.content, scan, events: result.events });
             }
             else {
                 touched.push({ filePath, scan });
@@ -3998,7 +4183,7 @@ export function readCursorMeta(filePath, currentVersion) {
         messageCount: events.filter((event) => event.type === 'message').length,
         todos: extractTodoProgressFromEvents(events),
     };
-    return { meta, content: userTexts.join('\n') };
+    return { meta, content: userTexts.join('\n'), events };
 }
 // ---------------------------------------------------------------------------
 // Kimi
@@ -4361,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,