@phnx-labs/agents-cli 1.22.24 → 1.22.26

package/dist/lib/session/db.js

@@ -12,7 +12,7 @@ import Database from '../sqlite.js';
 import { parseSession } from './parse.js';
 import { extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { getSessionsDir, getSessionsDbPath } from '../state.js';
-import { query as queryEvents } from '../events.js';
+import { query as queryEvents, queryToolUsageForSessions } from '../events.js';
 import { machineForSessionFile } from './origin-machine.js';
 import { loadSessionActorIndex, readSessionActorRecord } from './actor-sidecar.js';
 import { toolCallsFromEvents } from './tool-calls.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 = 36;
 /**
  * Bump to force `agents sessions backfill resources` to re-derive every
  * session's skill/slash-command tallies on its next run (resource_scan_ledger
@@ -204,6 +204,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 +230,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 +308,7 @@ 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;
+export const INSIGHTS_EXTRACTOR_VERSION = 4;
 let dbInstance = null;
 /**
  * Apply schema migrations from `fromVersion` → SCHEMA_VERSION. The new
@@ -810,6 +824,57 @@ 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;
+    `);
+    }
 }
 /**
  * Stamp `account_key` / `account_org` / `account` on every Claude row from its
@@ -988,6 +1053,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
 // ---------------------------------------------------------------------------
@@ -1627,9 +1735,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 +1749,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',
             };
         }
@@ -1648,6 +1759,12 @@ export function upsertSessionsBatch(entries) {
         }
     });
     const writtenEntries = [];
+    // Pre-compute browser/computer usage for all sessions outside the write
+    // transaction. detectToolUsage scans all event log files (O(files) I/O
+    // per call) and holding the SQLite write lock during that scan is what
+    // causes the "DB locked" errors (RUSH-2006). One pass for the whole batch
+    // costs O(files) total instead of O(N × files) inside the lock.
+    const toolUsageBySession = queryToolUsageForSessions(new Set(enrichedEntries.map(e => e.meta.id)));
     const txn = db.transaction((items) => {
         // Re-read the ledger now that we hold the write lock. Any file committed
         // by a concurrent process since our pre-scan is visible here.
@@ -1678,7 +1795,7 @@ export function upsertSessionsBatch(entries) {
             // back when the error escapes `fn`, so catching + skipping here leaves the txn valid
             // and committable. We deliberately do NOT stamp the ledger for a skipped row, so the
             // next scan re-tries it (self-healing once the underlying parser is fixed).
-            const toolUsage = detectToolUsage(meta.id);
+            const toolUsage = toolUsageBySession.get(meta.id) ?? { usedBrowser: false, usedComputer: false };
             // claude/codex skip enrichCachedSessionMeta above (preserving their
             // resumable-parse optimization) — write their pre-computed
             // skillsUsed/slashCommandsUsed (folded incrementally by discover.ts's
@@ -1767,12 +1884,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
@@ -2112,6 +2235,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();
@@ -2124,11 +2292,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) {
@@ -2141,7 +2316,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)
@@ -2622,6 +2798,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
@@ -2649,10 +2839,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

@@ -690,6 +690,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?: {

package/dist/lib/session/discover.js

@@ -877,6 +877,7 @@ async function scanRoutineArchivesIncremental(agent, onProgress) {
                     meta: result.meta,
                     content: result.content,
                     scan,
+                    events: result.events,
                     toolCalls: result.toolCalls,
                     toolIndexMode: result.toolIndexMode,
                 });
@@ -1756,7 +1757,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 +1803,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 +1838,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 +1902,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 +1913,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 +1927,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 +1966,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 +2022,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 +2030,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.
@@ -3902,7 +3998,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 +4094,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

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

@@ -71,6 +71,10 @@ export interface InsightFacets {
     assistantTurns: number;
     toolCount: number;
     errorCount: number;
+    /** Deterministic evidence buckets used by the actions-forward report. */
+    frictionSignals: Record<string, number>;
+    correctionSignals: Record<string, number>;
+    automationSignals: Record<string, number>;
 }
 /**
  * Compute every behavioural facet of one session from its parsed events.
@@ -124,3 +128,17 @@ export declare function topEntries(counts: Record<string, number>, limit: number
     name: string;
     count: number;
 }>;
+export type InsightActionCategory = 'rule' | 'skill' | 'automation' | 'product';
+export interface InsightAction {
+    priority: 'high' | 'medium' | 'low';
+    category: InsightActionCategory;
+    action: string;
+    evidenceCount: number;
+    sampleSessionIds: string[];
+}
+export interface SessionFacetEvidence {
+    id: string;
+    facets: InsightFacets;
+}
+/** Build a stable, evidence-backed action list without exposing transcript text. */
+export declare function buildInsightActions(sessions: SessionFacetEvidence[]): InsightAction[];