@phnx-labs/agents-cli 1.20.74 → 1.20.77

package/dist/lib/session/cloud.js

@@ -13,6 +13,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as yaml from 'yaml';
+import { deriveShortId } from './short-id.js';
 import { getCacheDir } from '../state.js';
 const PROXY_BASE = process.env.RUSH_PROXY_BASE ?? 'https://api.prix.dev';
 const USER_YAML = path.join(os.homedir(), '.rush', 'user.yaml');
@@ -94,7 +95,7 @@ export async function discoverCloudSessions(options) {
         const filePath = cachePathForExecution(id, agent);
         out.push({
             id,
-            shortId: id.slice(0, 8),
+            shortId: deriveShortId(id),
             agent,
             timestamp,
             project,

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

@@ -40,6 +40,10 @@ export interface SessionRow {
     worktree_slug: string | null;
     ticket_id: string | null;
     plan: string | null;
+    todos: string | null;
+    recent_directories_touched: string | null;
+    linear_project: string | null;
+    linear_project_url: string | null;
 }
 /** File stat snapshot used to detect changes between scan runs. */
 export interface ScanStamp {
@@ -109,6 +113,29 @@ export declare function getScanStampByPath(filePath: string): ScanStamp | null;
  * This is the fast path used by the incremental scanner — avoids N+1 queries.
  */
 export declare function getScanStampsForPaths(filePaths: string[]): Map<string, ScanStamp>;
+/**
+ * A file's persisted resumable-parse continuation, read back from scan_ledger.
+ * `parserState` is the serialized {@link ClaudeParserState} JSON blob (offset +
+ * accumulator snapshot); `contentText` is the accumulated user doc. Both are
+ * written by the Claude scan (B-2) and consumed on the next scan to decide
+ * full-vs-incremental and to hydrate the resume.
+ */
+export interface ParserStateRow {
+    parserState: string | null;
+    contentText: string | null;
+    fileMtimeMs: number;
+    fileSize: number;
+    scannedAt: number;
+}
+/**
+ * Bulk-load the resumable-parse continuation (parser_state + content_text) plus
+ * the stamp for a set of file paths in a single chunked query. Mirrors
+ * {@link getScanStampsForPaths}: keys by canonical path and fans results back to
+ * every original alias so callers can `.get(filePath)` with the path they passed.
+ * The Claude incremental scan uses this to fetch each changed file's prior
+ * continuation without an N+1 of {@link getScanStampByPath}.
+ */
+export declare function getParserStatesForPaths(filePaths: string[]): Map<string, ParserStateRow>;
 /**
  * Record scan stamps for files we've looked at. Covers both files that produced
  * a session and files we looked at but chose not to index (e.g. malformed).
@@ -117,6 +144,29 @@ export declare function recordScans(entries: Array<{
     filePath: string;
     scan: ScanStamp;
 }>): void;
+/** Snapshot of a leaf transcript directory used to detect create/delete/rename. */
+export interface DirStamp {
+    dirMtimeMs: number;
+    entryCount: number;
+}
+/**
+ * Bulk-load the dir ledger for a set of leaf directories in a single SQL query.
+ * Mirrors {@link getScanStampsForPaths}: keys by canonical path (so a dir
+ * reachable via a symlinked version home and its realpath collapse to one row)
+ * and fans the result back out to every original alias so callers can
+ * `.get(dirPath)` with the path they passed in.
+ */
+export declare function getDirLedgerForPaths(dirs: string[]): Map<string, DirStamp>;
+/**
+ * Upsert dir-scan stamps. Recorded after a full readdir of a leaf transcript
+ * dir so the next scan can skip that dir when its (mtime, entry_count) is
+ * unchanged. Mirrors {@link recordScans}.
+ */
+export declare function recordDirScans(entries: Array<{
+    dirPath: string;
+    dirMtimeMs: number;
+    entryCount: number;
+}>): void;
 /**
  * Upsert a session row and replace its FTS5 content in a single transaction.
  * `content` is the tokenizable user-prompt text; pass '' to leave the row unsearchable.
@@ -127,6 +177,8 @@ export declare function upsertSessionsBatch(entries: Array<{
     meta: SessionMeta;
     content: string;
     scan?: ScanStamp;
+    parserState?: string;
+    contentText?: string;
 }>): void;
 /**
  * Sync labels for a set of sessions. For each id in the map, if the stored
@@ -167,6 +219,8 @@ export declare function isSessionActivityFresh(row: {
     timestamp: string;
     file_mtime_ms: number | null;
 }, maxAgeMs: number, nowMs: number): boolean;
+/** Persist a lazily resolved Linear project without reparsing the transcript. */
+export declare function cacheLinearProject(sessionId: string, project: string, projectUrl: string): void;
 /**
  * Newest indexed session file for an agent working in `cwd`. Lets the live
  * `--active` scanner locate a Codex transcript (whose files are date-partitioned,

package/dist/lib/session/db.js

@@ -9,11 +9,13 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from '../sqlite.js';
+import { parseSession } from './parse.js';
+import { extractRecentDirectoriesTouched, extractTodoProgressFromEvents } from './state.js';
 import { getSessionsDir, getSessionsDbPath } from '../state.js';
 const SESSIONS_DIR = getSessionsDir();
 const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. */
-const SCHEMA_VERSION = 13;
+const SCHEMA_VERSION = 17;
 /**
  * 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`
@@ -69,7 +71,11 @@ CREATE TABLE IF NOT EXISTS sessions (
   pr_number INTEGER,
   worktree_slug TEXT,
   ticket_id TEXT,
-  plan TEXT
+  plan TEXT,
+  todos TEXT,
+  recent_directories_touched TEXT,
+  linear_project TEXT,
+  linear_project_url TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp DESC);
 CREATE INDEX IF NOT EXISTS idx_sessions_cwd ON sessions(cwd);
@@ -99,6 +105,27 @@ CREATE TABLE IF NOT EXISTS scan_ledger (
   file_path TEXT PRIMARY KEY,
   file_mtime_ms INTEGER NOT NULL,
   file_size INTEGER NOT NULL,
+  scanned_at INTEGER NOT NULL,
+  -- Resumable-parse cursor + continuation (B-1). parser_state is a JSON
+  -- ClaudeParserState blob (offset + accumulator snapshot) so a scan can pick
+  -- up where the last one stopped; content_text caches the accumulated user
+  -- doc so detectTicket + FTS can rebuild on append without re-reading the file.
+  -- Written by B-2; B-1 only defines + round-trips them.
+  parser_state TEXT,
+  content_text TEXT
+);
+
+-- Tracks the mtime + entry-count of every LEAF directory that directly holds
+-- transcripts (a Claude project dir, a Gemini chats dir). A dir's mtime bumps
+-- on create/delete/rename of its entries but NOT on an in-place append, so a
+-- match here means the dir gained/lost/renamed no files: we can skip the
+-- readdir + per-file stat and serve unchanged files from the DB (append-safety
+-- is preserved by re-stat'ing only the "hot set" — see discover.ts). Keyed by
+-- canonicalLedgerKey, same as scan_ledger.
+CREATE TABLE IF NOT EXISTS dir_ledger (
+  dir_path TEXT PRIMARY KEY,
+  dir_mtime_ms INTEGER NOT NULL,
+  entry_count INTEGER NOT NULL,
   scanned_at INTEGER NOT NULL
 );
 `;
@@ -252,6 +279,61 @@ function migrateSchema(db, fromVersion) {
         db.exec(`UPDATE sessions SET origin = 'cli' WHERE origin IS NULL OR origin = ''`);
         db.exec(`DELETE FROM scan_ledger;`);
     }
+    if (fromVersion < 14) {
+        // v13 → v14: the discovery scan now short-circuits the readdir + per-file
+        // stat of leaf transcript dirs whose (mtime, entry_count) is unchanged,
+        // caching that snapshot in the new `dir_ledger` table. Create it, and clear
+        // scan_ledger so the first post-upgrade scan does a clean full walk — that
+        // walk seeds BOTH ledgers correctly, so a cold/empty dir_ledger degrades to
+        // today's full behavior.
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS dir_ledger (
+        dir_path TEXT PRIMARY KEY,
+        dir_mtime_ms INTEGER NOT NULL,
+        entry_count INTEGER NOT NULL,
+        scanned_at INTEGER NOT NULL
+      );
+      DELETE FROM scan_ledger;
+    `);
+    }
+    if (fromVersion < 15) {
+        // v14 → v15: the Claude scan becomes resumable (B-1). scan_ledger gains a
+        // `parser_state` continuation blob (offset + accumulator snapshot) and a
+        // `content_text` cache of the accumulated user doc. Add both columns, then
+        // clear scan_ledger so the first post-upgrade scan does a clean full walk
+        // that reseeds the cursor from byte 0.
+        const cols = db.prepare(`PRAGMA table_info(scan_ledger)`).all();
+        if (!cols.some(c => c.name === 'parser_state'))
+            db.exec(`ALTER TABLE scan_ledger ADD COLUMN parser_state TEXT`);
+        if (!cols.some(c => c.name === 'content_text'))
+            db.exec(`ALTER TABLE scan_ledger ADD COLUMN content_text TEXT`);
+        db.exec(`DELETE FROM scan_ledger;`);
+    }
+    if (fromVersion < 16) {
+        // v15 → v16: repair rows poisoned by the empty-shortId bug (now fixed at the
+        // source in deriveShortId). A session id that was only a known prefix — a bare
+        // `session_` dir, an id of exactly `api-` or `ses_` — derived to '' via
+        // `id.replace(prefix, '').slice(0, 8)`, passed the `short_id TEXT NOT NULL`
+        // column (empty string is not NULL), yet matched nothing in the
+        // `short_id LIKE ?` picker lookups. The parser no longer produces '', but
+        // existing rows don't self-heal: an empty short_id is not re-parsed unless its
+        // file changes, and an orphaned row (file gone) never re-parses at all. Repair
+        // in place — `substr(id, 1, 8)` is non-empty because `id` is the non-empty
+        // primary key — so every corrupt row becomes addressable. No rescan needed.
+        db.exec(`UPDATE sessions SET short_id = substr(id, 1, 8) WHERE short_id IS NULL OR short_id = ''`);
+    }
+    if (fromVersion < 17) {
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (!cols.some(c => c.name === 'todos'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN todos TEXT`);
+        if (!cols.some(c => c.name === 'recent_directories_touched'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN recent_directories_touched TEXT`);
+        if (!cols.some(c => c.name === 'linear_project'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN linear_project TEXT`);
+        if (!cols.some(c => c.name === 'linear_project_url'))
+            db.exec(`ALTER TABLE sessions ADD COLUMN linear_project_url TEXT`);
+        db.exec(`DELETE FROM scan_ledger; DELETE FROM dir_ledger;`);
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -310,6 +392,11 @@ export function closeDB() {
     if (dbInstance) {
         dbInstance.close();
         dbInstance = null;
+        // Closing the connection finalizes every prepared statement it owns. Drop
+        // the cached upsert/FTS statements too, so the next getDB() rebuilds them
+        // against the fresh connection instead of re-running a finalized statement
+        // (which throws "statement has been finalized" on the first upsert).
+        cachedStmts = {};
     }
 }
 // ---------------------------------------------------------------------------
@@ -440,6 +527,55 @@ export function getScanStampsForPaths(filePaths) {
     }
     return result;
 }
+/**
+ * Bulk-load the resumable-parse continuation (parser_state + content_text) plus
+ * the stamp for a set of file paths in a single chunked query. Mirrors
+ * {@link getScanStampsForPaths}: keys by canonical path and fans results back to
+ * every original alias so callers can `.get(filePath)` with the path they passed.
+ * The Claude incremental scan uses this to fetch each changed file's prior
+ * continuation without an N+1 of {@link getScanStampByPath}.
+ */
+export function getParserStatesForPaths(filePaths) {
+    const result = new Map();
+    if (filePaths.length === 0)
+        return result;
+    const db = getDB();
+    const canonicalToOriginals = new Map();
+    for (const fp of filePaths) {
+        const canonical = canonicalLedgerKey(fp);
+        const aliases = canonicalToOriginals.get(canonical);
+        if (aliases)
+            aliases.push(fp);
+        else
+            canonicalToOriginals.set(canonical, [fp]);
+    }
+    const canonicalKeys = [...canonicalToOriginals.keys()];
+    const CHUNK = 500;
+    for (let i = 0; i < canonicalKeys.length; i += CHUNK) {
+        const chunk = canonicalKeys.slice(i, i + CHUNK);
+        const placeholders = chunk.map(() => '?').join(',');
+        const rows = db
+            .prepare(`
+        SELECT file_path, file_mtime_ms, file_size, scanned_at, parser_state, content_text
+        FROM scan_ledger
+        WHERE file_path IN (${placeholders})
+      `)
+            .all(...chunk);
+        for (const row of rows) {
+            const state = {
+                parserState: row.parser_state,
+                contentText: row.content_text,
+                fileMtimeMs: row.file_mtime_ms,
+                fileSize: row.file_size,
+                scannedAt: row.scanned_at,
+            };
+            for (const original of canonicalToOriginals.get(row.file_path) || []) {
+                result.set(original, state);
+            }
+        }
+    }
+    return result;
+}
 /**
  * Record scan stamps for files we've looked at. Covers both files that produced
  * a session and files we looked at but chose not to index (e.g. malformed).
@@ -464,6 +600,73 @@ export function recordScans(entries) {
     });
     txn(entries);
 }
+/**
+ * Bulk-load the dir ledger for a set of leaf directories in a single SQL query.
+ * Mirrors {@link getScanStampsForPaths}: keys by canonical path (so a dir
+ * reachable via a symlinked version home and its realpath collapse to one row)
+ * and fans the result back out to every original alias so callers can
+ * `.get(dirPath)` with the path they passed in.
+ */
+export function getDirLedgerForPaths(dirs) {
+    const result = new Map();
+    if (dirs.length === 0)
+        return result;
+    const db = getDB();
+    const canonicalToOriginals = new Map();
+    for (const d of dirs) {
+        const canonical = canonicalLedgerKey(d);
+        const aliases = canonicalToOriginals.get(canonical);
+        if (aliases)
+            aliases.push(d);
+        else
+            canonicalToOriginals.set(canonical, [d]);
+    }
+    const canonicalKeys = [...canonicalToOriginals.keys()];
+    const CHUNK = 500;
+    for (let i = 0; i < canonicalKeys.length; i += CHUNK) {
+        const chunk = canonicalKeys.slice(i, i + CHUNK);
+        const placeholders = chunk.map(() => '?').join(',');
+        const rows = db
+            .prepare(`
+        SELECT dir_path, dir_mtime_ms, entry_count
+        FROM dir_ledger
+        WHERE dir_path IN (${placeholders})
+      `)
+            .all(...chunk);
+        for (const row of rows) {
+            const stamp = { dirMtimeMs: row.dir_mtime_ms, entryCount: row.entry_count };
+            for (const original of canonicalToOriginals.get(row.dir_path) || []) {
+                result.set(original, stamp);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Upsert dir-scan stamps. Recorded after a full readdir of a leaf transcript
+ * dir so the next scan can skip that dir when its (mtime, entry_count) is
+ * unchanged. Mirrors {@link recordScans}.
+ */
+export function recordDirScans(entries) {
+    if (entries.length === 0)
+        return;
+    const db = getDB();
+    const stmt = db.prepare(`
+    INSERT INTO dir_ledger (dir_path, dir_mtime_ms, entry_count, scanned_at)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT(dir_path) DO UPDATE SET
+      dir_mtime_ms = excluded.dir_mtime_ms,
+      entry_count = excluded.entry_count,
+      scanned_at = excluded.scanned_at
+  `);
+    const now = Date.now();
+    const txn = db.transaction((items) => {
+        for (const { dirPath, dirMtimeMs, entryCount } of items) {
+            stmt.run(canonicalLedgerKey(dirPath), dirMtimeMs, entryCount, now);
+        }
+    });
+    txn(entries);
+}
 const upsertSessionStmt = (db) => db.prepare(`
   INSERT INTO sessions (
     id, short_id, agent, origin, routine_name, routine_run_id,
@@ -471,14 +674,16 @@ const upsertSessionStmt = (db) => db.prepare(`
     project, cwd, git_branch, topic, label, message_count, token_count,
     output_tokens, cost_usd, duration_ms,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
-    pr_url, pr_number, worktree_slug, ticket_id, plan
+    pr_url, pr_number, worktree_slug, ticket_id, plan, todos,
+    recent_directories_touched, linear_project, linear_project_url
   ) VALUES (
     @id, @short_id, @agent, @origin, @routine_name, @routine_run_id,
     @version, @account, @timestamp, @last_activity,
     @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
     @output_tokens, @cost_usd, @duration_ms,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
-    @pr_url, @pr_number, @worktree_slug, @ticket_id, @plan
+    @pr_url, @pr_number, @worktree_slug, @ticket_id, @plan, @todos,
+    @recent_directories_touched, @linear_project, @linear_project_url
   )
   ON CONFLICT(id) DO UPDATE SET
     short_id = excluded.short_id,
@@ -494,7 +699,15 @@ const upsertSessionStmt = (db) => db.prepare(`
     cwd = excluded.cwd,
     git_branch = excluded.git_branch,
     topic = excluded.topic,
-    label = excluded.label,
+    -- Never let an empty/placeholder incoming label clobber a good stored one.
+    -- A real incoming label (non-empty after trim) still wins; a blank one keeps
+    -- the label seeded by --name (seedLabelsFromNames) or refined by an agent
+    -- title / rename (syncLabels). A bare rescan carries no label, so it must
+    -- preserve, not erase, the good one already stored.
+    label = CASE
+      WHEN excluded.label IS NULL OR trim(excluded.label) = '' THEN sessions.label
+      ELSE excluded.label
+    END,
     message_count = excluded.message_count,
     token_count = excluded.token_count,
     output_tokens = excluded.output_tokens,
@@ -509,10 +722,40 @@ const upsertSessionStmt = (db) => db.prepare(`
     pr_number = excluded.pr_number,
     worktree_slug = excluded.worktree_slug,
     ticket_id = excluded.ticket_id,
-    plan = excluded.plan
+    plan = excluded.plan,
+    todos = excluded.todos,
+    recent_directories_touched = excluded.recent_directories_touched,
+    linear_project = CASE
+      WHEN excluded.ticket_id IS NOT sessions.ticket_id THEN excluded.linear_project
+      ELSE COALESCE(excluded.linear_project, sessions.linear_project)
+    END,
+    linear_project_url = CASE
+      WHEN excluded.ticket_id IS NOT sessions.ticket_id THEN excluded.linear_project_url
+      ELSE COALESCE(excluded.linear_project_url, sessions.linear_project_url)
+    END
 `);
+function enrichCachedSessionMeta(meta) {
+    if (!meta.filePath)
+        return meta;
+    try {
+        const events = parseSession(meta.filePath, meta.agent);
+        return {
+            ...meta,
+            todos: extractTodoProgressFromEvents(events),
+            recentDirectoriesTouched: extractRecentDirectoriesTouched(events, meta.cwd),
+        };
+    }
+    catch {
+        // Synthetic/cloud rows can intentionally name a transcript that is not local.
+        return meta;
+    }
+}
 const deleteTextStmt = (db) => db.prepare(`DELETE FROM session_text WHERE session_id = ?`);
 const insertTextStmt = (db) => db.prepare(`INSERT INTO session_text (session_id, label, topic, project, content) VALUES (?, ?, ?, ?, ?)`);
+// Read back the label the upsert actually stored (which may be the preserved
+// one, not the incoming blank) so the FTS label column stays consistent with
+// sessions.label after a bare rescan.
+const readLabelStmt = (db) => db.prepare(`SELECT label FROM sessions WHERE id = ?`);
 let cachedStmts = {};
 function stmts(db) {
     if (!cachedStmts.upsert) {
@@ -520,17 +763,29 @@ function stmts(db) {
             upsert: upsertSessionStmt(db),
             delText: deleteTextStmt(db),
             insText: insertTextStmt(db),
+            readLabel: readLabelStmt(db),
         };
     }
     return cachedStmts;
 }
+/**
+ * Return the label stored for a session, as text for the FTS index (never NULL).
+ * Called inside the upsert transaction, AFTER the row upsert, so it reflects the
+ * preserve-non-empty-label rule in the ON CONFLICT clause rather than the raw
+ * incoming label.
+ */
+function storedFtsLabel(readLabel, id) {
+    const row = readLabel.get(id);
+    return row?.label ?? '';
+}
 /**
  * Upsert a session row and replace its FTS5 content in a single transaction.
  * `content` is the tokenizable user-prompt text; pass '' to leave the row unsearchable.
  */
 export function upsertSession(meta, content, scan) {
+    meta = enrichCachedSessionMeta(meta);
     const db = getDB();
-    const { upsert, delText, insText } = stmts(db);
+    const { upsert, delText, insText, readLabel } = stmts(db);
     const row = {
         id: meta.id,
         short_id: meta.shortId,
@@ -562,11 +817,18 @@ export function upsertSession(meta, content, scan) {
         worktree_slug: meta.worktreeSlug ?? null,
         ticket_id: meta.ticketId ?? null,
         plan: meta.plan ?? null,
+        todos: meta.todos ? JSON.stringify(meta.todos) : null,
+        recent_directories_touched: meta.recentDirectoriesTouched ? JSON.stringify(meta.recentDirectoriesTouched) : null,
+        linear_project: meta.linearProject ?? null,
+        linear_project_url: meta.linearProjectUrl ?? null,
     };
     const txn = db.transaction(() => {
         upsert.run(row);
         delText.run(meta.id);
-        insText.run(meta.id, meta.label ?? '', meta.topic ?? '', meta.project ?? '', content ?? '');
+        insText.run(meta.id, 
+        // Use the label the upsert actually stored (preserve-non-empty rule),
+        // not the raw incoming one, so FTS label ranking survives a bare rescan.
+        storedFtsLabel(readLabel, meta.id), meta.topic ?? '', meta.project ?? '', content ?? '');
     });
     txn();
 }
@@ -575,15 +837,22 @@ export function upsertSessionsBatch(entries) {
     if (entries.length === 0)
         return;
     const db = getDB();
-    const { upsert, delText, insText } = stmts(db);
+    const { upsert, delText, insText, readLabel } = stmts(db);
     const now = Date.now();
+    // Persist the Claude resumable-parse continuation (parser_state + content_text)
+    // alongside the stamp. On a full/incremental Claude parse the caller passes the
+    // serialized newState + accumulated user doc so the NEXT scan can resume from
+    // the persisted offset (B-2). Other scanners pass neither, leaving both columns
+    // NULL exactly as before — their ledger rows are unaffected.
     const ledger = db.prepare(`
-    INSERT INTO scan_ledger (file_path, file_mtime_ms, file_size, scanned_at)
-    VALUES (?, ?, ?, ?)
+    INSERT INTO scan_ledger (file_path, file_mtime_ms, file_size, scanned_at, parser_state, content_text)
+    VALUES (?, ?, ?, ?, ?, ?)
     ON CONFLICT(file_path) DO UPDATE SET
       file_mtime_ms = excluded.file_mtime_ms,
       file_size = excluded.file_size,
-      scanned_at = excluded.scanned_at
+      scanned_at = excluded.scanned_at,
+      parser_state = excluded.parser_state,
+      content_text = excluded.content_text
   `);
     // Build a lookup from canonical file path → entry, used inside the write
     // transaction to re-check the ledger AFTER acquiring the lock. When a
@@ -594,6 +863,9 @@ 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 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.
@@ -613,7 +885,7 @@ export function upsertSessionsBatch(entries) {
                 }
             }
         }
-        for (const { meta, content, scan } of items) {
+        for (const { meta, content, scan, parserState, contentText } of items) {
             if (alreadyIndexed.has(meta.id))
                 continue;
             // Per-row guard: one malformed session (e.g. a required field that resolves to
@@ -655,11 +927,18 @@ export function upsertSessionsBatch(entries) {
                     worktree_slug: meta.worktreeSlug ?? null,
                     ticket_id: meta.ticketId ?? null,
                     plan: meta.plan ?? null,
+                    todos: meta.todos ? JSON.stringify(meta.todos) : null,
+                    recent_directories_touched: meta.recentDirectoriesTouched ? JSON.stringify(meta.recentDirectoriesTouched) : null,
+                    linear_project: meta.linearProject ?? null,
+                    linear_project_url: meta.linearProjectUrl ?? null,
                 });
                 delText.run(meta.id);
-                insText.run(meta.id, meta.label ?? '', meta.topic ?? '', meta.project ?? '', content ?? '');
+                insText.run(meta.id, 
+                // Mirror upsertSession: index the label the upsert actually stored
+                // (preserve-non-empty rule), not the raw incoming one.
+                storedFtsLabel(readLabel, meta.id), meta.topic ?? '', meta.project ?? '', content ?? '');
                 if (scan && meta.filePath) {
-                    ledger.run(canonicalLedgerKey(meta.filePath), scan.fileMtimeMs, scan.fileSize, now);
+                    ledger.run(canonicalLedgerKey(meta.filePath), scan.fileMtimeMs, scan.fileSize, now, parserState ?? null, contentText ?? null);
                 }
             }
             catch (err) {
@@ -669,7 +948,7 @@ export function upsertSessionsBatch(entries) {
             }
         }
     });
-    txn(entries);
+    txn(enrichedEntries);
 }
 /**
  * Sync labels for a set of sessions. For each id in the map, if the stored
@@ -832,8 +1111,22 @@ function rowToMeta(row) {
         worktreeSlug: row.worktree_slug ?? undefined,
         ticketId: row.ticket_id ?? undefined,
         plan: row.plan ?? undefined,
+        todos: parseJsonColumn(row.todos),
+        recentDirectoriesTouched: parseJsonColumn(row.recent_directories_touched),
+        linearProject: row.linear_project ?? undefined,
+        linearProjectUrl: row.linear_project_url ?? undefined,
     };
 }
+function parseJsonColumn(value) {
+    if (!value)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * The recency signal used to sort and label the listing: last-message time when
  * a parser computed it (`meta.lastActivity` from `lastTsMs`), else the file's
@@ -854,6 +1147,11 @@ export function isSessionActivityFresh(row, maxAgeMs, nowMs) {
     const activityMs = Number.isFinite(parsedActivityMs) ? parsedActivityMs : row.file_mtime_ms ?? undefined;
     return activityMs != null && nowMs - activityMs <= maxAgeMs;
 }
+/** Persist a lazily resolved Linear project without reparsing the transcript. */
+export function cacheLinearProject(sessionId, project, projectUrl) {
+    getDB().prepare(`UPDATE sessions SET linear_project = ?, linear_project_url = ? WHERE id = ?`)
+        .run(project, projectUrl, sessionId);
+}
 /**
  * Newest indexed session file for an agent working in `cwd`. Lets the live
  * `--active` scanner locate a Codex transcript (whose files are date-partitioned,
@@ -909,9 +1207,12 @@ function buildSessionWhere(options) {
         params.push(options.cwd);
     }
     if (options.cwdPrefix) {
-        // Stored cwd uses the host path separator (normalizeCwd → path.resolve), so
-        // the subdir wildcard must too — a hardcoded '/' never matches a Windows
-        // `C:\a\b` subpath and the listing comes back empty.
+        // A LOCAL stored cwd uses the host path separator (normalizeCwd runs
+        // path.normalize on it), so the subdir wildcard must too — a hardcoded '/'
+        // never matches a Windows `C:\a\b` subpath and the listing comes back empty.
+        // A cwd recorded on another machine keeps its own separators, so this
+        // wildcard does not match foreign subpaths; both sides go through
+        // normalizeCwd, so the exact `cwd = ?` comparison still holds for them.
         where.push('(cwd = ? OR cwd LIKE ?)');
         params.push(options.cwdPrefix, options.cwdPrefix + path.sep + '%');
     }

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

@@ -0,0 +1,30 @@
+/** A session's foreground/background presence. */
+export type Presence = 'attached' | 'background' | 'parked';
+export interface DetachRecord {
+    sessionId: string;
+    agent: string;
+    cwd?: string;
+    /** pid of the detached headless continuation `agents sessions detach` spawned. */
+    headlessPid: number;
+    /**
+     * Start-time fingerprint of {@link headlessPid} at spawn, so a liveness check
+     * survives PID reuse: the pid is only "our" continuation if it still occupies
+     * the process we launched. Null when the platform capture failed.
+     */
+    headlessStartTime: string | null;
+    detachedAtMs: number;
+}
+export declare function writeDetachRecord(rec: DetachRecord): void;
+export declare function readDetachRecord(sessionId: string): DetachRecord | undefined;
+export declare function clearDetachRecord(sessionId: string): void;
+export declare function listDetachRecords(): DetachRecord[];
+/** True while the recorded headless continuation is still the live process we spawned. */
+export declare function isHeadlessAlive(rec: DetachRecord): boolean;
+/**
+ * Presence for a session id from the detach store alone:
+ *   - no record            -> undefined (caller decides: `attached` for a live
+ *                             interactive row, nothing for cloud/team rows)
+ *   - record + pid alive    -> `background` (headless continuation running)
+ *   - record + pid exited   -> `parked` (the run finished; transcript is durable)
+ */
+export declare function presenceFromStore(sessionId: string): Presence | undefined;