@phnx-labs/agents-cli 1.21.3 → 1.22.0

package/dist/lib/session/db.js

@@ -15,6 +15,8 @@ import { getSessionsDir, getSessionsDbPath } from '../state.js';
 import { query as queryEvents } from '../events.js';
 import { machineForSessionFile } from './origin-machine.js';
 import { loadSessionActorIndex, readSessionActorRecord } from './actor-sidecar.js';
+import { toolCallsFromEvents } from './tool-calls.js';
+import { persistToolCalls, purgeToolCalls, toolEvidenceSourcePath } from './tool-store.js';
 import { extractSkills, extractSlashCommands } from './highlights.js';
 import { resolveResource } from '../resources.js';
 import { discoverPlugins } from '../plugins.js';
@@ -23,7 +25,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 = 24;
+export const SCHEMA_VERSION = 30;
 /**
  * Canonicalize a file path for use as a scan_ledger key. The same physical
  * session file is reachable via multiple aliases — `~/.claude/projects/x.jsonl`
@@ -147,6 +149,73 @@ CREATE TABLE IF NOT EXISTS dir_ledger (
   scanned_at INTEGER NOT NULL
 );
 
+-- One redacted evidence row per tool call. The ordinal is assigned in
+-- transcript order and is stable across incremental appends.
+CREATE TABLE IF NOT EXISTS tool_calls (
+  call_key TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  ordinal INTEGER NOT NULL,
+  source_call_id TEXT,
+  timestamp TEXT NOT NULL,
+  tool TEXT NOT NULL,
+  input TEXT NOT NULL,
+  outcome TEXT NOT NULL,
+  exit_code INTEGER,
+  status_code INTEGER,
+  error_code TEXT,
+  output TEXT,
+  error TEXT,
+  parse_error TEXT,
+  evidence_bytes INTEGER NOT NULL,
+  UNIQUE(session_id, ordinal)
+);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_session ON tool_calls(session_id, ordinal);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_tool ON tool_calls(tool COLLATE NOCASE);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_outcome ON tool_calls(outcome);
+
+CREATE TABLE IF NOT EXISTS tool_call_programs (
+  call_key TEXT NOT NULL,
+  program TEXT NOT NULL COLLATE NOCASE,
+  PRIMARY KEY(call_key, program)
+);
+CREATE INDEX IF NOT EXISTS idx_tool_call_programs_program ON tool_call_programs(program, call_key);
+
+-- Ordered static program sites retain repeated commands within one Bash call.
+-- The complete redacted command stays on tool_calls.input; these rows contain
+-- only the normalized program and whether it is a wrapper or effective target.
+CREATE TABLE IF NOT EXISTS tool_program_occurrences (
+  call_key TEXT NOT NULL,
+  occurrence_ordinal INTEGER NOT NULL,
+  program TEXT NOT NULL COLLATE NOCASE,
+  role TEXT NOT NULL CHECK(role IN ('wrapper', 'effective')),
+  PRIMARY KEY(call_key, occurrence_ordinal)
+);
+CREATE INDEX IF NOT EXISTS idx_tool_program_occurrences_program
+  ON tool_program_occurrences(program, call_key);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS tool_call_text USING fts5(
+  call_key UNINDEXED,
+  tool,
+  input,
+  output,
+  error,
+  tokenize = 'trigram'
+);
+
+-- Independent of scan_ledger: schema migration never forces the normal
+-- session index to reread history. Existing transcripts are backfilled only
+-- by the explicit, bounded agents sessions backfill tools command.
+CREATE TABLE IF NOT EXISTS tool_scan_ledger (
+  session_id TEXT PRIMARY KEY,
+  file_path TEXT NOT NULL UNIQUE,
+  file_mtime_ms INTEGER NOT NULL,
+  file_size INTEGER NOT NULL,
+  extractor_version INTEGER NOT NULL,
+  indexed_at INTEGER NOT NULL,
+  call_count INTEGER NOT NULL,
+  evidence_bytes INTEGER NOT NULL
+);
+
 -- Skill/slash-command usage per session (#12), computed from a session's
 -- parsed transcript (extractSkills / extractSlashCommands, session/highlights.ts)
 -- and joined at write time against the currently-installed resource/plugin
@@ -390,12 +459,11 @@ function migrateSchema(db, fromVersion) {
             .prepare(`SELECT id, agent, file_path FROM sessions WHERE machine IS NULL OR machine = ''`)
             .all();
         const upd = db.prepare(`UPDATE sessions SET machine = ? WHERE id = ?`);
-        const txn = db.transaction((items) => {
-            for (const r of items) {
-                upd.run(machineForSessionFile(r.file_path, r.agent), r.id);
-            }
-        });
-        txn(rows);
+        // migrateSchema runs inside getDB's schema transaction, so these writes
+        // deliberately share that transaction instead of opening a nested one.
+        for (const row of rows) {
+            upd.run(machineForSessionFile(row.file_path, row.agent), row.id);
+        }
     }
     if (fromVersion < 19) {
         // v18 → v19: actor provenance (RUSH-2018) — who initiated the session and
@@ -430,7 +498,7 @@ function migrateSchema(db, fromVersion) {
         db.exec(`DELETE FROM scan_ledger; DELETE FROM dir_ledger;`);
     }
     if (fromVersion < 22) {
-        // v21 → v22 (main): persist the transcript's tool-call count.
+        // v21 → v22: persist the transcript's aggregate tool-call count.
         const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
         if (!cols.some(c => c.name === 'tool_call_count'))
             db.exec(`ALTER TABLE sessions ADD COLUMN tool_call_count INTEGER`);
@@ -445,10 +513,7 @@ function migrateSchema(db, fromVersion) {
         //
         // Deliberately NO DEFAULT (NULL on ALTER, for every pre-existing row):
         // NULL means "not yet computed by this scanner" (a legacy row), distinct
-        // from a real, computed 0/false. Collapsing that into a DEFAULT 0 would
-        // make every un-rescanned row look like a definite "never used
-        // browser/computer" and permanently blind the picker's fallback path for
-        // any row that isn't rescanned before it's next viewed.
+        // from a real, computed 0/false.
         const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
         if (!cols.some(c => c.name === 'used_browser'))
             db.exec(`ALTER TABLE sessions ADD COLUMN used_browser INTEGER`);
@@ -458,12 +523,7 @@ function migrateSchema(db, fromVersion) {
     if (fromVersion < 24) {
         // v23 → v24: session_resource_usage (#12) — skill/slash-command usage per
         // session, joined against the currently-installed resource/plugin for
-        // provenance (repo_root/snapshot_sha/plugin/source). A brand-new table
-        // needs only CREATE TABLE IF NOT EXISTS, already present in SCHEMA for a
-        // fresh DB — this repeats it for an existing DB whose SCHEMA exec ran
-        // before the table definition was added. No ledger wipe: this table is
-        // populated by writeResourceUsage() at upsert time, independent of the
-        // scan ledgers.
+        // provenance. No ledger wipe: writeResourceUsage() owns this table.
         db.exec(`
       CREATE TABLE IF NOT EXISTS session_resource_usage (
         session_id TEXT NOT NULL,
@@ -480,6 +540,144 @@ function migrateSchema(db, fromVersion) {
       CREATE INDEX IF NOT EXISTS idx_session_resource_usage_plugin ON session_resource_usage(plugin);
     `);
     }
+    if (fromVersion < 25) {
+        // v24 → v25: tool-call evidence uses an independent ledger. Do not clear
+        // scan_ledger or dir_ledger: normal session listing stays warm, while tool
+        // history is filled once on demand.
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS tool_calls (
+        call_key TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        ordinal INTEGER NOT NULL,
+        source_call_id TEXT,
+        timestamp TEXT NOT NULL,
+        tool TEXT NOT NULL,
+        input TEXT NOT NULL,
+        outcome TEXT NOT NULL,
+        exit_code INTEGER,
+        status_code INTEGER,
+        error_code TEXT,
+        output TEXT,
+        error TEXT,
+        parse_error TEXT,
+        evidence_bytes INTEGER NOT NULL,
+        UNIQUE(session_id, ordinal)
+      );
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_session ON tool_calls(session_id, ordinal);
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_tool ON tool_calls(tool COLLATE NOCASE);
+      CREATE INDEX IF NOT EXISTS idx_tool_calls_outcome ON tool_calls(outcome);
+      CREATE TABLE IF NOT EXISTS tool_call_programs (
+        call_key TEXT NOT NULL,
+        program TEXT NOT NULL COLLATE NOCASE,
+        PRIMARY KEY(call_key, program)
+      );
+      CREATE INDEX IF NOT EXISTS idx_tool_call_programs_program ON tool_call_programs(program, call_key);
+      CREATE VIRTUAL TABLE IF NOT EXISTS tool_call_text USING fts5(
+        call_key UNINDEXED,
+        tool,
+        input,
+        output,
+        error,
+        tokenize = 'unicode61 remove_diacritics 2'
+      );
+      CREATE TABLE IF NOT EXISTS tool_scan_ledger (
+        file_path TEXT PRIMARY KEY,
+        file_mtime_ms INTEGER NOT NULL,
+        file_size INTEGER NOT NULL,
+        extractor_version INTEGER NOT NULL,
+        indexed_at INTEGER NOT NULL,
+        call_count INTEGER NOT NULL,
+        evidence_bytes INTEGER NOT NULL
+      );
+    `);
+    }
+    if (fromVersion < 26) {
+        // v25 → v26: make append accounting O(changed calls), including empty
+        // deltas, instead of reading every historical evidence row per append.
+        const callCols = db.prepare(`PRAGMA table_info(tool_calls)`).all();
+        if (!callCols.some((column) => column.name === 'evidence_bytes')) {
+            db.exec(`ALTER TABLE tool_calls ADD COLUMN evidence_bytes INTEGER NOT NULL DEFAULT 0`);
+        }
+        const ledgerCols = db.prepare(`PRAGMA table_info(tool_scan_ledger)`).all();
+        if (!ledgerCols.some((column) => column.name === 'evidence_bytes')) {
+            db.exec(`ALTER TABLE tool_scan_ledger ADD COLUMN evidence_bytes INTEGER NOT NULL DEFAULT 0`);
+        }
+        // The first tool schema existed only in prerelease development builds. Force its tool
+        // evidence through one bounded rebuild rather than trusting zeroed totals.
+        db.exec(`DELETE FROM tool_scan_ledger`);
+    }
+    if (fromVersion < 27) {
+        // v26 → v27: the original unicode word tokenizer could not prefilter the
+        // substring semantics promised by input/output/error queries. Rebuild only
+        // the derived FTS table from already-redacted call rows; transcripts and
+        // both scan ledgers remain warm.
+        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 (call_key, tool, input, output, error)
+      SELECT call_key, tool, input, coalesce(output, ''), coalesce(error, '')
+      FROM tool_calls;
+    `);
+    }
+    if (fromVersion < 28) {
+        // v27 → v28: retain every static program occurrence instead of only the
+        // distinct program set. The source transcript is rebuilt only by the
+        // explicit tools backfill; normal session and directory ledgers stay warm.
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS tool_program_occurrences (
+        call_key TEXT NOT NULL,
+        occurrence_ordinal INTEGER NOT NULL,
+        program TEXT NOT NULL COLLATE NOCASE,
+        role TEXT NOT NULL CHECK(role IN ('wrapper', 'effective')),
+        PRIMARY KEY(call_key, occurrence_ordinal)
+      );
+      CREATE INDEX IF NOT EXISTS idx_tool_program_occurrences_program
+        ON tool_program_occurrences(program, call_key);
+      DELETE FROM tool_scan_ledger;
+    `);
+    }
+    if (fromVersion < 29) {
+        // v28 → v29: coverage and query planning address the independent tool
+        // ledger by session id. Rebuild only this derived ledger so a tool query
+        // never has to resolve or stat transcript paths.
+        db.exec(`
+      DROP TABLE tool_scan_ledger;
+      CREATE TABLE tool_scan_ledger (
+        session_id TEXT PRIMARY KEY,
+        file_path TEXT NOT NULL UNIQUE,
+        file_mtime_ms INTEGER NOT NULL,
+        file_size INTEGER NOT NULL,
+        extractor_version INTEGER NOT NULL,
+        indexed_at INTEGER NOT NULL,
+        call_count INTEGER NOT NULL,
+        evidence_bytes INTEGER NOT NULL
+      );
+    `);
+    }
+    if (fromVersion < 30) {
+        // v29 → v30: prerelease tool-index builds temporarily used schema versions
+        // later owned by independent main migrations. Repair from the physical
+        // schema because a v29 marker alone cannot prove these columns are present.
+        const cols = new Set(db.prepare(`PRAGMA table_info(sessions)`).all().map((column) => column.name));
+        if (!cols.has('tool_call_count')) {
+            db.exec(`
+        ALTER TABLE sessions ADD COLUMN tool_call_count INTEGER;
+        DELETE FROM scan_ledger;
+        DELETE FROM dir_ledger;
+      `);
+        }
+        if (!cols.has('used_browser'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN used_browser INTEGER`);
+        if (!cols.has('used_computer'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN used_computer INTEGER`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -487,24 +685,37 @@ export function getDB() {
         return dbInstance;
     fs.mkdirSync(SESSIONS_DIR, { recursive: true });
     const db = new Database(DB_PATH);
-    db.pragma('journal_mode = WAL');
-    db.pragma('synchronous = NORMAL');
-    db.pragma('temp_store = MEMORY');
-    // Wait up to 30s instead of failing immediately on SQLITE_BUSY. Multiple
+    // Wait up to 30s instead of failing immediately on SQLITE_BUSY. Install the
+    // handler before journal_mode: concurrent first opens can race for its schema
+    // lock, before a later busy_timeout would have a chance to wait. Multiple
     // agents (CLIs, skills, hooks) open this DB concurrently. The first scan of
     // a new version home can take longer than 10s; concurrent callers need enough
     // headroom to wait. The ledger-recheck in upsertSessionsBatch makes
     // subsequent writers near-instant, so 30s is a rarely-reached safety net.
     db.pragma('busy_timeout = 30000');
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.pragma('temp_store = MEMORY');
     db.exec(SCHEMA);
-    const current = db.prepare(`SELECT value FROM meta WHERE key = 'schema_version'`).get();
-    const currentVersion = current ? parseInt(current.value, 10) : 0;
-    if (!current) {
+    const readSchemaVersion = () => {
+        const row = db.prepare(`SELECT value FROM meta WHERE key = 'schema_version'`).get();
+        return row ? parseInt(row.value, 10) : undefined;
+    };
+    const currentVersion = readSchemaVersion();
+    if (currentVersion === undefined) {
         db.prepare(`INSERT OR IGNORE INTO meta(key, value) VALUES ('schema_version', ?)`).run(String(SCHEMA_VERSION));
     }
     else if (currentVersion < SCHEMA_VERSION) {
-        migrateSchema(db, currentVersion);
-        db.prepare(`INSERT OR REPLACE INTO meta(key, value) VALUES ('schema_version', ?)`).run(String(SCHEMA_VERSION));
+        // Re-read after BEGIN IMMEDIATE acquires the writer lock. A second process
+        // may have completed the migration while this connection was waiting.
+        const migrate = db.transaction(() => {
+            const lockedVersion = readSchemaVersion();
+            if (lockedVersion === undefined || lockedVersion >= SCHEMA_VERSION)
+                return;
+            migrateSchema(db, lockedVersion);
+            db.prepare(`INSERT OR REPLACE INTO meta(key, value) VALUES ('schema_version', ?)`).run(String(SCHEMA_VERSION));
+        });
+        migrate();
     }
     // Index last_activity only after the column is guaranteed to exist — fresh DBs
     // get it from CREATE TABLE above, existing pre-v8 DBs from the migration just
@@ -1186,9 +1397,38 @@ export function upsertSessionsBatch(entries) {
     const byPath = new Map(entries
         .filter(e => e.scan && e.meta.filePath)
         .map(e => [canonicalLedgerKey(e.meta.filePath), e]));
-    const enrichedEntries = entries.map(entry => entry.meta.agent === 'claude' || entry.meta.agent === 'codex'
-        ? entry
-        : { ...entry, meta: enrichCachedSessionMeta(entry.meta) });
+    const enrichedEntries = entries.map(entry => {
+        if (entry.meta.agent === 'claude' || entry.meta.agent === 'codex' || !entry.meta.filePath)
+            return entry;
+        try {
+            const toolSourcePath = toolEvidenceSourcePath(entry.meta.filePath, entry.meta.agent);
+            const toolScan = toolSourcePath === entry.meta.filePath
+                ? entry.scan
+                : (() => {
+                    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);
+            writeResourceUsage(entry.meta.id, events, entry.meta.cwd);
+            return {
+                ...entry,
+                meta: {
+                    ...entry.meta,
+                    todos: extractTodoProgressFromEvents(events),
+                    recentDirectoriesTouched: extractRecentDirectoriesTouched(events, entry.meta.cwd),
+                },
+                toolCalls: toolCallsFromEvents(events),
+                toolScan,
+                toolIndexMode: 'replace',
+            };
+        }
+        catch {
+            return entry;
+        }
+    });
+    const writtenEntries = [];
     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.
@@ -1208,7 +1448,8 @@ export function upsertSessionsBatch(entries) {
                 }
             }
         }
-        for (const { meta, content, scan, parserState, contentText } of items) {
+        for (const entry of items) {
+            const { meta, content, scan, parserState, contentText } = entry;
             if (alreadyIndexed.has(meta.id))
                 continue;
             // Per-row guard: one malformed session (e.g. a required field that resolves to
@@ -1280,6 +1521,7 @@ export function upsertSessionsBatch(entries) {
                 if (scan && meta.filePath) {
                     ledger.run(canonicalLedgerKey(meta.filePath), scan.fileMtimeMs, scan.fileSize, now, parserState ?? null, contentText ?? null);
                 }
+                writtenEntries.push(entry);
             }
             catch (err) {
                 if (process.stderr.isTTY) {
@@ -1289,6 +1531,20 @@ export function upsertSessionsBatch(entries) {
         }
     });
     txn(enrichedEntries);
+    // Tool evidence shares the transcript parse above but owns an independent
+    // transaction/ledger. If this write fails, the normal session row remains
+    // valid and ensureToolIndex retries from the missing tool ledger later.
+    for (const entry of writtenEntries) {
+        const toolScan = entry.toolScan ?? entry.scan;
+        if (!toolScan || !entry.toolCalls)
+            continue;
+        try {
+            persistToolCalls(db, entry.meta, entry.toolCalls, toolScan, entry.toolIndexMode ?? 'replace');
+        }
+        catch {
+            // Boundary is intentionally retryable via tool_scan_ledger.
+        }
+    }
 }
 /**
  * Sync labels for a set of sessions. For each id in the map, if the stored
@@ -1637,13 +1893,26 @@ export function querySessions(options = {}) {
             : 'ORDER BY IFNULL(last_activity, timestamp) DESC, timestamp DESC';
     const sql = `SELECT * FROM sessions ${clause} ${orderClause} ${limitClause}`;
     const rows = db.prepare(sql).all(...params);
+    if (options.skipExistenceCheck) {
+        const trimmed = options.limit ? rows.slice(0, options.limit) : rows;
+        return trimmed.map(rowToMeta);
+    }
     // Belt-and-suspenders: drop rows whose JSONL no longer exists on disk. The
     // authoritative fix is to keep file_path in sync (see updateSessionFilePaths
     // callers), but skipping vanished rows here prevents phantom sessions from
     // 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 live = rows.filter(r => !r.file_path || fs.existsSync(r.file_path));
+    const missing = rows.filter(r => r.file_path && !fs.existsSync(r.file_path));
+    if (missing.length > 0) {
+        const purge = db.transaction(() => {
+            for (const row of missing)
+                purgeToolCalls(db, row.id);
+        });
+        purge();
+    }
+    const missingIds = new Set(missing.map((row) => row.id));
+    const live = rows.filter(r => !r.file_path || !missingIds.has(r.id));
     const trimmed = options.limit ? live.slice(0, options.limit) : live;
     return trimmed.map(rowToMeta);
 }

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

@@ -9,6 +9,9 @@
 import type { SessionAgentId, SessionEvent, SessionMeta, TodoProgress } from './types.js';
 export { machineForSessionFile } from './origin-machine.js';
 import { type ScanStamp } from './db.js';
+import { ToolCallCollector, type IndexedToolCall, type ToolCallCollectorSnapshot } from './tool-calls.js';
+/** One JSONL record may not force an unbounded string allocation. */
+export declare const SESSION_JSONL_LINE_MAX_BYTES: number;
 /** Options controlling which sessions to discover and how to report progress. */
 export interface DiscoverOptions {
     agent?: SessionAgentId;
@@ -27,6 +30,8 @@ export interface DiscoverOptions {
     /** Match any session whose cwd equals this or is a descendant. Overrides `cwd`. */
     cwdPrefix?: string;
     limit?: number;
+    /** Internal indexed-query path: return every row in scope instead of the default page. */
+    unbounded?: boolean;
     /** Filter sessions newer than this (ISO timestamp or "7d", "30d", "90d") */
     since?: string;
     /** Filter sessions older than this (ISO timestamp) */
@@ -39,6 +44,8 @@ export interface DiscoverOptions {
     origin?: 'cli' | 'routine';
     /** Column to order results by (all descending): 'timestamp' (default), 'cost', or 'duration'. */
     sortBy?: 'timestamp' | 'cost' | 'duration';
+    /** Trust scan-ledger rows without stat'ing every returned transcript. */
+    skipExistenceCheck?: boolean;
     /** Called as each agent makes parsing progress. Totals count only files that need re-parsing (cache misses). */
     onProgress?: (progress: ScanProgress) => void;
     /** Only sessions that invoked this skill (#12) — see QueryOptions.skill in session/db.ts. */
@@ -139,6 +146,22 @@ interface CodexSessionScan {
  * TTL, no external lock files needed.
  */
 export declare function discoverSessions(options?: DiscoverOptions): Promise<SessionMeta[]>;
+/** Read the current SQLite snapshot without scanning or parsing transcript files. */
+export declare function queryIndexedSessions(options?: DiscoverOptions, indexedOptions?: {
+    resolveLinear?: boolean;
+    skipExistenceCheck?: boolean;
+}): Promise<SessionMeta[]>;
+/**
+ * Drop unmanaged rows for agents that HAVE managed versions.
+ *
+ * Scoping happens here, at query time, rather than by narrowing the scan: the index
+ * stays complete, so `--unmanaged` needs no re-scan and every other consumer of the
+ * DB (watchdog, the Factory watcher, `--roots`) is unaffected.
+ *
+ * An agent with no managed versions is left alone entirely — someone who has never
+ * run `agents add` sees exactly what they saw before.
+ */
+export declare function scopeToManaged(sessions: SessionMeta[], agents: readonly SessionAgentId[], options?: DiscoverOptions): SessionMeta[];
 /**
  * How many agents' dotfile dirs we scan at once, and the minimum spacing between
  * successive scan starts. A small bound + stagger turns a simultaneous bulk
@@ -370,6 +393,8 @@ export declare function readCodexMeta(filePath: string, resolveAccount?: () => s
     content: string;
     parserState?: string;
     contentText?: string;
+    toolCalls?: IndexedToolCall[];
+    toolIndexMode: 'replace' | 'append';
 } | null>;
 /**
  * Mutable accumulator for the Claude transcript reducer. One field per local
@@ -408,6 +433,7 @@ export interface ClaudeParseState {
     plan?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    toolCollector: ToolCallCollector;
     /** Skill-invocation tool_use events, held for extractSkills() at finalize (#12). */
     skillEvents: SessionEvent[];
     /** Slash-command events (user-typed <command-name> wrapper OR a SlashCommand
@@ -442,8 +468,9 @@ export declare function scanClaudeSession(filePath: string): Promise<ClaudeSessi
  * exact even when the recent window is smaller than the true count.
  */
 export interface ClaudeParserState {
-    v: 1;
+    v: 2;
     offset: number;
+    jsonlDroppingOversizedLine?: boolean;
     timestamp?: string;
     cwd?: string;
     gitBranch?: string;
@@ -475,6 +502,7 @@ export interface ClaudeParserState {
     contentText?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    toolCalls: ToolCallCollectorSnapshot;
     /** #12: see ClaudeParseState.skillEvents/slashCommandEvents. */
     skillEvents: SessionEvent[];
     slashCommandEvents: SessionEvent[];
@@ -484,7 +512,7 @@ export interface ClaudeParserState {
  * `offset` bytes consumed. Round-trips through {@link hydrateClaudeParseState}
  * so incremental replay equals a full parse.
  */
-export declare function serializeClaudeParserState(state: ClaudeParseState, offset: number): ClaudeParserState;
+export declare function serializeClaudeParserState(state: ClaudeParseState, offset: number, jsonlDroppingOversizedLine?: boolean): ClaudeParserState;
 /**
  * Rebuild a live {@link ClaudeParseState} from a persisted continuation so that
  * applying the appended lines yields the same accumulator a full parse would.
@@ -517,6 +545,7 @@ export declare function scanClaudeSessionIncremental(filePath: string, fromOffse
     scan: ClaudeSessionScan;
     newState: ClaudeParserState;
     newOffset: number;
+    toolCalls: IndexedToolCall[];
 }>;
 /** Test seam: read the (incremental, full) Claude parse counters. */
 export declare function __claudeScanBranchCountsForTest(): {
@@ -553,6 +582,7 @@ export interface CodexParseState {
     spawnedTeam?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    toolCollector: ToolCallCollector;
     /** #12: see ClaudeParseState.skillEvents. Empty in practice today — no
      *  verified Codex skill-invocation tool name — but wired for parity so a
      *  future confirmed tool name (or a literal 'SlashCommand' function_call)
@@ -586,8 +616,9 @@ export declare function finalizeCodexScan(state: CodexParseState): CodexSessionS
  * finalize is identical after a resume.
  */
 export interface CodexParserState {
-    v: 1;
+    v: 2;
     offset: number;
+    jsonlDroppingOversizedLine?: boolean;
     sessionId?: string;
     timestamp?: string;
     cwd?: string;
@@ -610,13 +641,14 @@ export interface CodexParserState {
     contentText?: string;
     checklistEvents: SessionEvent[];
     recentDirectoriesTouched: string[];
+    toolCalls: ToolCallCollectorSnapshot;
 }
 /**
  * Snapshot a live {@link CodexParseState} into its serializable form at `offset`
  * bytes consumed. Round-trips through {@link hydrateCodexParseState} so
  * incremental replay equals a full parse.
  */
-export declare function serializeCodexParserState(state: CodexParseState, offset: number): CodexParserState;
+export declare function serializeCodexParserState(state: CodexParseState, offset: number, jsonlDroppingOversizedLine?: boolean): CodexParserState;
 /**
  * Rebuild a live {@link CodexParseState} from a persisted continuation so that
  * applying the appended lines yields the same accumulator a full parse would.
@@ -635,9 +667,9 @@ export declare function hydrateCodexParseState(prior: CodexParserState): CodexPa
  *
  * Same trailing-line discipline as {@link scanClaudeSessionIncremental}: apply
  * ONLY the run of newline-terminated lines (slice at the last `'\n'`), and set
- * `newOffset = fromOffset + consumedBytes`. Any tail after the last `'\n'` —
- * syntactically broken OR a complete-but-not-yet-terminated record — is DEFERRED
- * to the next pass once its `'\n'` lands. Codex `messageCount` is additive with
+ * `newOffset = fromOffset + consumedBytes`. An ordinary tail after the last
+ * `'\n'` is deferred; an oversized one advances under a persisted discard bit.
+ * Codex `messageCount` is additive with
  * NO dedup, so re-reading a still-unterminated complete line would double-count
  * it; deferring prevents that (the bug class prix-cloud caught for Claude).
  */
@@ -645,6 +677,7 @@ export declare function scanCodexSessionIncremental(filePath: string, fromOffset
     scan: CodexSessionScan;
     newState: CodexParserState;
     newOffset: number;
+    toolCalls: IndexedToolCall[];
 }>;
 /** Test seam: read the (incremental, full) Codex parse counters. */
 export declare function __codexScanBranchCountsForTest(): {