@ccpocket/bridge 1.5.2 → 1.6.0

package/dist/sessions-index.js

@@ -1,6 +1,62 @@
-import { readdir, readFile, writeFile, appendFile, stat } from "node:fs/promises";
+import { readdir, readFile, writeFile, appendFile, stat, open } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { homedir } from "node:os";
+function createRecentSessionsPerfStats() {
+    return {
+        claudeProjectDirs: 0,
+        claudeIndexDirs: 0,
+        claudeJsonlOnlyDirs: 0,
+        claudeIndexEntries: 0,
+        claudeJsonlFilesTotal: 0,
+        claudeJsonlFilesExcluded: 0,
+        claudeJsonlFilesRead: 0,
+        claudeJsonlEntries: 0,
+        codexFilesTotal: 0,
+        codexFilesRead: 0,
+        codexEntries: 0,
+        claudeNamedOnlyFastPathUsed: false,
+        counts: {
+            beforeArchive: 0,
+            afterArchive: 0,
+            afterProvider: 0,
+            afterNamedOnly: 0,
+            afterSearch: 0,
+            returned: 0,
+        },
+    };
+}
+function markDuration(durations, key, startedAt) {
+    const elapsedMs = Number(process.hrtime.bigint() - startedAt) / 1_000_000;
+    durations[key] = elapsedMs;
+}
+function shouldLogRecentSessionsPerf() {
+    const v = process.env.BRIDGE_RECENT_SESSIONS_PROFILE;
+    return v === "1" || v === "true";
+}
+function logRecentSessionsPerf(options, durations, stats) {
+    if (!shouldLogRecentSessionsPerf())
+        return;
+    const projectPath = options.projectPath;
+    const projectPathLabel = projectPath
+        ? projectPath.length > 72
+            ? `${projectPath.slice(0, 69)}...`
+            : projectPath
+        : "";
+    const payload = {
+        options: {
+            limit: options.limit ?? 20,
+            offset: options.offset ?? 0,
+            projectPath: projectPathLabel || undefined,
+            provider: options.provider ?? "all",
+            namedOnly: options.namedOnly ?? false,
+            searchQuery: options.searchQuery ? "<set>" : "<none>",
+            archivedSessionIds: options.archivedSessionIds?.size ?? 0,
+        },
+        durationsMs: Object.fromEntries(Object.entries(durations).map(([k, v]) => [k, Number(v.toFixed(1))])),
+        stats,
+    };
+    console.info(`[recent-sessions][perf] ${JSON.stringify(payload)}`);
+}
 /** Convert a filesystem path to Claude's project directory slug (e.g. /foo/bar → -foo-bar). */
 export function pathToSlug(p) {
     return p.replaceAll("/", "-").replaceAll("_", "-");
@@ -20,119 +76,279 @@ export function normalizeWorktreePath(p) {
 export function isWorktreeSlug(dirSlug, projectSlug) {
     return dirSlug.startsWith(projectSlug + "-worktrees-");
 }
+/** Concurrency limit for parallel file reads to avoid fd exhaustion. */
+const PARALLEL_FILE_READ_LIMIT = 32;
+/** Head/Tail byte sizes for partial JSONL reads. */
+const HEAD_BYTES = 16384; // 16KB — covers first user entry + metadata
+const TAIL_BYTES = 8192; // 8KB — covers last entries for modified/lastPrompt
 /**
- * Scan a directory for JSONL session files and create SessionIndexEntry objects.
- * Used as a fallback when sessions-index.json is missing (common for worktree sessions).
+ * Run async tasks with a concurrency limit.
+ * Returns results in the same order as the input tasks.
  */
-export async function scanJsonlDir(dirPath) {
-    const entries = [];
-    let files;
-    try {
-        files = await readdir(dirPath);
+async function parallelMap(items, concurrency, fn) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < items.length) {
+            const i = nextIndex++;
+            results[i] = await fn(items[i]);
+        }
     }
-    catch {
-        return entries;
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}
+// Regexes for fast field extraction without JSON.parse
+const RE_TYPE_USER = /"type"\s*:\s*"user"/;
+const RE_TYPE_ASSISTANT = /"type"\s*:\s*"assistant"/;
+const RE_TIMESTAMP = /"timestamp"\s*:\s*"([^"]+)"/;
+const RE_GIT_BRANCH = /"gitBranch"\s*:\s*"([^"]+)"/;
+const RE_CWD = /"cwd"\s*:\s*"([^"]+)"/;
+const RE_IS_SIDECHAIN = /"isSidechain"\s*:\s*true/;
+/** Extract user prompt text from a parsed JSONL entry. */
+function extractUserPromptText(entry) {
+    const message = entry.message;
+    if (!message?.content)
+        return "";
+    if (typeof message.content === "string")
+        return message.content;
+    if (Array.isArray(message.content)) {
+        const textBlock = message.content.find((c) => c.type === "text" && c.text);
+        return textBlock?.text ?? "";
     }
-    for (const file of files) {
-        if (!file.endsWith(".jsonl"))
+    return "";
+}
+/**
+ * Parse head and optional tail text chunks to build a SessionIndexEntry.
+ * Uses regex for most fields, JSON.parse only for first/last user lines.
+ */
+function parseFromChunks(sessionId, head, tail) {
+    let firstPrompt = "";
+    let lastPrompt = "";
+    let created = "";
+    let modified = "";
+    let gitBranch = "";
+    let projectPath = "";
+    let isSidechain = false;
+    let hasAnyMessage = false;
+    // --- Scan head lines ---
+    const headLines = head.split("\n");
+    for (const line of headLines) {
+        if (!line.trim())
             continue;
-        const sessionId = basename(file, ".jsonl");
-        const filePath = join(dirPath, file);
-        let raw;
-        try {
-            raw = await readFile(filePath, "utf-8");
-        }
-        catch {
+        const isUser = RE_TYPE_USER.test(line);
+        const isAssistant = !isUser && RE_TYPE_ASSISTANT.test(line);
+        if (!isUser && !isAssistant)
             continue;
+        hasAnyMessage = true;
+        const tsMatch = line.match(RE_TIMESTAMP);
+        if (tsMatch) {
+            if (!created)
+                created = tsMatch[1];
+            modified = tsMatch[1];
         }
-        const lines = raw.split("\n");
-        let firstPrompt = "";
-        let lastPrompt = "";
-        let messageCount = 0;
-        let created = "";
-        let modified = "";
-        let gitBranch = "";
-        let projectPath = "";
-        let isSidechain = false;
-        let summary;
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            let entry;
+        if (!gitBranch) {
+            const gbMatch = line.match(RE_GIT_BRANCH);
+            if (gbMatch)
+                gitBranch = gbMatch[1];
+        }
+        if (!projectPath) {
+            const cwdMatch = line.match(RE_CWD);
+            if (cwdMatch)
+                projectPath = normalizeWorktreePath(cwdMatch[1]);
+        }
+        if (!isSidechain && RE_IS_SIDECHAIN.test(line)) {
+            isSidechain = true;
+        }
+        if (isUser && !firstPrompt) {
+            // JSON.parse only the first user line to extract prompt text
             try {
-                entry = JSON.parse(line);
+                const entry = JSON.parse(line);
+                firstPrompt = extractUserPromptText(entry);
             }
-            catch {
+            catch { /* skip */ }
+        }
+    }
+    // --- Scan tail lines (if separate from head) ---
+    if (tail) {
+        const tailLines = tail.split("\n");
+        // Find last timestamp and last user prompt from tail (scan in reverse)
+        let lastUserLine = null;
+        for (let i = tailLines.length - 1; i >= 0; i--) {
+            const line = tailLines[i];
+            if (!line.trim())
                 continue;
-            }
-            const type = entry.type;
-            if (type === "summary" && entry.summary) {
-                summary = entry.summary;
-            }
-            if (type !== "user" && type !== "assistant")
+            const isUser = RE_TYPE_USER.test(line);
+            const isAssistant = !isUser && RE_TYPE_ASSISTANT.test(line);
+            if (!isUser && !isAssistant)
                 continue;
-            messageCount++;
-            const timestamp = entry.timestamp;
-            if (timestamp) {
-                if (!created)
-                    created = timestamp;
-                modified = timestamp;
+            hasAnyMessage = true;
+            // Get the last modified timestamp
+            if (!modified || true) {
+                // Always update modified from tail (tail is later in file)
+                const tsMatch = line.match(RE_TIMESTAMP);
+                if (tsMatch) {
+                    modified = tsMatch[1];
+                    // We found the last message — we're done with timestamps
+                    if (isUser && !lastUserLine)
+                        lastUserLine = line;
+                    break;
+                }
             }
-            if (!gitBranch && entry.gitBranch) {
-                gitBranch = entry.gitBranch;
+        }
+        // Also find last user line if not found in reverse timestamp scan
+        if (!lastUserLine) {
+            for (let i = tailLines.length - 1; i >= 0; i--) {
+                const line = tailLines[i];
+                if (!line.trim())
+                    continue;
+                if (RE_TYPE_USER.test(line)) {
+                    lastUserLine = line;
+                    break;
+                }
             }
-            if (!projectPath && entry.cwd) {
-                projectPath = normalizeWorktreePath(entry.cwd);
+        }
+        // JSON.parse only the last user line for lastPrompt
+        if (lastUserLine) {
+            try {
+                const entry = JSON.parse(lastUserLine);
+                const text = extractUserPromptText(entry);
+                if (text)
+                    lastPrompt = text;
             }
-            if (type === "user") {
-                const message = entry.message;
-                if (message?.content) {
-                    let text = "";
-                    if (typeof message.content === "string") {
-                        text = message.content;
-                    }
-                    else if (Array.isArray(message.content)) {
-                        const textBlock = message.content.find((c) => c.type === "text" && c.text);
-                        if (textBlock?.text) {
-                            text = textBlock.text;
-                        }
-                    }
-                    if (text) {
-                        if (!firstPrompt)
-                            firstPrompt = text;
-                        lastPrompt = text;
-                    }
+            catch { /* skip */ }
+        }
+        // Fill in metadata from tail if head didn't have it
+        if (!gitBranch || !projectPath) {
+            for (const line of tailLines) {
+                if (!line.trim())
+                    continue;
+                if (!RE_TYPE_USER.test(line) && !RE_TYPE_ASSISTANT.test(line))
+                    continue;
+                if (!gitBranch) {
+                    const gbMatch = line.match(RE_GIT_BRANCH);
+                    if (gbMatch)
+                        gitBranch = gbMatch[1];
                 }
-            }
-            if (entry.isSidechain) {
-                isSidechain = true;
+                if (!projectPath) {
+                    const cwdMatch = line.match(RE_CWD);
+                    if (cwdMatch)
+                        projectPath = normalizeWorktreePath(cwdMatch[1]);
+                }
+                if (gitBranch && projectPath)
+                    break;
             }
         }
-        if (messageCount > 0) {
-            entries.push({
-                sessionId,
-                provider: "claude",
-                summary,
-                firstPrompt,
-                ...(lastPrompt && lastPrompt !== firstPrompt ? { lastPrompt } : {}),
-                messageCount,
-                created,
-                modified,
-                gitBranch,
-                projectPath,
-                isSidechain,
-            });
+    }
+    if (!hasAnyMessage)
+        return null;
+    return {
+        sessionId,
+        provider: "claude",
+        firstPrompt,
+        ...(lastPrompt && lastPrompt !== firstPrompt ? { lastPrompt } : {}),
+        created,
+        modified,
+        gitBranch,
+        projectPath,
+        isSidechain,
+    };
+}
+/**
+ * Fast parse a Claude JSONL file using partial (head+tail) reads.
+ * Only reads the first 16KB and last 8KB of the file, avoiding full I/O.
+ * JSON.parse is called at most twice (first + last user lines).
+ */
+async function parseClaudeJsonlFileFast(sessionId, filePath) {
+    let fh;
+    try {
+        fh = await open(filePath, "r");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const fileStat = await fh.stat();
+        const fileSize = fileStat.size;
+        if (fileSize === 0)
+            return null;
+        // Small files: read entirely (no benefit from partial reads)
+        if (fileSize <= HEAD_BYTES + TAIL_BYTES) {
+            const buf = Buffer.alloc(fileSize);
+            await fh.read(buf, 0, fileSize, 0);
+            return parseFromChunks(sessionId, buf.toString("utf-8"), null);
         }
+        // Head read
+        const headBuf = Buffer.alloc(HEAD_BYTES);
+        await fh.read(headBuf, 0, HEAD_BYTES, 0);
+        const headStr = headBuf.toString("utf-8");
+        // Tail read — discard the first partial line
+        const tailBuf = Buffer.alloc(TAIL_BYTES);
+        await fh.read(tailBuf, 0, TAIL_BYTES, fileSize - TAIL_BYTES);
+        const tailRaw = tailBuf.toString("utf-8");
+        const firstNewline = tailRaw.indexOf("\n");
+        const cleanTail = firstNewline >= 0 ? tailRaw.slice(firstNewline + 1) : "";
+        return parseFromChunks(sessionId, headStr, cleanTail);
     }
-    return entries;
+    finally {
+        await fh.close();
+    }
+}
+/**
+ * Scan a directory for JSONL session files and create SessionIndexEntry objects.
+ * Used as a fallback when sessions-index.json is missing (common for worktree sessions).
+ * File reads are parallelized and use head+tail partial reads for performance.
+ */
+export async function scanJsonlDir(dirPath, options = {}) {
+    const scanStats = options.stats;
+    let files;
+    try {
+        files = await readdir(dirPath);
+    }
+    catch {
+        return [];
+    }
+    // Filter to JSONL files and apply exclusions
+    const targets = [];
+    for (const file of files) {
+        if (!file.endsWith(".jsonl"))
+            continue;
+        scanStats && (scanStats.filesTotal += 1);
+        const sessionId = basename(file, ".jsonl");
+        if (options.excludeSessionIds?.has(sessionId)) {
+            scanStats && (scanStats.filesExcluded += 1);
+            continue;
+        }
+        targets.push({ sessionId, filePath: join(dirPath, file) });
+    }
+    // Read and parse files in parallel using fast head+tail reads
+    const results = await parallelMap(targets, PARALLEL_FILE_READ_LIMIT, async ({ sessionId, filePath }) => {
+        const entry = await parseClaudeJsonlFileFast(sessionId, filePath);
+        if (entry) {
+            scanStats && (scanStats.filesRead += 1);
+            scanStats && (scanStats.entriesReturned += 1);
+        }
+        else {
+            scanStats && (scanStats.filesRead += 1);
+        }
+        return entry;
+    });
+    return results.filter((e) => e !== null);
 }
 export async function getAllRecentSessions(options = {}) {
+    const totalStartedAt = process.hrtime.bigint();
+    const durations = {};
+    const perfStats = createRecentSessionsPerfStats();
     const limit = options.limit ?? 20;
     const offset = options.offset ?? 0;
     const filterProjectPath = options.projectPath;
+    const shouldLoadClaude = options.provider !== "codex";
+    const shouldLoadCodex = options.provider !== "claude";
+    const includeOnlyNamedClaude = options.namedOnly === true;
     const projectsDir = join(homedir(), ".claude", "projects");
     const entries = [];
     let projectDirs;
+    const loadProjectDirsStartedAt = process.hrtime.bigint();
     try {
         projectDirs = await readdir(projectsDir);
     }
@@ -140,94 +356,161 @@ export async function getAllRecentSessions(options = {}) {
         // ~/.claude/projects doesn't exist
         projectDirs = [];
     }
+    markDuration(durations, "loadClaudeProjectDirs", loadProjectDirsStartedAt);
     // Compute worktree slug prefix for projectPath filtering
     const projectSlug = filterProjectPath
         ? pathToSlug(filterProjectPath)
         : null;
-    for (const dirName of projectDirs) {
-        // Skip hidden directories
-        if (dirName.startsWith("."))
-            continue;
-        // When filtering by project, skip unrelated directories early
-        const isProjectDir = projectSlug ? dirName === projectSlug : false;
-        const isWorktreeDir = projectSlug
-            ? isWorktreeSlug(dirName, projectSlug)
-            : false;
-        if (filterProjectPath && !isProjectDir && !isWorktreeDir)
-            continue;
-        const dirPath = join(projectsDir, dirName);
-        const indexPath = join(dirPath, "sessions-index.json");
-        let raw = null;
-        try {
-            raw = await readFile(indexPath, "utf-8");
-        }
-        catch {
-            // No sessions-index.json — will try JSONL scan for worktree dirs
+    // --- Load Claude and Codex sessions in parallel ---
+    const loadClaudeStartedAt = process.hrtime.bigint();
+    const claudeEntriesPromise = (async () => {
+        if (!shouldLoadClaude)
+            return [];
+        // Filter directories first (sync), then process in parallel
+        const relevantDirs = [];
+        for (const dirName of projectDirs) {
+            if (dirName.startsWith("."))
+                continue;
+            const isProjectDir = projectSlug ? dirName === projectSlug : false;
+            const isWorktreeDir = projectSlug
+                ? isWorktreeSlug(dirName, projectSlug)
+                : false;
+            if (filterProjectPath && !isProjectDir && !isWorktreeDir)
+                continue;
+            relevantDirs.push(dirName);
         }
-        if (raw !== null) {
-            // Parse sessions-index.json
-            let index;
+        perfStats.claudeProjectDirs = relevantDirs.length;
+        // Process directories in parallel
+        const dirResults = await parallelMap(relevantDirs, PARALLEL_FILE_READ_LIMIT, async (dirName) => {
+            const dirPath = join(projectsDir, dirName);
+            const indexPath = join(dirPath, "sessions-index.json");
+            let raw = null;
             try {
-                index = JSON.parse(raw);
+                raw = await readFile(indexPath, "utf-8");
             }
             catch {
-                console.error(`[sessions-index] Failed to parse ${indexPath}`);
-                continue;
+                // No sessions-index.json — will try JSONL scan for worktree dirs
             }
-            if (!Array.isArray(index.entries))
-                continue;
-            const indexedIds = new Set();
-            for (const entry of index.entries) {
-                indexedIds.add(entry.sessionId);
-                const mapped = {
-                    sessionId: entry.sessionId,
-                    provider: "claude",
-                    name: entry.customTitle || undefined,
-                    summary: entry.summary,
-                    firstPrompt: entry.firstPrompt ?? "",
-                    messageCount: entry.messageCount ?? 0,
-                    created: entry.created ?? "",
-                    modified: entry.modified ?? "",
-                    gitBranch: entry.gitBranch ?? "",
-                    projectPath: normalizeWorktreePath(entry.projectPath ?? ""),
-                    isSidechain: entry.isSidechain ?? false,
-                };
-                entries.push(mapped);
+            const result = {
+                entries: [],
+                indexDirs: 0,
+                indexEntries: 0,
+                jsonlOnlyDirs: 0,
+                jsonlStats: { filesTotal: 0, filesExcluded: 0, filesRead: 0, entriesReturned: 0 },
+            };
+            if (raw !== null) {
+                result.indexDirs = 1;
+                let index;
+                try {
+                    index = JSON.parse(raw);
+                }
+                catch {
+                    console.error(`[sessions-index] Failed to parse ${indexPath}`);
+                    return result;
+                }
+                if (!Array.isArray(index.entries))
+                    return result;
+                const indexedIds = new Set();
+                for (const entry of index.entries) {
+                    const name = entry.customTitle || undefined;
+                    if (includeOnlyNamedClaude && (!name || name === "")) {
+                        continue;
+                    }
+                    indexedIds.add(entry.sessionId);
+                    result.entries.push({
+                        sessionId: entry.sessionId,
+                        provider: "claude",
+                        name,
+                        summary: entry.summary,
+                        firstPrompt: entry.firstPrompt ?? "",
+                        created: entry.created ?? "",
+                        modified: entry.modified ?? "",
+                        gitBranch: entry.gitBranch ?? "",
+                        projectPath: normalizeWorktreePath(entry.projectPath ?? ""),
+                        isSidechain: entry.isSidechain ?? false,
+                    });
+                    result.indexEntries += 1;
+                }
+                if (!includeOnlyNamedClaude) {
+                    const scanned = await scanJsonlDir(dirPath, {
+                        excludeSessionIds: indexedIds,
+                        stats: result.jsonlStats,
+                    });
+                    result.entries.push(...scanned);
+                }
+                else {
+                    perfStats.claudeNamedOnlyFastPathUsed = true;
+                }
             }
-            // Supplement: scan JSONL files not covered by the index.
-            // Claude CLI may not register every session (e.g. `claude -r` resumes)
-            // into sessions-index.json, so we pick up any orphaned JSONL files here.
-            const scanned = await scanJsonlDir(dirPath);
-            for (const s of scanned) {
-                if (!indexedIds.has(s.sessionId)) {
-                    entries.push(s);
+            else {
+                if (includeOnlyNamedClaude) {
+                    perfStats.claudeNamedOnlyFastPathUsed = true;
+                    return result;
                 }
+                result.jsonlOnlyDirs = 1;
+                const scanned = await scanJsonlDir(dirPath, { stats: result.jsonlStats });
+                result.entries.push(...scanned);
             }
+            return result;
+        });
+        // Aggregate stats and entries
+        const allEntries = [];
+        for (const r of dirResults) {
+            allEntries.push(...r.entries);
+            perfStats.claudeIndexDirs += r.indexDirs;
+            perfStats.claudeIndexEntries += r.indexEntries;
+            perfStats.claudeJsonlOnlyDirs += r.jsonlOnlyDirs;
+            perfStats.claudeJsonlFilesTotal += r.jsonlStats.filesTotal;
+            perfStats.claudeJsonlFilesExcluded += r.jsonlStats.filesExcluded;
+            perfStats.claudeJsonlFilesRead += r.jsonlStats.filesRead;
+            perfStats.claudeJsonlEntries += r.jsonlStats.entriesReturned;
         }
-        else {
-            // No sessions-index.json: scan JSONL files directly.
-            // Directories are already filtered above, so all remaining dirs are relevant.
-            const scanned = await scanJsonlDir(dirPath);
-            entries.push(...scanned);
-        }
-    }
-    const codexEntries = await getAllRecentCodexSessions({
-        projectPath: filterProjectPath,
-    });
-    entries.push(...codexEntries);
+        return allEntries;
+    })();
+    const loadCodexStartedAt = process.hrtime.bigint();
+    const codexEntriesPromise = (async () => {
+        if (!shouldLoadCodex)
+            return [];
+        const codexPerf = {
+            filesTotal: 0,
+            filesRead: 0,
+            entriesReturned: 0,
+        };
+        const codexEntries = await getAllRecentCodexSessions({
+            projectPath: filterProjectPath,
+            perfStats: codexPerf,
+        });
+        perfStats.codexFilesTotal = codexPerf.filesTotal;
+        perfStats.codexFilesRead = codexPerf.filesRead;
+        perfStats.codexEntries = codexPerf.entriesReturned;
+        return codexEntries;
+    })();
+    // Wait for both Claude and Codex loading to complete in parallel
+    const [claudeEntries, codexEntries] = await Promise.all([
+        claudeEntriesPromise,
+        codexEntriesPromise,
+    ]);
+    markDuration(durations, "loadClaudeSessions", loadClaudeStartedAt);
+    markDuration(durations, "loadCodexSessions", loadCodexStartedAt);
+    // Combine results
+    entries.push(...claudeEntries, ...codexEntries);
     // Filter out archived sessions
     const archivedIds = options.archivedSessionIds;
     let filtered = archivedIds
         ? entries.filter((e) => !archivedIds.has(e.sessionId))
         : [...entries];
+    perfStats.counts.beforeArchive = entries.length;
+    perfStats.counts.afterArchive = filtered.length;
     // Filter by provider
     if (options.provider) {
         filtered = filtered.filter((e) => e.provider === options.provider);
     }
+    perfStats.counts.afterProvider = filtered.length;
     // Filter named only
     if (options.namedOnly) {
         filtered = filtered.filter((e) => e.name != null && e.name !== "");
     }
+    perfStats.counts.afterNamedOnly = filtered.length;
     // Filter by search query (name, firstPrompt, lastPrompt, summary)
     if (options.searchQuery) {
         const q = options.searchQuery.toLowerCase();
@@ -236,14 +519,22 @@ export async function getAllRecentSessions(options = {}) {
             e.lastPrompt?.toLowerCase().includes(q) ||
             e.summary?.toLowerCase().includes(q));
     }
+    perfStats.counts.afterSearch = filtered.length;
     // Sort by modified descending
+    const sortStartedAt = process.hrtime.bigint();
     filtered.sort((a, b) => {
         const ta = new Date(a.modified).getTime();
         const tb = new Date(b.modified).getTime();
         return tb - ta;
     });
+    markDuration(durations, "sortSessions", sortStartedAt);
+    const paginateStartedAt = process.hrtime.bigint();
     const sliced = filtered.slice(offset, offset + limit);
     const hasMore = offset + limit < filtered.length;
+    perfStats.counts.returned = sliced.length;
+    markDuration(durations, "paginate", paginateStartedAt);
+    markDuration(durations, "total", totalStartedAt);
+    logRecentSessionsPerf(options, durations, perfStats);
     return { sessions: sliced, hasMore };
 }
 async function listCodexSessionFiles() {
@@ -254,24 +545,17 @@ async function listCodexSessionFiles() {
         const dir = stack.pop();
         let children;
         try {
-            children = await readdir(dir);
+            children = await readdir(dir, { withFileTypes: true });
         }
         catch {
             continue;
         }
         for (const child of children) {
-            const p = join(dir, child);
-            let st;
-            try {
-                st = await stat(p);
-            }
-            catch {
-                continue;
-            }
-            if (st.isDirectory()) {
+            const p = join(dir, child.name);
+            if (child.isDirectory()) {
                 stack.push(p);
             }
-            else if (st.isFile() && p.endsWith(".jsonl")) {
+            else if (child.isFile() && p.endsWith(".jsonl")) {
                 files.push(p);
             }
         }
@@ -289,7 +573,7 @@ function parseCodexSessionJsonl(raw, fallbackSessionId) {
     let firstPrompt = "";
     let lastPrompt = "";
     let summary = "";
-    let messageCount = 0;
+    let hasMessages = false;
     let lastAssistantText = "";
     // Settings extracted from the first turn_context entry
     let approvalPolicy;
@@ -362,7 +646,7 @@ function parseCodexSessionJsonl(raw, fallbackSessionId) {
         if (entry.type === "event_msg") {
             const payload = entry.payload;
             if (payload?.type === "user_message" && typeof payload.message === "string") {
-                messageCount += 1;
+                hasMessages = true;
                 if (!firstPrompt)
                     firstPrompt = payload.message;
                 lastPrompt = payload.message;
@@ -383,12 +667,12 @@ function parseCodexSessionJsonl(raw, fallbackSessionId) {
                 .join("\n")
                 .trim();
             if (text.length > 0) {
-                messageCount += 1;
+                hasMessages = true;
                 lastAssistantText = text;
             }
         }
     }
-    if (!projectPath || messageCount === 0)
+    if (!projectPath || !hasMessages)
         return null;
     summary = lastAssistantText || summary;
     const codexSettings = (approvalPolicy
@@ -414,7 +698,6 @@ function parseCodexSessionJsonl(raw, fallbackSessionId) {
             summary: summary || undefined,
             firstPrompt,
             ...(lastPrompt && lastPrompt !== firstPrompt ? { lastPrompt } : {}),
-            messageCount,
             created,
             modified,
             gitBranch,
@@ -494,7 +777,6 @@ export async function renameClaudeSession(projectPath, claudeSessionId, name) {
     let firstPrompt = "";
     let created = new Date().toISOString();
     let modified = created;
-    let messageCount = 0;
     let gitBranch = "";
     try {
         const raw = await readFile(jsonlPath, "utf-8");
@@ -506,7 +788,6 @@ export async function renameClaudeSession(projectPath, claudeSessionId, name) {
                 const type = entry.type;
                 if (type !== "user" && type !== "assistant")
                     continue;
-                messageCount++;
                 const ts = entry.timestamp;
                 if (ts) {
                     if (!firstPrompt)
@@ -539,7 +820,7 @@ export async function renameClaudeSession(projectPath, claudeSessionId, name) {
         fileMtime: Date.now(),
         firstPrompt,
         customTitle: name,
-        messageCount,
+        messageCount: 0,
         created,
         modified,
         gitBranch,
@@ -603,6 +884,7 @@ export async function renameCodexSession(threadId, name) {
 async function getAllRecentCodexSessions(options = {}) {
     const files = await listCodexSessionFiles();
     const entries = [];
+    options.perfStats && (options.perfStats.filesTotal = files.length);
     const normalizedProjectPath = options.projectPath
         ? normalizeWorktreePath(options.projectPath)
         : null;
@@ -616,6 +898,7 @@ async function getAllRecentCodexSessions(options = {}) {
         catch {
             continue;
         }
+        options.perfStats && (options.perfStats.filesRead += 1);
         const fallbackSessionId = basename(filePath, ".jsonl");
         const parsed = parseCodexSessionJsonl(raw, fallbackSessionId);
         if (!parsed)
@@ -629,6 +912,7 @@ async function getAllRecentCodexSessions(options = {}) {
             parsed.entry.name = threadName;
         }
         entries.push(parsed.entry);
+        options.perfStats && (options.perfStats.entriesReturned += 1);
     }
     return entries;
 }