@phnx-labs/agents-cli 1.22.25 → 1.22.27

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

@@ -7,12 +7,12 @@
  * BM25 ranking, and label-first search for /rename'd sessions.
  */
 import Database from '../sqlite.js';
-import type { SessionAgentId, SessionMeta } from './types.js';
+import type { SessionAgentId, SessionEvent, SessionMeta } from './types.js';
 import { type IndexedToolCall } from './tool-calls.js';
 /** 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 declare const SCHEMA_VERSION = 34;
+export declare 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
@@ -26,7 +26,8 @@ export declare const RESOURCE_INDEX_VERSION = 1;
  * re-derives on the next `agents insights` instead of silently reporting stale
  * numbers alongside fresh ones. Same role as RESOURCE_INDEX_VERSION.
  */
-export declare const INSIGHTS_EXTRACTOR_VERSION = 3;
+/** Bump when facet extraction changes so cached rows recompute (stalls-by-model v6). */
+export declare const INSIGHTS_EXTRACTOR_VERSION = 6;
 /** Raw row shape returned from the sessions table. */
 export interface SessionRow {
     id: string;
@@ -50,7 +51,11 @@ export interface SessionRow {
     message_count: number | null;
     token_count: number | null;
     output_tokens: number | null;
+    input_tokens: number | null;
+    cache_read_tokens: number | null;
+    cache_write_tokens: number | null;
     cost_usd: number | null;
+    cost_usd_nocache: number | null;
     duration_ms: number | null;
     model: string | null;
     tool_call_count: number | null;
@@ -149,6 +154,23 @@ export interface FtsOptimizeResult {
  * the DB file; run VACUUM (with the daemon stopped) to return it to the OS.
  */
 export declare function optimizeSessionSearchIndex(): FtsOptimizeResult[];
+/**
+ * Keep the FTS indexes from degrading on the normal scan path.
+ *
+ * `optimizeSessionSearchIndex` is the full, unbounded compaction behind
+ * `agents sessions optimize`. Leaving it as the ONLY compaction meant the index
+ * degraded until a human happened to run that command, which is how
+ * `tool_call_text_data` reached gigabytes for tens of MB of content. This is the
+ * automatic counterpart: bounded, threshold-gated, and safe to call after every
+ * batch of writes. Non-destructive — merging never changes what is searchable.
+ *
+ * Returns one result per table it actually merged (empty when every table is
+ * under the threshold, which is the common case on a warm index).
+ */
+export declare function maintainSessionSearchIndex(db?: Database.Database, options?: {
+    segmentThreshold?: number;
+    mergePages?: number;
+}): FtsOptimizeResult[];
 /**
  * Try to claim the right to run the incremental scan. Returns true if this
  * process should proceed with scanning, false if another live process is
@@ -245,6 +267,7 @@ export declare function upsertSessionsBatch(entries: Array<{
     scan?: ScanStamp;
     parserState?: string;
     contentText?: string;
+    events?: SessionEvent[];
     toolCalls?: IndexedToolCall[];
     toolScan?: ScanStamp;
     toolIndexMode?: 'replace' | 'append';
@@ -317,11 +340,23 @@ export interface UsageRollupRow {
      */
     label?: string;
     costUsd: number;
+    /**
+     * USD cost priced as if caching were off (cache read/write at the input rate),
+     * summed from `cost_usd_nocache`. Backs `agents output --pricing no-cache`.
+     * Equals `costUsd` for rows whose sessions record no cache split (RUSH-2287).
+     */
+    costUsdNoCache: number;
     durationMs: number;
     sessionCount: number;
     tokenCount: number;
     /** Real generated (output) tokens — excludes cache-read/-write context. */
     outputTokens: number;
+    /** Uncached input tokens summed across the group (0 where no harness recorded a split). */
+    inputTokens: number;
+    /** Cache-read tokens summed across the group. */
+    cacheReadTokens: number;
+    /** Cache-write (cache-creation) tokens summed across the group. */
+    cacheWriteTokens: number;
 }
 /** What to group a usage rollup by. */
 /**

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 = 34;
+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,
@@ -204,6 +208,12 @@ CREATE TABLE IF NOT EXISTS tool_program_occurrences (
 CREATE INDEX IF NOT EXISTS idx_tool_program_occurrences_program
   ON tool_program_occurrences(program, call_key);
 
+-- Derived search index over tool_calls. call_key is UNINDEXED -- it is carried
+-- for display, NOT for lookup: an FTS5 table has no index on an ordinary column,
+-- so DELETE ... WHERE call_key = ? scans the whole index once per call, which is
+-- quadratic in a session's call count. Every write here therefore addresses a
+-- row by rowid, mirroring the tool_calls.rowid of the call it describes, so a
+-- delete is a single rowid seek (tool-store.ts persistToolCalls/deleteSessionCalls).
 CREATE VIRTUAL TABLE IF NOT EXISTS tool_call_text USING fts5(
   call_key UNINDEXED,
   tool,
@@ -224,7 +234,15 @@ CREATE TABLE IF NOT EXISTS tool_scan_ledger (
   extractor_version INTEGER NOT NULL,
   indexed_at INTEGER NOT NULL,
   call_count INTEGER NOT NULL,
-  evidence_bytes INTEGER NOT NULL
+  evidence_bytes INTEGER NOT NULL,
+  -- Resume point for the incremental tool scan. parsed_offset is the byte
+  -- offset just past the last COMPLETE newline-terminated record consumed, and
+  -- parser_state is the serialized ToolCallCollector snapshot at that offset
+  -- (next ordinal + still-unresolved calls). Together they let the next scan of
+  -- a session that only grew read the appended bytes instead of the whole file.
+  -- NULL means "no resume point" — the next scan re-reads from byte 0.
+  parser_state TEXT,
+  parsed_offset INTEGER
 );
 
 -- Skill/slash-command usage per session (#12), computed from a session's
@@ -294,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 = 3;
+/** 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
@@ -810,6 +829,76 @@ function migrateSchema(db, fromVersion) {
       );
     `);
     }
+    if (fromVersion < 35) {
+        // v34 -> v35: the default listing sort was `ORDER BY IFNULL(last_activity,
+        // timestamp) DESC` — wrapping the column in IFNULL() makes SQLite unable to
+        // satisfy it from idx_sessions_last_activity, so every list/resume query did
+        // a full table sort instead of an index walk (RUSH-2211). Every upsert path
+        // already writes a non-NULL last_activity (resolveLastActivity falls back to
+        // `timestamp`, itself NOT NULL) — the only rows that can still be NULL here
+        // are ones written before the v8 migration that somehow slipped the backfill,
+        // or seeded directly by a test. Backfill them so the column is unconditionally
+        // NOT NULL, then querySessions can sort on the bare column and use the index.
+        db.exec(`UPDATE sessions SET last_activity = timestamp WHERE last_activity IS NULL`);
+    }
+    if (fromVersion < 36) {
+        // v35 -> v36: make the tool index incremental, and stop paying a full FTS
+        // scan per deleted call.
+        //
+        // (a) tool_scan_ledger gains a resume point (parser_state + parsed_offset).
+        //     Existing rows get NULLs, which read as "no resume point": the next
+        //     scan of each session re-reads it once from byte 0 and records a resume
+        //     point, so every scan after that is incremental. No ledger is wiped.
+        //
+        // (b) tool_call_text is rebuilt so its rowid mirrors tool_calls.rowid. The
+        //     old rows were inserted with FTS5-assigned rowids and are only
+        //     addressable by the UNINDEXED call_key, i.e. a full index scan per
+        //     delete. There is no ALTER for that, and the rowids cannot be repaired
+        //     in place, so the table is dropped and repopulated from tool_calls --
+        //     the same non-destructive derived-table rebuild v27 did (the source of
+        //     truth is tool_calls, which is untouched). The rebuild also lands the
+        //     content as one merged segment, which is the compaction
+        //     optimizeSessionSearchIndex would otherwise have to do afterwards.
+        const ledgerCols = new Set(db.prepare(`PRAGMA table_info(tool_scan_ledger)`).all()
+            .map((column) => column.name));
+        if (!ledgerCols.has('parser_state'))
+            db.exec(`ALTER TABLE tool_scan_ledger ADD COLUMN parser_state TEXT`);
+        if (!ledgerCols.has('parsed_offset'))
+            db.exec(`ALTER TABLE tool_scan_ledger ADD COLUMN parsed_offset INTEGER`);
+        db.exec(`
+      DROP TABLE IF EXISTS tool_call_text;
+      CREATE VIRTUAL TABLE tool_call_text USING fts5(
+        call_key UNINDEXED,
+        tool,
+        input,
+        output,
+        error,
+        tokenize = 'trigram'
+      );
+      INSERT INTO tool_call_text (rowid, call_key, tool, input, output, error)
+      SELECT rowid, call_key, tool, input, coalesce(output, ''), coalesce(error, '')
+      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
@@ -988,6 +1077,49 @@ export function optimizeSessionSearchIndex() {
         return { table, segmentsBefore, segmentsAfter: segments(table) };
     });
 }
+/**
+ * Segment count above which a scan pays for a slice of merge work. Below it the
+ * index is small enough that querying it is not the bottleneck and merging is
+ * pure overhead on every scan.
+ */
+const FTS_MAINTENANCE_SEGMENT_THRESHOLD = 512;
+/**
+ * Page budget for one incremental merge. FTS5's `'merge'` command does at most
+ * this much work and returns — it is not `'optimize'`, which merges the whole
+ * index in one unbounded pass. That bound is why this can run on the scan path:
+ * the cost per scan is fixed, and repeated scans converge the index instead of
+ * one scan stalling on a multi-gigabyte compaction.
+ */
+const FTS_MAINTENANCE_MERGE_PAGES = 64;
+/**
+ * Keep the FTS indexes from degrading on the normal scan path.
+ *
+ * `optimizeSessionSearchIndex` is the full, unbounded compaction behind
+ * `agents sessions optimize`. Leaving it as the ONLY compaction meant the index
+ * degraded until a human happened to run that command, which is how
+ * `tool_call_text_data` reached gigabytes for tens of MB of content. This is the
+ * automatic counterpart: bounded, threshold-gated, and safe to call after every
+ * batch of writes. Non-destructive — merging never changes what is searchable.
+ *
+ * Returns one result per table it actually merged (empty when every table is
+ * under the threshold, which is the common case on a warm index).
+ */
+export function maintainSessionSearchIndex(db = getDB(), options = {}) {
+    const threshold = options.segmentThreshold ?? FTS_MAINTENANCE_SEGMENT_THRESHOLD;
+    const pages = options.mergePages ?? FTS_MAINTENANCE_MERGE_PAGES;
+    // Hardcoded literals — never interpolate caller input into an identifier.
+    const tables = ['tool_call_text', 'session_text'];
+    const segments = (table) => db.prepare(`SELECT count(*) AS n FROM ${table}_data`).get().n;
+    const results = [];
+    for (const table of tables) {
+        const segmentsBefore = segments(table);
+        if (segmentsBefore < threshold)
+            continue;
+        db.prepare(`INSERT INTO ${table}(${table}, rank) VALUES('merge', ?)`).run(pages);
+        results.push({ table, segmentsBefore, segmentsAfter: segments(table) });
+    }
+    return results;
+}
 // ---------------------------------------------------------------------------
 // Scan coordinator — prevents concurrent full scans across processes
 // ---------------------------------------------------------------------------
@@ -1261,7 +1393,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,
@@ -1270,7 +1403,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,
@@ -1305,7 +1439,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,
@@ -1544,7 +1682,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,
@@ -1627,9 +1769,10 @@ export function upsertSessionsBatch(entries) {
                     const stat = fs.statSync(toolSourcePath);
                     return { fileMtimeMs: stat.mtimeMs, fileSize: stat.size };
                 })();
-            // Non-resumable harnesses already parse here for todos/recent dirs. Derive
-            // the tool index from those same in-memory events: no second file read.
-            const events = parseSession(entry.meta.filePath, entry.meta.agent);
+            // Some non-resumable scanners already normalized the transcript while
+            // deriving metadata. Reuse those events; scanners that only read summary
+            // metadata fall back to exactly one normalized parse here.
+            const events = entry.events ?? parseSession(entry.meta.filePath, entry.meta.agent);
             writeResourceUsage(entry.meta.id, events, entry.meta.cwd);
             return {
                 ...entry,
@@ -1640,6 +1783,8 @@ export function upsertSessionsBatch(entries) {
                 },
                 toolCalls: toolCallsFromEvents(events),
                 toolScan,
+                // These are complete event arrays, not an appended tail. Append would
+                // duplicate existing evidence even when persistToolCalls supports it.
                 toolIndexMode: 'replace',
             };
         }
