@mrpatronz/nexusflow 2.21.0 → 2.22.0

package/dist/utils/session-finder.js

@@ -5,6 +5,8 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { MODULAR_SESSION_READERS, modularSessionReader } from './session-readers.js';
+export { SESSION_SOURCES } from './cli-harnesses.js';
 export function extractRecordUsage(record) {
     if (!record || typeof record !== 'object')
         return {};
@@ -437,13 +439,14 @@ export async function canTransferClaudeSessionInWorkspace(workspacePath, repoPat
 }
 /**
  * Scans the local filesystem for conversation histories belonging to Claude, Antigravity,
- * Codex, and Copilot that relate to the specified workspace.
+ * Codex, Copilot, and Pi that relate to the specified workspace.
  *
  * @param workspacePath - Root directory of the active workspace.
  * @param repoPaths - Directories of sub-repositories included in the workspace.
+ * @param source - Optional history source to scan independently for progressive loading.
  * @returns A promise that resolves to an array of {@link AISession} objects sorted by update time descending.
  */
-export async function findSessions(workspacePath, repoPaths = []) {
+export async function findSessions(workspacePath, repoPaths = [], source) {
     const sessions = [];
     const wsFolderName = path.basename(workspacePath);
     // Normalization helper for accurate path comparison
@@ -482,392 +485,410 @@ export async function findSessions(workspacePath, repoPaths = []) {
         return workspacePath;
     };
     // ─── 1. Scan Antigravity Sessions ──────────────────────────────────────
-    const agDir = getAntigravityDir();
-    const agHistoryPath = path.join(agDir, 'history.jsonl');
-    try {
-        const historyContent = await fs.readFile(agHistoryPath, 'utf-8');
-        const lines = historyContent.split('\n').filter(Boolean);
-        const conversationsMap = new Map();
-        for (const line of lines) {
-            try {
-                const entry = JSON.parse(line);
-                if (entry.conversationId && isPathMatch(entry.workspace)) {
-                    if (!conversationsMap.has(entry.conversationId)) {
-                        conversationsMap.set(entry.conversationId, {
-                            id: entry.conversationId,
-                            title: entry.display || 'Untitled Conversation',
-                            entries: [],
-                        });
+    if (!source || source === 'antigravity') {
+        const agDir = getAntigravityDir();
+        const agHistoryPath = path.join(agDir, 'history.jsonl');
+        try {
+            const historyContent = await fs.readFile(agHistoryPath, 'utf-8');
+            const lines = historyContent.split('\n').filter(Boolean);
+            const conversationsMap = new Map();
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.conversationId && isPathMatch(entry.workspace)) {
+                        if (!conversationsMap.has(entry.conversationId)) {
+                            conversationsMap.set(entry.conversationId, {
+                                id: entry.conversationId,
+                                title: entry.display || 'Untitled Conversation',
+                                entries: [],
+                            });
+                        }
+                        conversationsMap.get(entry.conversationId).entries.push(entry);
                     }
-                    conversationsMap.get(entry.conversationId).entries.push(entry);
                 }
+                catch { }
             }
-            catch { }
-        }
-        for (const [convId, convData] of conversationsMap.entries()) {
-            const transcriptPath = path.join(agDir, 'brain', convId, '.system_generated', 'logs', 'transcript.jsonl');
-            let messageCount = 0;
-            const times = sessionTimes();
-            for (const entry of convData.entries)
-                times.add(entry.timestamp);
-            let title = convData.title;
-            let sessionUsage;
-            let latestQuota;
-            try {
-                const transcriptContent = await fs.readFile(transcriptPath, 'utf-8');
-                const transcriptLines = transcriptContent.split('\n').filter(Boolean);
-                let firstUserMessage = null;
-                for (const line of transcriptLines) {
-                    try {
-                        const tObj = JSON.parse(line);
-                        times.add(tObj.timestamp);
-                        if (tObj.type === 'USER_INPUT' || tObj.type === 'PLANNER_RESPONSE') {
-                            messageCount++;
-                            if (tObj.type === 'USER_INPUT' && !firstUserMessage) {
-                                firstUserMessage = tObj.content;
+            for (const [convId, convData] of conversationsMap.entries()) {
+                const transcriptPath = path.join(agDir, 'brain', convId, '.system_generated', 'logs', 'transcript.jsonl');
+                let messageCount = 0;
+                const times = sessionTimes();
+                for (const entry of convData.entries)
+                    times.add(entry.timestamp);
+                let title = convData.title;
+                let sessionUsage;
+                let latestQuota;
+                try {
+                    const transcriptContent = await fs.readFile(transcriptPath, 'utf-8');
+                    const transcriptLines = transcriptContent.split('\n').filter(Boolean);
+                    let firstUserMessage = null;
+                    for (const line of transcriptLines) {
+                        try {
+                            const tObj = JSON.parse(line);
+                            times.add(tObj.timestamp);
+                            if (tObj.type === 'USER_INPUT' || tObj.type === 'PLANNER_RESPONSE') {
+                                messageCount++;
+                                if (tObj.type === 'USER_INPUT' && !firstUserMessage) {
+                                    firstUserMessage = tObj.content;
+                                }
                             }
+                            const { usage: turnUsage, quota: turnQuota } = extractRecordUsage(tObj);
+                            if (turnUsage)
+                                sessionUsage = accumulateUsage(sessionUsage, turnUsage);
+                            if (turnQuota)
+                                latestQuota = turnQuota;
                         }
-                        const { usage: turnUsage, quota: turnQuota } = extractRecordUsage(tObj);
-                        if (turnUsage)
-                            sessionUsage = accumulateUsage(sessionUsage, turnUsage);
-                        if (turnQuota)
-                            latestQuota = turnQuota;
+                        catch { }
+                    }
+                    if (firstUserMessage) {
+                        const cleanMatch = firstUserMessage.match(/<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/);
+                        title = cleanMatch ? cleanMatch[1].trim() : firstUserMessage.trim();
                     }
-                    catch { }
                 }
-                if (firstUserMessage) {
-                    const cleanMatch = firstUserMessage.match(/<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/);
-                    title = cleanMatch ? cleanMatch[1].trim() : firstUserMessage.trim();
+                catch {
+                    messageCount = convData.entries.length * 2;
                 }
+                sessions.push({
+                    id: convId,
+                    assistant: 'antigravity',
+                    title: sanitizeSessionTitle(title),
+                    ...times.values(),
+                    messageCount,
+                    workspacePath: resolveTargetCwd(convData.entries[0]?.workspace),
+                    recordedCwd: convData.entries[0]?.workspace,
+                    threadKind: 'unknown',
+                    ...(sessionUsage ? { usage: sessionUsage } : {}),
+                    ...(latestQuota ? { quota: latestQuota } : {}),
+                });
             }
-            catch {
-                messageCount = convData.entries.length * 2;
-            }
-            sessions.push({
-                id: convId,
-                assistant: 'antigravity',
-                title: sanitizeSessionTitle(title),
-                ...times.values(),
-                messageCount,
-                workspacePath: resolveTargetCwd(convData.entries[0]?.workspace),
-                recordedCwd: convData.entries[0]?.workspace,
-                threadKind: 'unknown',
-                ...(sessionUsage ? { usage: sessionUsage } : {}),
-                ...(latestQuota ? { quota: latestQuota } : {}),
-            });
         }
+        catch { }
     }
-    catch { }
     // ─── 2. Scan Claude Code Sessions ──────────────────────────────────────
-    const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
-    const claudeProjectsDir = path.join(claudeConfigDir, 'projects');
-    try {
-        const candidateTargets = [
-            { folder: getClaudeProjectFolderName(workspacePath), targetPath: workspacePath },
-            ...repoPaths.map(r => ({ folder: getClaudeProjectFolderName(r), targetPath: r }))
-        ];
-        for (const { folder, targetPath } of candidateTargets) {
-            const projectPath = path.join(claudeProjectsDir, folder);
-            try {
-                const files = await fs.readdir(projectPath);
-                const jsonlFiles = files.filter(f => f.endsWith('.jsonl'));
-                for (const file of jsonlFiles) {
-                    const filePath = path.join(projectPath, file);
-                    const sessionId = path.basename(file, '.jsonl');
-                    try {
-                        const content = await fs.readFile(filePath, 'utf-8');
-                        const lines = content.split('\n').filter(Boolean);
-                        let messageCount = 0;
-                        const times = sessionTimes();
-                        let title = 'Claude Session';
-                        let recordedCwd;
-                        let threadKind = file.startsWith('agent-') ? 'subagent' : 'unknown';
-                        let sessionUsage;
-                        let latestQuota;
-                        for (const line of lines) {
-                            let record;
-                            try {
-                                record = JSON.parse(line);
-                            }
-                            catch {
-                                continue;
-                            }
-                            times.add(record.timestamp);
-                            if (record.sessionId === sessionId && typeof record.cwd === 'string')
-                                recordedCwd ??= record.cwd;
-                            if (record.isSidechain === true)
-                                threadKind = 'subagent';
-                            else if (record.isSidechain === false && threadKind === 'unknown')
-                                threadKind = 'main';
-                            if (record.type === 'user' || record.type === 'assistant') {
-                                const text = claudeRecordText(record);
-                                // CLI-injected caveats, slash commands and tool results aren't
-                                // real turns — exclude them from the count and the title.
-                                const isNoise = record.type === 'user' && isNoiseUserRecord(record, text);
-                                if (isNoise)
+    if (!source || source === 'claude') {
+        const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+        const claudeProjectsDir = path.join(claudeConfigDir, 'projects');
+        try {
+            const candidateTargets = [
+                { folder: getClaudeProjectFolderName(workspacePath), targetPath: workspacePath },
+                ...repoPaths.map(r => ({ folder: getClaudeProjectFolderName(r), targetPath: r }))
+            ];
+            for (const { folder, targetPath } of candidateTargets) {
+                const projectPath = path.join(claudeProjectsDir, folder);
+                try {
+                    const files = await fs.readdir(projectPath);
+                    const jsonlFiles = files.filter(f => f.endsWith('.jsonl'));
+                    for (const file of jsonlFiles) {
+                        const filePath = path.join(projectPath, file);
+                        const sessionId = path.basename(file, '.jsonl');
+                        try {
+                            const content = await fs.readFile(filePath, 'utf-8');
+                            const lines = content.split('\n').filter(Boolean);
+                            let messageCount = 0;
+                            const times = sessionTimes();
+                            let title = 'Claude Session';
+                            let recordedCwd;
+                            let threadKind = file.startsWith('agent-') ? 'subagent' : 'unknown';
+                            let sessionUsage;
+                            let latestQuota;
+                            for (const line of lines) {
+                                let record;
+                                try {
+                                    record = JSON.parse(line);
+                                }
+                                catch {
                                     continue;
-                                messageCount++;
-                                if (record.type === 'user' && title === 'Claude Session' && text.trim()) {
-                                    title = text.trim();
                                 }
+                                times.add(record.timestamp);
+                                if (record.sessionId === sessionId && typeof record.cwd === 'string')
+                                    recordedCwd ??= record.cwd;
+                                if (record.isSidechain === true)
+                                    threadKind = 'subagent';
+                                else if (record.isSidechain === false && threadKind === 'unknown')
+                                    threadKind = 'main';
+                                if (record.type === 'user' || record.type === 'assistant') {
+                                    const text = claudeRecordText(record);
+                                    // CLI-injected caveats, slash commands and tool results aren't
+                                    // real turns — exclude them from the count and the title.
+                                    const isNoise = record.type === 'user' && isNoiseUserRecord(record, text);
+                                    if (isNoise)
+                                        continue;
+                                    messageCount++;
+                                    if (record.type === 'user' && title === 'Claude Session' && text.trim()) {
+                                        title = text.trim();
+                                    }
+                                }
+                                const { usage: turnUsage, quota: turnQuota } = extractRecordUsage(record);
+                                if (turnUsage)
+                                    sessionUsage = accumulateUsage(sessionUsage, turnUsage);
+                                if (turnQuota)
+                                    latestQuota = turnQuota;
                             }
-                            const { usage: turnUsage, quota: turnQuota } = extractRecordUsage(record);
-                            if (turnUsage)
-                                sessionUsage = accumulateUsage(sessionUsage, turnUsage);
-                            if (turnQuota)
-                                latestQuota = turnQuota;
+                            sessions.push({
+                                id: sessionId,
+                                assistant: 'claude',
+                                title: sanitizeSessionTitle(title),
+                                ...times.values(),
+                                messageCount,
+                                workspacePath: targetPath,
+                                recordedCwd,
+                                threadKind,
+                                ...(sessionUsage ? { usage: sessionUsage } : {}),
+                                ...(latestQuota ? { quota: latestQuota } : {}),
+                            });
                         }
-                        sessions.push({
-                            id: sessionId,
-                            assistant: 'claude',
-                            title: sanitizeSessionTitle(title),
-                            ...times.values(),
-                            messageCount,
-                            workspacePath: targetPath,
-                            recordedCwd,
-                            threadKind,
-                            ...(sessionUsage ? { usage: sessionUsage } : {}),
-                            ...(latestQuota ? { quota: latestQuota } : {}),
-                        });
+                        catch { }
                     }
-                    catch { }
                 }
+                catch { }
             }
-            catch { }
         }
+        catch { }
     }
-    catch { }
     // ─── 3. OpenAI Codex Sessions (rollout-*.jsonl) ──────────────────────────
-    // Codex writes a `session_meta` record (payload.cwd) followed by
-    // `response_item` records (payload.type==='message', role, content[].text).
-    const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-    const codexSessionsDir = path.join(codexHome, 'sessions');
-    try {
-        const codexFiles = await getFilesRecursively(codexSessionsDir, '.jsonl');
-        // Sort candidate rollout files so most recent / newest are scanned first
-        const sortedCodexFiles = [...codexFiles].sort((a, b) => b.localeCompare(a));
-        const MAX_CODEX_SCAN = 200;
-        const filesToScan = sortedCodexFiles.slice(0, MAX_CODEX_SCAN);
-        for (const file of filesToScan) {
-            try {
-                const header = await codexSessionHeader(file);
-                // Recent rollouts record cwd up front. Skip unrelated conversations
-                // before reading and parsing their full, sometimes very large logs.
-                if (header?.type === 'session_meta' && typeof header.payload?.cwd === 'string'
-                    && !isPathMatch(header.payload.cwd))
-                    continue;
-                const content = await fs.readFile(file, 'utf-8');
-                const lines = content.split('\n').filter(Boolean);
-                let sessionCwd = null;
-                let sessionId = null;
-                let messageCount = 0;
-                const times = sessionTimes();
-                let title = 'Codex Session';
-                let identity = { threadKind: 'unknown' };
-                let sessionUsage;
-                let reportedTotalUsage;
-                let latestQuota;
-                for (const line of lines) {
-                    let record;
-                    try {
-                        record = JSON.parse(line);
-                    }
-                    catch {
+    if (!source || source === 'codex') {
+        // Codex writes a `session_meta` record (payload.cwd) followed by
+        // `response_item` records (payload.type==='message', role, content[].text).
+        const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+        const codexSessionsDir = path.join(codexHome, 'sessions');
+        try {
+            const codexFiles = await getFilesRecursively(codexSessionsDir, '.jsonl');
+            // Sort candidate rollout files so most recent / newest are scanned first
+            const sortedCodexFiles = [...codexFiles].sort((a, b) => b.localeCompare(a));
+            const MAX_CODEX_SCAN = 200;
+            const filesToScan = sortedCodexFiles.slice(0, MAX_CODEX_SCAN);
+            for (const file of filesToScan) {
+                try {
+                    const header = await codexSessionHeader(file);
+                    // Recent rollouts record cwd up front. Skip unrelated conversations
+                    // before reading and parsing their full, sometimes very large logs.
+                    if (header?.type === 'session_meta' && typeof header.payload?.cwd === 'string'
+                        && !isPathMatch(header.payload.cwd))
                         continue;
-                    }
-                    times.add(record.timestamp);
-                    times.add(record.payload?.timestamp);
-                    if (record.type === 'session_meta') {
-                        if (record.payload?.cwd)
-                            sessionCwd = record.payload.cwd;
-                        sessionId = codexSessionId(record) ?? sessionId;
-                        identity = codexThreadIdentity(record.payload);
-                    }
-                    else if (record.type === 'response_item' && record.payload?.type === 'message') {
-                        const role = record.payload.role;
-                        if (role !== 'user' && role !== 'assistant')
-                            continue;
-                        const text = codexMessageText(record.payload).trim();
-                        if (role === 'user' && (!text || isInjectedContextText(text)))
+                    const content = await fs.readFile(file, 'utf-8');
+                    const lines = content.split('\n').filter(Boolean);
+                    let sessionCwd = null;
+                    let sessionId = null;
+                    let messageCount = 0;
+                    const times = sessionTimes();
+                    let title = 'Codex Session';
+                    let identity = { threadKind: 'unknown' };
+                    let sessionUsage;
+                    let reportedTotalUsage;
+                    let latestQuota;
+                    for (const line of lines) {
+                        let record;
+                        try {
+                            record = JSON.parse(line);
+                        }
+                        catch {
                             continue;
-                        messageCount++;
-                        if (role === 'user' && title === 'Codex Session' && text) {
-                            title = text;
                         }
-                    }
-                    // Interactive Codex writes cumulative totals in token_count events,
-                    // rather than a top-level usage field. Keep the latest total instead
-                    // of summing snapshots from each turn.
-                    if (record.type === 'event_msg' && record.payload?.type === 'token_count') {
-                        const total = record.payload.info?.total_token_usage;
-                        if (total) {
-                            const parsed = extractRecordUsage({ usage: total }).usage;
-                            if (parsed) {
-                                if (typeof total.cache_write_input_tokens === 'number') {
-                                    parsed.cachedInputTokens = (typeof total.cached_input_tokens === 'number' ? total.cached_input_tokens : 0)
-                                        + total.cache_write_input_tokens;
+                        times.add(record.timestamp);
+                        times.add(record.payload?.timestamp);
+                        if (record.type === 'session_meta') {
+                            if (record.payload?.cwd)
+                                sessionCwd = record.payload.cwd;
+                            sessionId = codexSessionId(record) ?? sessionId;
+                            identity = codexThreadIdentity(record.payload);
+                        }
+                        else if (record.type === 'response_item' && record.payload?.type === 'message') {
+                            const role = record.payload.role;
+                            if (role !== 'user' && role !== 'assistant')
+                                continue;
+                            const text = codexMessageText(record.payload).trim();
+                            if (role === 'user' && (!text || isInjectedContextText(text)))
+                                continue;
+                            messageCount++;
+                            if (role === 'user' && title === 'Codex Session' && text) {
+                                title = text;
+                            }
+                        }
+                        // Interactive Codex writes cumulative totals in token_count events,
+                        // rather than a top-level usage field. Keep the latest total instead
+                        // of summing snapshots from each turn.
+                        if (record.type === 'event_msg' && record.payload?.type === 'token_count') {
+                            const total = record.payload.info?.total_token_usage;
+                            if (total) {
+                                const parsed = extractRecordUsage({ usage: total }).usage;
+                                if (parsed) {
+                                    if (typeof total.cache_write_input_tokens === 'number') {
+                                        parsed.cachedInputTokens = (typeof total.cached_input_tokens === 'number' ? total.cached_input_tokens : 0)
+                                            + total.cache_write_input_tokens;
+                                    }
+                                    reportedTotalUsage = parsed;
                                 }
-                                reportedTotalUsage = parsed;
                             }
                         }
+                        const { usage: turnUsage, quota: turnQuota } = extractRecordUsage(record);
+                        if (turnUsage)
+                            sessionUsage = accumulateUsage(sessionUsage, turnUsage);
+                        if (turnQuota)
+                            latestQuota = turnQuota;
                     }
-                    const { usage: turnUsage, quota: turnQuota } = extractRecordUsage(record);
-                    if (turnUsage)
-                        sessionUsage = accumulateUsage(sessionUsage, turnUsage);
-                    if (turnQuota)
-                        latestQuota = turnQuota;
+                    // Match on the recorded cwd; fall back to a content scan for older files.
+                    const matched = sessionCwd
+                        ? isPathMatch(sessionCwd)
+                        : (content.toLowerCase().includes(normWorkspace) || content.includes(wsFolderName));
+                    if (!matched)
+                        continue;
+                    // Skip contentless sessions (only injected context, no real turns).
+                    if (messageCount === 0)
+                        continue;
+                    // Current rollout filenames include timestamps. The stable resume id is
+                    // session_meta.payload.id, not the filename.
+                    if (!sessionId)
+                        continue;
+                    sessions.push({
+                        id: sessionId,
+                        assistant: 'codex',
+                        title: sanitizeSessionTitle(title),
+                        ...times.values(),
+                        messageCount,
+                        workspacePath: resolveTargetCwd(sessionCwd || undefined),
+                        recordedCwd: sessionCwd ?? undefined,
+                        ...identity,
+                        ...((reportedTotalUsage ?? sessionUsage) ? { usage: reportedTotalUsage ?? sessionUsage } : {}),
+                        ...(latestQuota ? { quota: latestQuota } : {}),
+                    });
                 }
-                // Match on the recorded cwd; fall back to a content scan for older files.
-                const matched = sessionCwd
-                    ? isPathMatch(sessionCwd)
-                    : (content.toLowerCase().includes(normWorkspace) || content.includes(wsFolderName));
-                if (!matched)
-                    continue;
-                // Skip contentless sessions (only injected context, no real turns).
-                if (messageCount === 0)
-                    continue;
-                // Current rollout filenames include timestamps. The stable resume id is
-                // session_meta.payload.id, not the filename.
-                if (!sessionId)
-                    continue;
-                sessions.push({
-                    id: sessionId,
-                    assistant: 'codex',
-                    title: sanitizeSessionTitle(title),
-                    ...times.values(),
-                    messageCount,
-                    workspacePath: resolveTargetCwd(sessionCwd || undefined),
-                    recordedCwd: sessionCwd ?? undefined,
-                    ...identity,
-                    ...((reportedTotalUsage ?? sessionUsage) ? { usage: reportedTotalUsage ?? sessionUsage } : {}),
-                    ...(latestQuota ? { quota: latestQuota } : {}),
-                });
+                catch { }
             }
-            catch { }
         }
+        catch { }
     }
-    catch { }
     // ─── 4. GitHub Copilot Sessions (SQLite session store) ───────────────────
-    // Copilot keeps sessions in ~/.copilot/session-store.db: a `sessions` table
-    // (id, cwd, summary, timestamps) and a `turns` table (user_message /
-    // assistant_response per turn). Match on `cwd` like the other harnesses.
-    const copilotDb = await openCopilotDb();
-    if (copilotDb) {
-        try {
-            const rows = copilotDb.prepare('SELECT id, cwd, summary, created_at, updated_at FROM sessions').all();
-            for (const row of rows) {
-                if (!isPathMatch(row.cwd))
-                    continue;
-                const counted = copilotDb.prepare(`SELECT
+    if (!source || source === 'copilot') {
+        // Copilot keeps sessions in ~/.copilot/session-store.db: a `sessions` table
+        // (id, cwd, summary, timestamps) and a `turns` table (user_message /
+        // assistant_response per turn). Match on `cwd` like the other harnesses.
+        const copilotDb = await openCopilotDb();
+        if (copilotDb) {
+            try {
+                const rows = copilotDb.prepare('SELECT id, cwd, summary, created_at, updated_at FROM sessions').all();
+                for (const row of rows) {
+                    if (!isPathMatch(row.cwd))
+                        continue;
+                    const counted = copilotDb.prepare(`SELECT
              SUM(CASE WHEN TRIM(COALESCE(user_message, '')) != '' THEN 1 ELSE 0 END)
              + SUM(CASE WHEN TRIM(COALESCE(assistant_response, '')) != '' THEN 1 ELSE 0 END) AS n
            FROM turns WHERE session_id = ?`).get(row.id);
-                const messageCount = Number(counted?.n ?? 0);
-                let title = (row.summary || '').trim();
-                if (!title) {
-                    const first = copilotDb.prepare(`SELECT user_message FROM turns
+                    const messageCount = Number(counted?.n ?? 0);
+                    let title = (row.summary || '').trim();
+                    if (!title) {
+                        const first = copilotDb.prepare(`SELECT user_message FROM turns
              WHERE session_id = ? AND TRIM(COALESCE(user_message, '')) != ''
                AND TRIM(user_message) NOT LIKE '<%'
              ORDER BY turn_index LIMIT 1`).get(row.id);
-                    title = (first?.user_message || '').trim();
+                        title = (first?.user_message || '').trim();
+                    }
+                    // Skip contentless sessions (no summary and no turns).
+                    if (!title && messageCount === 0)
+                        continue;
+                    if (!title)
+                        title = 'Copilot Session';
+                    sessions.push({
+                        id: row.id,
+                        assistant: 'copilot',
+                        title: sanitizeSessionTitle(title),
+                        createdAt: sessionTimestamp(row.created_at) ?? '',
+                        updatedAt: sessionTimestamp(row.updated_at) ?? '',
+                        messageCount,
+                        workspacePath: resolveTargetCwd(row.cwd),
+                        recordedCwd: row.cwd,
+                        threadKind: 'unknown',
+                    });
                 }
-                // Skip contentless sessions (no summary and no turns).
-                if (!title && messageCount === 0)
-                    continue;
-                if (!title)
-                    title = 'Copilot Session';
-                sessions.push({
-                    id: row.id,
-                    assistant: 'copilot',
-                    title: sanitizeSessionTitle(title),
-                    createdAt: sessionTimestamp(row.created_at) ?? '',
-                    updatedAt: sessionTimestamp(row.updated_at) ?? '',
-                    messageCount,
-                    workspacePath: resolveTargetCwd(row.cwd),
-                    recordedCwd: row.cwd,
-                    threadKind: 'unknown',
-                });
             }
-        }
-        catch {
-            // Leave Copilot out rather than fail the whole listing.
-        }
-        finally {
-            try {
-                copilotDb.close();
+            catch {
+                // Leave Copilot out rather than fail the whole listing.
+            }
+            finally {
+                try {
+                    copilotDb.close();
+                }
+                catch { }
             }
-            catch { }
         }
     }
-    // ─── 5. Scan Workspace .sessions Directory ───────────────────────────────
-    try {
-        const wsSessionsDir = path.join(workspacePath, '.sessions');
-        const sessionFiles = await getFilesRecursively(wsSessionsDir, '.jsonl').catch(() => []);
-        for (const filePath of sessionFiles) {
-            try {
-                const content = await fs.readFile(filePath, 'utf-8');
-                const lines = content.split('\n').filter(Boolean);
-                if (lines.length === 0)
-                    continue;
-                let sessionId = path.basename(filePath, '.jsonl');
-                let assistant = 'claude';
-                let title = 'AI Session';
-                let messageCount = 0;
-                const times = sessionTimes();
-                let sessionUsage;
-                let latestQuota;
-                for (const line of lines) {
-                    let record;
-                    try {
-                        record = JSON.parse(line);
-                    }
-                    catch {
+    // ─── Modular history readers ────────────────────────────────────────────
+    const scanContext = { roots: [workspacePath, ...repoPaths], matchesCwd: isPathMatch, targetCwd: resolveTargetCwd };
+    for (const [id, reader] of Object.entries(MODULAR_SESSION_READERS)) {
+        if (!source || source === id)
+            sessions.push(...await reader.list(scanContext));
+    }
+    // ─── Scan Workspace .sessions Directory ──────────────────────────────────
+    if (!source || source === 'workspace') {
+        try {
+            const wsSessionsDir = path.join(workspacePath, '.sessions');
+            const sessionFiles = await getFilesRecursively(wsSessionsDir, '.jsonl').catch(() => []);
+            for (const filePath of sessionFiles) {
+                try {
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const lines = content.split('\n').filter(Boolean);
+                    if (lines.length === 0)
                         continue;
+                    let sessionId = path.basename(filePath, '.jsonl');
+                    let assistant = 'claude';
+                    let title = 'AI Session';
+                    let messageCount = 0;
+                    const times = sessionTimes();
+                    let sessionUsage;
+                    let latestQuota;
+                    for (const line of lines) {
+                        let record;
+                        try {
+                            record = JSON.parse(line);
+                        }
+                        catch {
+                            continue;
+                        }
+                        times.add(record.timestamp);
+                        if (record.sessionId)
+                            sessionId = record.sessionId;
+                        if (record.provider) {
+                            const p = String(record.provider).toLowerCase();
+                            if (p.includes('claude'))
+                                assistant = 'claude';
+                            else if (p.includes('codex'))
+                                assistant = 'codex';
+                            else if (p.includes('antigravity') || p.includes('gemini'))
+                                assistant = 'antigravity';
+                            else if (p.includes('copilot'))
+                                assistant = 'copilot';
+                            else if (p === 'pi')
+                                assistant = 'pi';
+                        }
+                        if (record.userPrompt && title === 'AI Session') {
+                            title = String(record.userPrompt).trim();
+                        }
+                        if (record.userPrompt || record.assistantResponse) {
+                            messageCount += (record.userPrompt ? 1 : 0) + (record.assistantResponse ? 1 : 0);
+                        }
+                        const { usage: turnUsage, quota: turnQuota } = extractRecordUsage(record);
+                        if (turnUsage)
+                            sessionUsage = accumulateUsage(sessionUsage, turnUsage);
+                        if (turnQuota)
+                            latestQuota = turnQuota;
                     }
-                    times.add(record.timestamp);
-                    if (record.sessionId)
-                        sessionId = record.sessionId;
-                    if (record.provider) {
-                        const p = String(record.provider).toLowerCase();
-                        if (p.includes('claude'))
-                            assistant = 'claude';
-                        else if (p.includes('codex'))
-                            assistant = 'codex';
-                        else if (p.includes('antigravity') || p.includes('gemini'))
-                            assistant = 'antigravity';
-                        else if (p.includes('copilot'))
-                            assistant = 'copilot';
-                    }
-                    if (record.userPrompt && title === 'AI Session') {
-                        title = String(record.userPrompt).trim();
-                    }
-                    if (record.userPrompt || record.assistantResponse) {
-                        messageCount += (record.userPrompt ? 1 : 0) + (record.assistantResponse ? 1 : 0);
+                    if (!sessions.some((s) => s.id === sessionId)) {
+                        sessions.push({
+                            id: sessionId,
+                            assistant,
+                            title: sanitizeSessionTitle(title),
+                            ...times.values(),
+                            messageCount: messageCount || lines.length,
+                            workspacePath,
+                            threadKind: 'unknown',
+                            ...(sessionUsage ? { usage: sessionUsage } : {}),
+                            ...(latestQuota ? { quota: latestQuota } : {}),
+                        });
                     }
-                    const { usage: turnUsage, quota: turnQuota } = extractRecordUsage(record);
-                    if (turnUsage)
-                        sessionUsage = accumulateUsage(sessionUsage, turnUsage);
-                    if (turnQuota)
-                        latestQuota = turnQuota;
-                }
-                if (!sessions.some((s) => s.id === sessionId)) {
-                    sessions.push({
-                        id: sessionId,
-                        assistant,
-                        title: sanitizeSessionTitle(title),
-                        ...times.values(),
-                        messageCount: messageCount || lines.length,
-                        workspacePath,
-                        threadKind: 'unknown',
-                        ...(sessionUsage ? { usage: sessionUsage } : {}),
-                        ...(latestQuota ? { quota: latestQuota } : {}),
-                    });
                 }
+                catch { }
             }
-            catch { }
         }
+        catch { }
     }
-    catch { }
     // Sort by updatedAt descending
     sessions.sort((a, b) => (Date.parse(b.updatedAt) || 0) - (Date.parse(a.updatedAt) || 0));
     return sessions;
@@ -879,7 +900,7 @@ export async function findSessions(workspacePath, repoPaths = []) {
  *
  * @param workspacePath - Root directory of the active workspace.
  * @param repoPaths - Directories of sub-repositories included in the workspace.
- * @returns A promise that resolves to an array of unique {@link AIAssistant} names.
+ * @returns A promise that resolves to an array of unique session assistant names.
  */
 // ─── High-Performance mtime-aware Session Caches ────────────────────────────
 let agHistoryCache = null;
@@ -1000,7 +1021,7 @@ async function getCodexCwds(codexHome) {
  *
  * @param workspacePath - Root directory of the active workspace.
  * @param repoPaths - Directories of sub-repositories included in the workspace.
- * @returns A promise that resolves to an array of unique {@link AIAssistant} names.
+ * @returns A promise that resolves to an array of unique session assistant names.
  */
 export async function findActiveAssistants(workspacePath, repoPaths = []) {
     const active = new Set();
@@ -1058,19 +1079,27 @@ export async function findActiveAssistants(workspacePath, repoPaths = []) {
     if (copilotCwds.some(isPathMatch)) {
         active.add('copilot');
     }
+    for (const [id, reader] of Object.entries(MODULAR_SESSION_READERS)) {
+        if (await reader.hasAny({ roots: [workspacePath, ...repoPaths], matchesCwd: isPathMatch }))
+            active.add(id);
+    }
     return Array.from(active);
 }
 /**
  * Reads and parses the full transcript for a specific assistant conversation session.
  *
- * @param assistant - The name of the AI assistant ('antigravity', 'claude', 'codex', 'copilot').
+ * @param assistant - The name of the AI assistant ('antigravity', 'claude', 'codex', 'copilot', 'pi').
  * @param sessionId - Unique ID of the conversation session.
  * @returns A promise that resolves to an array of {@link ChatMessage} objects.
  */
 export async function getSessionTranscript(assistant, sessionId) {
     assertSafeSessionId(assistant, sessionId);
     const messages = [];
-    if (assistant === 'antigravity') {
+    const modularReader = modularSessionReader(assistant);
+    if (modularReader) {
+        messages.push(...await modularReader.transcript(sessionId));
+    }
+    else if (assistant === 'antigravity') {
         const agDir = getAntigravityDir();
         const transcriptPath = path.join(agDir, 'brain', sessionId, '.system_generated', 'logs', 'transcript.jsonl');
         const content = await fs.readFile(transcriptPath, 'utf-8');