@@ -1721,7 +1866,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,
@@ -1773,12 +1922,18 @@ export function upsertSessionsBatch(entries) {
         if (!toolScan || !entry.toolCalls)
             continue;
         try {
-            persistToolCalls(db, entry.meta, entry.toolCalls, toolScan, entry.toolIndexMode ?? 'replace');
+            persistToolCalls(db, entry.meta, entry.toolCalls, toolScan, { mode: entry.toolIndexMode ?? 'replace' });
         }
         catch {
             // Boundary is intentionally retryable via tool_scan_ledger.
         }
     }
+    // Every batch appends FTS segments (session_text always, tool_call_text for the
+    // harnesses indexed above). Pay a bounded slice of the merge here so the
+    // scan path keeps its own index healthy instead of leaving all compaction to
+    // the manual `agents sessions optimize` (RUSH-2208). Threshold-gated, so a
+    // small index costs two counts and nothing else.
+    maintainSessionSearchIndex(db);
 }
 /**
  * Sync labels for a set of sessions. For each id in the map, if the stored
@@ -1929,7 +2084,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,
@@ -2118,6 +2277,51 @@ 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).
+ */
+function findMissingFilePaths(filePaths) {
+    const byDir = new Map();
+    for (const p of filePaths) {
+        const dir = path.dirname(p);
+        let basenames = byDir.get(dir);
+        if (!basenames) {
+            basenames = new Set();
+            byDir.set(dir, basenames);
+        }
+        basenames.add(path.basename(p));
+    }
+    const missing = new Set();
+    for (const [dir, basenames] of byDir) {
+        let entries;
+        try {
+            entries = new Set(fs.readdirSync(dir));
+        }
+        catch {
+            // 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));
+            }
+            continue;
+        }
+        for (const base of basenames) {
+            if (!entries.has(base))
+                missing.add(path.join(dir, base));
+        }
+    }
+    return missing;
+}
 /** Query sessions from the database, applying filters and ordering by last-activity descending (default). */
 export function querySessions(options = {}) {
     const db = getDB();
@@ -2130,11 +2334,18 @@ export function querySessions(options = {}) {
         : '';
     // NULLs last so unpriced / duration-less rows never crowd out real data when
     // sorting by cost or duration. timestamp is never null (NOT NULL column).
+    // Default sort is the bare `last_activity` column, not `IFNULL(last_activity,
+    // timestamp)` — the v35 migration backfills every row so last_activity is
+    // never NULL, and every upsert path (resolveLastActivity) keeps it that way
+    // going forward. Wrapping the column in IFNULL() defeats
+    // idx_sessions_last_activity (SQLite can't use an index on an expression that
+    // isn't the bare column); the bare column lets the planner walk the index
+    // instead of sorting the whole result set (RUSH-2211).
     const orderClause = options.sortBy === 'cost'
         ? 'ORDER BY cost_usd IS NULL, cost_usd DESC, timestamp DESC'
         : options.sortBy === 'duration'
             ? 'ORDER BY duration_ms IS NULL, duration_ms DESC, timestamp DESC'
-            : 'ORDER BY IFNULL(last_activity, timestamp) DESC, timestamp DESC';
+            : 'ORDER BY last_activity DESC, timestamp DESC';
     const sql = `SELECT * FROM sessions ${clause} ${orderClause} ${limitClause}`;
     const rows = db.prepare(sql).all(...params);
     if (options.skipExistenceCheck) {
@@ -2147,7 +2358,8 @@ export function querySessions(options = {}) {
     // surfacing in the Factory UI if any code path forgets to rewrite (#136).
     // Synthetic rows (OpenClaw channels/cron — see scanOpenClawIncremental) carry
     // an empty file_path and are exempt; they're keyed by CLI output, not files.
-    const missing = rows.filter(r => r.file_path && !fs.existsSync(r.file_path));
+    const missingPaths = findMissingFilePaths(rows.map(r => r.file_path).filter((p) => !!p));
+    const missing = rows.filter(r => r.file_path && missingPaths.has(r.file_path));
     if (missing.length > 0) {
         const purge = db.transaction(() => {
             for (const row of missing)
@@ -2324,10 +2536,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
@@ -2628,6 +2847,20 @@ export function buildFtsQuery(input) {
     const expr = terms.map(t => `${t}*`).join(' OR ');
     return { expr, terms };
 }
+/**
+ * Build a `label:(...)` FTS5 column-filter MATCH expression for the label
+ * tier. Unlike `buildFtsQuery` (2-char floor, tuned for full-content search),
+ * this allows 1-char terms: label search is the interactive type-ahead path —
+ * the query grows one keystroke at a time, so a single character has to be
+ * indexable too. Terms are filtered to `[a-z0-9]` before being embedded in the
+ * expression string, so there's no FTS5 syntax injection from user input.
+ */
+function buildLabelFtsQuery(input) {
+    const terms = input.toLowerCase().split(/[^a-z0-9]+/).filter(t => t.length >= 1);
+    if (terms.length === 0)
+        return '';
+    return `label:(${terms.map(t => `${t}*`).join(' OR ')})`;
+}
 /**
  * Label-first search. Sessions whose custom label substring-matches the query
  * always rank ahead of FTS5 hits — this gives predictable behavior when a user
@@ -2655,10 +2888,34 @@ export function ftsSearch(input, limit = 200) {
     // its `label` — set by an agent title / `/rename`, or seeded at launch from
     // `agents run --name`. Typing it resolves the session ahead of any FTS content
     // hit.
-    const labelRows = db.prepare(`
-    SELECT id, label FROM sessions
-    WHERE label IS NOT NULL AND LOWER(label) LIKE ?
-  `).all(`%${lower}%`);
+    //
+    // Candidates come from the FTS5 `label` column, not a raw `LOWER(label) LIKE
+    // '%q%'` scan of `sessions`: a leading wildcard can't use any index, so on a
+    // large session table that was a full-table scan on every keystroke of
+    // interactive search (RUSH-2211). `session_text.label` is kept 1:1 with
+    // `sessions.label` by every upsert path (storedFtsLabel), so this is the
+    // same data, indexed. Token-prefix matching seeks the FTS index instead of
+    // scanning every row, at the cost of only matching at token boundaries — a
+    // substring inside a single token (e.g. "ckf" inside "quickfix") no longer
+    // matches, since FTS5 only indexes prefixes of whole tokens, not arbitrary
+    // interior slices. (A slice spanning a token boundary, like "ix-b" inside
+    // "fix-bug", still matches: "ix-b" tokenizes to "ix" + "b", and "b" is a
+    // valid prefix of the "bug" token.) That's the accepted trade-off for an
+    // indexable interactive path; the exact/prefix/contains scoring below still
+    // runs in JS over the FTS candidate set, so ranking among real matches is
+    // unchanged. Only a query with no indexable token (rare — e.g.
+    // punctuation-only input) falls back to the direct scan rather than
+    // silently dropping the tier.
+    const labelMatchExpr = buildLabelFtsQuery(input);
+    const labelRows = labelMatchExpr
+        ? db.prepare(`
+        SELECT session_id AS id, label FROM session_text
+        WHERE session_text MATCH ?
+      `).all(labelMatchExpr)
+        : db.prepare(`
+        SELECT id, label FROM sessions
+        WHERE label IS NOT NULL AND LOWER(label) LIKE ?
+      `).all(`%${lower}%`);
     let hasExactLabelMatch = false;
     for (const row of labelRows) {
         // Score the label by match quality (exact > prefix > contains).

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;
@@ -690,6 +710,7 @@ export declare function __resetCodexScanBranchCountsForTest(): void;
 export declare function readCursorMeta(filePath: string, currentVersion?: string): {
     meta: SessionMeta;
     content: string;
+    events: SessionEvent[];
 } | null;
 /** Parse a single Kimi session state.json file to extract session metadata. */
 export declare function readKimiMeta(filePath: string, priorRow?: {