@pixelbyte-software/pixcode 1.30.0

package/dist-server/server/projects.js

@@ -0,0 +1,2492 @@
+/**
+ * PROJECT DISCOVERY AND MANAGEMENT SYSTEM
+ * ========================================
+ *
+ * This module manages project discovery for both Claude CLI and Cursor CLI sessions.
+ *
+ * ## Architecture Overview
+ *
+ * 1. **Claude Projects** (stored in ~/.claude/projects/)
+ *    - Each project is a directory named with the project path encoded (/ replaced with -)
+ *    - Contains .jsonl files with conversation history including 'cwd' field
+ *    - Project metadata stored in ~/.claude/project-config.json
+ *
+ * 2. **Cursor Projects** (stored in ~/.cursor/chats/)
+ *    - Each project directory is named with MD5 hash of the absolute project path
+ *    - Example: /Users/john/myproject -> MD5 -> a1b2c3d4e5f6...
+ *    - Contains session directories with SQLite databases (store.db)
+ *    - Project path is NOT stored in the database - only in the MD5 hash
+ *
+ * ## Project Discovery Strategy
+ *
+ * 1. **Claude Projects Discovery**:
+ *    - Scan ~/.claude/projects/ directory for Claude project folders
+ *    - Extract actual project path from .jsonl files (cwd field)
+ *    - Fall back to decoded directory name if no sessions exist
+ *
+ * 2. **Cursor Sessions Discovery**:
+ *    - For each KNOWN project (from Claude or manually added)
+ *    - Compute MD5 hash of the project's absolute path
+ *    - Check if ~/.cursor/chats/{md5_hash}/ directory exists
+ *    - Read session metadata from SQLite store.db files
+ *
+ * 3. **Manual Project Addition**:
+ *    - Users can manually add project paths via UI
+ *    - Stored in ~/.claude/project-config.json with 'manuallyAdded' flag
+ *    - Allows discovering Cursor sessions for projects without Claude sessions
+ *
+ * ## Critical Limitations
+ *
+ * - **CANNOT discover Cursor-only projects**: From a quick check, there was no mention of
+ *   the cwd of each project. if someone has the time, you can try to reverse engineer it.
+ *
+ * - **Project relocation breaks history**: If a project directory is moved or renamed,
+ *   the MD5 hash changes, making old Cursor sessions inaccessible unless the old
+ *   path is known and manually added.
+ *
+ * ## Error Handling
+ *
+ * - Missing ~/.claude directory is handled gracefully with automatic creation
+ * - ENOENT errors are caught and handled without crashing
+ * - Empty arrays returned when no projects/sessions exist
+ *
+ * ## Caching Strategy
+ *
+ * - Project directory extraction is cached to minimize file I/O
+ * - Cache is cleared when project configuration changes
+ * - Session data is fetched on-demand, not cached
+ */
+import { promises as fs } from 'fs';
+import fsSync from 'fs';
+import path from 'path';
+import readline from 'readline';
+import crypto from 'crypto';
+import Database from 'better-sqlite3';
+import os from 'os';
+import sessionManager from './sessionManager.js';
+import { applyCustomSessionNames } from './database/db.js';
+// Import TaskMaster detection functions
+async function detectTaskMasterFolder(projectPath) {
+    try {
+        const taskMasterPath = path.join(projectPath, '.taskmaster');
+        // Check if .taskmaster directory exists
+        try {
+            const stats = await fs.stat(taskMasterPath);
+            if (!stats.isDirectory()) {
+                return {
+                    hasTaskmaster: false,
+                    reason: '.taskmaster exists but is not a directory'
+                };
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return {
+                    hasTaskmaster: false,
+                    reason: '.taskmaster directory not found'
+                };
+            }
+            throw error;
+        }
+        // Check for key TaskMaster files
+        const keyFiles = [
+            'tasks/tasks.json',
+            'config.json'
+        ];
+        const fileStatus = {};
+        let hasEssentialFiles = true;
+        for (const file of keyFiles) {
+            const filePath = path.join(taskMasterPath, file);
+            try {
+                await fs.access(filePath);
+                fileStatus[file] = true;
+            }
+            catch (error) {
+                fileStatus[file] = false;
+                if (file === 'tasks/tasks.json') {
+                    hasEssentialFiles = false;
+                }
+            }
+        }
+        // Parse tasks.json if it exists for metadata
+        let taskMetadata = null;
+        if (fileStatus['tasks/tasks.json']) {
+            try {
+                const tasksPath = path.join(taskMasterPath, 'tasks/tasks.json');
+                const tasksContent = await fs.readFile(tasksPath, 'utf8');
+                const tasksData = JSON.parse(tasksContent);
+                // Handle both tagged and legacy formats
+                let tasks = [];
+                if (tasksData.tasks) {
+                    // Legacy format
+                    tasks = tasksData.tasks;
+                }
+                else {
+                    // Tagged format - get tasks from all tags
+                    Object.values(tasksData).forEach(tagData => {
+                        if (tagData.tasks) {
+                            tasks = tasks.concat(tagData.tasks);
+                        }
+                    });
+                }
+                // Calculate task statistics
+                const stats = tasks.reduce((acc, task) => {
+                    acc.total++;
+                    acc[task.status] = (acc[task.status] || 0) + 1;
+                    // Count subtasks
+                    if (task.subtasks) {
+                        task.subtasks.forEach(subtask => {
+                            acc.subtotalTasks++;
+                            acc.subtasks = acc.subtasks || {};
+                            acc.subtasks[subtask.status] = (acc.subtasks[subtask.status] || 0) + 1;
+                        });
+                    }
+                    return acc;
+                }, {
+                    total: 0,
+                    subtotalTasks: 0,
+                    pending: 0,
+                    'in-progress': 0,
+                    done: 0,
+                    review: 0,
+                    deferred: 0,
+                    cancelled: 0,
+                    subtasks: {}
+                });
+                taskMetadata = {
+                    taskCount: stats.total,
+                    subtaskCount: stats.subtotalTasks,
+                    completed: stats.done || 0,
+                    pending: stats.pending || 0,
+                    inProgress: stats['in-progress'] || 0,
+                    review: stats.review || 0,
+                    completionPercentage: stats.total > 0 ? Math.round((stats.done / stats.total) * 100) : 0,
+                    lastModified: (await fs.stat(tasksPath)).mtime.toISOString()
+                };
+            }
+            catch (parseError) {
+                console.warn('Failed to parse tasks.json:', parseError.message);
+                taskMetadata = { error: 'Failed to parse tasks.json' };
+            }
+        }
+        return {
+            hasTaskmaster: true,
+            hasEssentialFiles,
+            files: fileStatus,
+            metadata: taskMetadata,
+            path: taskMasterPath
+        };
+    }
+    catch (error) {
+        console.error('Error detecting TaskMaster folder:', error);
+        return {
+            hasTaskmaster: false,
+            reason: `Error checking directory: ${error.message}`
+        };
+    }
+}
+// Cache for extracted project directories
+const projectDirectoryCache = new Map();
+let hasWarnedDiscoveredPersistenceFailure = false;
+// Clear cache when needed (called when project files change)
+function clearProjectDirectoryCache() {
+    projectDirectoryCache.clear();
+}
+// Load project configuration file
+async function loadProjectConfig() {
+    const configPath = path.join(os.homedir(), '.claude', 'project-config.json');
+    try {
+        const configData = await fs.readFile(configPath, 'utf8');
+        return JSON.parse(configData);
+    }
+    catch (error) {
+        // Return empty config if file doesn't exist
+        return {};
+    }
+}
+// Save project configuration file
+async function saveProjectConfig(config) {
+    const claudeDir = path.join(os.homedir(), '.claude');
+    const configPath = path.join(claudeDir, 'project-config.json');
+    // Ensure the .claude directory exists
+    try {
+        await fs.mkdir(claudeDir, { recursive: true });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+function encodeProjectName(projectPath) {
+    return path.resolve(projectPath).replace(/[\\/:\s~_]/g, '-');
+}
+function isTrackedConfigProject(projectConfig) {
+    return Boolean(projectConfig?.manuallyAdded || projectConfig?.autoDiscovered);
+}
+function mergeUniqueProviders(existingProviders = [], incomingProviders = []) {
+    return Array.from(new Set([
+        ...(Array.isArray(existingProviders) ? existingProviders : []),
+        ...(Array.isArray(incomingProviders) ? incomingProviders : []),
+    ])).sort();
+}
+function areStringArraysEqual(first, second) {
+    if (!Array.isArray(first) || !Array.isArray(second)) {
+        return false;
+    }
+    if (first.length !== second.length) {
+        return false;
+    }
+    return first.every((value, index) => value === second[index]);
+}
+async function listGeminiCliProjectEntries() {
+    const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
+    try {
+        await fs.access(geminiTmpDir);
+    }
+    catch {
+        return [];
+    }
+    let projectDirs;
+    try {
+        projectDirs = await fs.readdir(geminiTmpDir);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const projectDir of projectDirs) {
+        const projectRootFile = path.join(geminiTmpDir, projectDir, '.project_root');
+        let projectRoot;
+        try {
+            projectRoot = (await fs.readFile(projectRootFile, 'utf8')).trim();
+        }
+        catch {
+            continue;
+        }
+        const normalizedProjectRoot = normalizeComparablePath(projectRoot);
+        if (!normalizedProjectRoot) {
+            continue;
+        }
+        entries.push({
+            projectDir,
+            projectRoot: path.resolve(projectRoot),
+            normalizedProjectRoot,
+        });
+    }
+    return entries;
+}
+function addDiscoveredProject(discoveredProjectsByPath, projectPath, provider) {
+    if (typeof projectPath !== 'string' || projectPath.trim().length === 0) {
+        return;
+    }
+    const normalizedProjectPath = normalizeComparablePath(projectPath);
+    if (!normalizedProjectPath) {
+        return;
+    }
+    const absoluteProjectPath = path.resolve(projectPath);
+    if (!discoveredProjectsByPath.has(normalizedProjectPath)) {
+        discoveredProjectsByPath.set(normalizedProjectPath, {
+            path: absoluteProjectPath,
+            providers: new Set(),
+        });
+    }
+    discoveredProjectsByPath.get(normalizedProjectPath).providers.add(provider);
+}
+async function discoverProjectsFromHistory(codexSessionsIndexRef = null, geminiCliProjectsRef = null) {
+    const discoveredProjectsByPath = new Map();
+    if (codexSessionsIndexRef && !codexSessionsIndexRef.sessionsByProject) {
+        codexSessionsIndexRef.sessionsByProject = await buildCodexSessionsIndex();
+    }
+    const codexSessionsByProject = codexSessionsIndexRef?.sessionsByProject || await buildCodexSessionsIndex();
+    for (const sessions of codexSessionsByProject.values()) {
+        const sampleSession = sessions.find(session => typeof session.cwd === 'string' && session.cwd.trim().length > 0);
+        if (!sampleSession?.cwd) {
+            continue;
+        }
+        addDiscoveredProject(discoveredProjectsByPath, sampleSession.cwd, 'codex');
+    }
+    if (geminiCliProjectsRef && !geminiCliProjectsRef.entries) {
+        geminiCliProjectsRef.entries = await listGeminiCliProjectEntries();
+    }
+    const geminiCliEntries = geminiCliProjectsRef?.entries || await listGeminiCliProjectEntries();
+    for (const entry of geminiCliEntries) {
+        addDiscoveredProject(discoveredProjectsByPath, entry.projectRoot, 'gemini');
+    }
+    for (const session of sessionManager.sessions.values()) {
+        if (session?.projectPath) {
+            addDiscoveredProject(discoveredProjectsByPath, session.projectPath, 'gemini');
+        }
+    }
+    return Array.from(discoveredProjectsByPath.values()).map((entry) => ({
+        path: entry.path,
+        providers: Array.from(entry.providers).sort(),
+    }));
+}
+function mergeDiscoveredProjectsIntoConfig(config, discoveredProjects) {
+    let changed = false;
+    const nextConfig = { ...config };
+    const nowIso = new Date().toISOString();
+    for (const discovered of discoveredProjects) {
+        const projectName = encodeProjectName(discovered.path);
+        const currentConfig = nextConfig[projectName] || {};
+        const mergedProviders = mergeUniqueProviders(currentConfig.detectedProviders, discovered.providers);
+        const nextProjectConfig = {
+            ...currentConfig,
+            originalPath: currentConfig.originalPath || discovered.path,
+            detectedProviders: mergedProviders,
+            detectedAt: currentConfig.detectedAt || nowIso,
+        };
+        if (currentConfig.manuallyAdded) {
+            delete nextProjectConfig.autoDiscovered;
+        }
+        else {
+            nextProjectConfig.autoDiscovered = true;
+        }
+        const providersChanged = !areStringArraysEqual(Array.isArray(currentConfig.detectedProviders) ? currentConfig.detectedProviders : [], mergedProviders);
+        const autoDiscoveredChanged = Boolean(currentConfig.autoDiscovered) !== Boolean(nextProjectConfig.autoDiscovered);
+        const originalPathChanged = currentConfig.originalPath !== nextProjectConfig.originalPath;
+        const detectedAtChanged = !currentConfig.detectedAt && Boolean(nextProjectConfig.detectedAt);
+        if (providersChanged || autoDiscoveredChanged || originalPathChanged || detectedAtChanged || !nextConfig[projectName]) {
+            changed = true;
+            nextConfig[projectName] = nextProjectConfig;
+        }
+    }
+    return { config: nextConfig, changed };
+}
+async function syncAutoDiscoveredProjects(config, codexSessionsIndexRef = null, geminiCliProjectsRef = null) {
+    const discoveredProjects = await discoverProjectsFromHistory(codexSessionsIndexRef, geminiCliProjectsRef);
+    if (discoveredProjects.length === 0) {
+        return config;
+    }
+    const mergedConfigResult = mergeDiscoveredProjectsIntoConfig(config, discoveredProjects);
+    if (!mergedConfigResult.changed) {
+        return config;
+    }
+    try {
+        await saveProjectConfig(mergedConfigResult.config);
+        clearProjectDirectoryCache();
+    }
+    catch (error) {
+        // Keep discovered projects available in-memory even if persistence fails.
+        if (!hasWarnedDiscoveredPersistenceFailure) {
+            console.warn('Failed to persist discovered projects to config:', error.message);
+            hasWarnedDiscoveredPersistenceFailure = true;
+        }
+    }
+    return mergedConfigResult.config;
+}
+// Generate better display name from path
+async function generateDisplayName(projectName, actualProjectDir = null) {
+    // Use actual project directory if provided, otherwise decode from project name
+    let projectPath = actualProjectDir || projectName.replace(/-/g, '/');
+    // Try to read package.json from the project path
+    try {
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        const packageData = await fs.readFile(packageJsonPath, 'utf8');
+        const packageJson = JSON.parse(packageData);
+        // Return the name from package.json if it exists
+        if (packageJson.name) {
+            return packageJson.name;
+        }
+    }
+    catch (error) {
+        // Fall back to path-based naming if package.json doesn't exist or can't be read
+    }
+    // If it starts with /, it's an absolute path
+    if (projectPath.startsWith('/')) {
+        const parts = projectPath.split('/').filter(Boolean);
+        // Return only the last folder name
+        return parts[parts.length - 1] || projectPath;
+    }
+    return projectPath;
+}
+// Extract the actual project directory from JSONL sessions (with caching)
+async function extractProjectDirectory(projectName) {
+    // Check cache first
+    if (projectDirectoryCache.has(projectName)) {
+        return projectDirectoryCache.get(projectName);
+    }
+    // Check project config for originalPath (manually added projects via UI or platform)
+    // This handles projects with dashes in their directory names correctly
+    const config = await loadProjectConfig();
+    if (config[projectName]?.originalPath) {
+        const originalPath = config[projectName].originalPath;
+        projectDirectoryCache.set(projectName, originalPath);
+        return originalPath;
+    }
+    const projectDir = path.join(os.homedir(), '.claude', 'projects', projectName);
+    const cwdCounts = new Map();
+    let latestTimestamp = 0;
+    let latestCwd = null;
+    let extractedPath;
+    try {
+        // Check if the project directory exists
+        await fs.access(projectDir);
+        const files = await fs.readdir(projectDir);
+        const jsonlFiles = files.filter(file => file.endsWith('.jsonl'));
+        if (jsonlFiles.length === 0) {
+            // Fall back to decoded project name if no sessions
+            extractedPath = projectName.replace(/-/g, '/');
+        }
+        else {
+            // Process all JSONL files to collect cwd values
+            for (const file of jsonlFiles) {
+                const jsonlFile = path.join(projectDir, file);
+                const fileStream = fsSync.createReadStream(jsonlFile);
+                const rl = readline.createInterface({
+                    input: fileStream,
+                    crlfDelay: Infinity
+                });
+                for await (const line of rl) {
+                    if (line.trim()) {
+                        try {
+                            const entry = JSON.parse(line);
+                            if (entry.cwd) {
+                                // Count occurrences of each cwd
+                                cwdCounts.set(entry.cwd, (cwdCounts.get(entry.cwd) || 0) + 1);
+                                // Track the most recent cwd
+                                const timestamp = new Date(entry.timestamp || 0).getTime();
+                                if (timestamp > latestTimestamp) {
+                                    latestTimestamp = timestamp;
+                                    latestCwd = entry.cwd;
+                                }
+                            }
+                        }
+                        catch (parseError) {
+                            // Skip malformed lines
+                        }
+                    }
+                }
+            }
+            // Determine the best cwd to use
+            if (cwdCounts.size === 0) {
+                // No cwd found, fall back to decoded project name
+                extractedPath = projectName.replace(/-/g, '/');
+            }
+            else if (cwdCounts.size === 1) {
+                // Only one cwd, use it
+                extractedPath = Array.from(cwdCounts.keys())[0];
+            }
+            else {
+                // Multiple cwd values - prefer the most recent one if it has reasonable usage
+                const mostRecentCount = cwdCounts.get(latestCwd) || 0;
+                const maxCount = Math.max(...cwdCounts.values());
+                // Use most recent if it has at least 25% of the max count
+                if (mostRecentCount >= maxCount * 0.25) {
+                    extractedPath = latestCwd;
+                }
+                else {
+                    // Otherwise use the most frequently used cwd
+                    for (const [cwd, count] of cwdCounts.entries()) {
+                        if (count === maxCount) {
+                            extractedPath = cwd;
+                            break;
+                        }
+                    }
+                }
+                // Fallback (shouldn't reach here)
+                if (!extractedPath) {
+                    extractedPath = latestCwd || projectName.replace(/-/g, '/');
+                }
+            }
+        }
+        // Cache the result
+        projectDirectoryCache.set(projectName, extractedPath);
+        return extractedPath;
+    }
+    catch (error) {
+        // If the directory doesn't exist, just use the decoded project name
+        if (error.code === 'ENOENT') {
+            extractedPath = projectName.replace(/-/g, '/');
+        }
+        else {
+            console.error(`Error extracting project directory for ${projectName}:`, error);
+            // Fall back to decoded project name for other errors
+            extractedPath = projectName.replace(/-/g, '/');
+        }
+        // Cache the fallback result too
+        projectDirectoryCache.set(projectName, extractedPath);
+        return extractedPath;
+    }
+}
+async function getProjects(progressCallback = null) {
+    const claudeDir = path.join(os.homedir(), '.claude', 'projects');
+    let config = await loadProjectConfig();
+    const projects = [];
+    const existingProjects = new Set();
+    const codexSessionsIndexRef = { sessionsByProject: null };
+    const geminiCliProjectsRef = { entries: null };
+    let totalProjects = 0;
+    let processedProjects = 0;
+    let directories = [];
+    try {
+        config = await syncAutoDiscoveredProjects(config, codexSessionsIndexRef, geminiCliProjectsRef);
+    }
+    catch (error) {
+        console.warn('Failed to sync auto-discovered projects:', error.message);
+    }
+    try {
+        // Check if the .claude/projects directory exists
+        await fs.access(claudeDir);
+        // First, get existing Claude projects from the file system
+        const entries = await fs.readdir(claudeDir, { withFileTypes: true });
+        directories = entries.filter(e => e.isDirectory());
+        // Build set of existing project names for later
+        directories.forEach(e => existingProjects.add(e.name));
+    }
+    catch (error) {
+        // If the directory doesn't exist (ENOENT), that's okay - just continue with empty projects
+        if (error.code !== 'ENOENT') {
+            console.error('Error reading projects directory:', error);
+        }
+    }
+    // Count tracked config projects (manual + auto discovered) not already represented by Claude folders
+    const trackedProjectsCount = Object.entries(config)
+        .filter(([name, cfg]) => isTrackedConfigProject(cfg) && !existingProjects.has(name))
+        .length;
+    totalProjects = directories.length + trackedProjectsCount;
+    for (const entry of directories) {
+        processedProjects++;
+        if (progressCallback) {
+            progressCallback({
+                phase: 'loading',
+                current: processedProjects,
+                total: totalProjects,
+                currentProject: entry.name
+            });
+        }
+        const actualProjectDir = await extractProjectDirectory(entry.name);
+        const projectConfig = config[entry.name] || {};
+        const isManuallyAdded = Boolean(projectConfig.manuallyAdded);
+        const isAutoDiscovered = Boolean(projectConfig.autoDiscovered) && !isManuallyAdded;
+        const customName = projectConfig.displayName;
+        const autoDisplayName = await generateDisplayName(entry.name, actualProjectDir);
+        const project = {
+            name: entry.name,
+            path: actualProjectDir,
+            displayName: customName || autoDisplayName,
+            fullPath: actualProjectDir,
+            isCustomName: !!customName,
+            isManuallyAdded,
+            autoDiscovered: isAutoDiscovered,
+            source: isManuallyAdded ? 'manual' : 'claude',
+            detectedProviders: projectConfig.detectedProviders || [],
+            detectedAt: projectConfig.detectedAt || null,
+            sessions: [],
+            geminiSessions: [],
+            sessionMeta: {
+                hasMore: false,
+                total: 0
+            }
+        };
+        // Try to get sessions for this project (just first 5 for performance)
+        try {
+            const sessionResult = await getSessions(entry.name, 5, 0);
+            project.sessions = sessionResult.sessions || [];
+            project.sessionMeta = {
+                hasMore: sessionResult.hasMore,
+                total: sessionResult.total
+            };
+        }
+        catch (e) {
+            console.warn(`Could not load sessions for project ${entry.name}:`, e.message);
+            project.sessionMeta = {
+                hasMore: false,
+                total: 0
+            };
+        }
+        applyCustomSessionNames(project.sessions, 'claude');
+        try {
+            project.cursorSessions = await getCursorSessions(actualProjectDir);
+        }
+        catch (e) {
+            console.warn(`Could not load Cursor sessions for project ${entry.name}:`, e.message);
+            project.cursorSessions = [];
+        }
+        applyCustomSessionNames(project.cursorSessions, 'cursor');
+        try {
+            project.codexSessions = await getCodexSessions(actualProjectDir, {
+                indexRef: codexSessionsIndexRef,
+            });
+        }
+        catch (e) {
+            console.warn(`Could not load Codex sessions for project ${entry.name}:`, e.message);
+            project.codexSessions = [];
+        }
+        applyCustomSessionNames(project.codexSessions, 'codex');
+        try {
+            const uiSessions = sessionManager.getProjectSessions(actualProjectDir) || [];
+            const cliSessions = await getGeminiCliSessions(actualProjectDir, {
+                geminiCliProjectsRef,
+            });
+            const uiIds = new Set(uiSessions.map(s => s.id));
+            project.geminiSessions = [...uiSessions, ...cliSessions.filter(s => !uiIds.has(s.id))];
+        }
+        catch (e) {
+            console.warn(`Could not load Gemini sessions for project ${entry.name}:`, e.message);
+            project.geminiSessions = [];
+        }
+        applyCustomSessionNames(project.geminiSessions, 'gemini');
+        try {
+            const taskMasterResult = await detectTaskMasterFolder(actualProjectDir);
+            project.taskmaster = {
+                hasTaskmaster: taskMasterResult.hasTaskmaster,
+                hasEssentialFiles: taskMasterResult.hasEssentialFiles,
+                metadata: taskMasterResult.metadata,
+                status: taskMasterResult.hasTaskmaster && taskMasterResult.hasEssentialFiles ? 'configured' : 'not-configured'
+            };
+        }
+        catch (e) {
+            console.warn(`Could not detect TaskMaster for project ${entry.name}:`, e.message);
+            project.taskmaster = {
+                hasTaskmaster: false,
+                hasEssentialFiles: false,
+                metadata: null,
+                status: 'error'
+            };
+        }
+        projects.push(project);
+    }
+    // Add tracked projects from config that do not currently have Claude folders.
+    for (const [projectName, projectConfig] of Object.entries(config)) {
+        if (!existingProjects.has(projectName) && isTrackedConfigProject(projectConfig)) {
+            processedProjects++;
+            if (progressCallback) {
+                progressCallback({
+                    phase: 'loading',
+                    current: processedProjects,
+                    total: totalProjects,
+                    currentProject: projectName
+                });
+            }
+            let actualProjectDir = projectConfig.originalPath;
+            if (!actualProjectDir) {
+                try {
+                    actualProjectDir = await extractProjectDirectory(projectName);
+                }
+                catch (error) {
+                    // Fall back to decoded project name
+                    actualProjectDir = projectName.replace(/-/g, '/');
+                }
+            }
+            const isManuallyAdded = Boolean(projectConfig.manuallyAdded);
+            const isAutoDiscovered = Boolean(projectConfig.autoDiscovered) && !isManuallyAdded;
+            const source = isManuallyAdded ? 'manual' : 'history';
+            const project = {
+                name: projectName,
+                path: actualProjectDir,
+                displayName: projectConfig.displayName || await generateDisplayName(projectName, actualProjectDir),
+                fullPath: actualProjectDir,
+                isCustomName: !!projectConfig.displayName,
+                isManuallyAdded,
+                autoDiscovered: isAutoDiscovered,
+                source,
+                detectedProviders: projectConfig.detectedProviders || [],
+                detectedAt: projectConfig.detectedAt || null,
+                sessions: [],
+                geminiSessions: [],
+                sessionMeta: {
+                    hasMore: false,
+                    total: 0
+                },
+                cursorSessions: [],
+                codexSessions: []
+            };
+            try {
+                project.cursorSessions = await getCursorSessions(actualProjectDir);
+            }
+            catch (e) {
+                console.warn(`Could not load Cursor sessions for tracked project ${projectName}:`, e.message);
+            }
+            applyCustomSessionNames(project.cursorSessions, 'cursor');
+            try {
+                project.codexSessions = await getCodexSessions(actualProjectDir, {
+                    indexRef: codexSessionsIndexRef,
+                });
+            }
+            catch (e) {
+                console.warn(`Could not load Codex sessions for tracked project ${projectName}:`, e.message);
+            }
+            applyCustomSessionNames(project.codexSessions, 'codex');
+            try {
+                const uiSessions = sessionManager.getProjectSessions(actualProjectDir) || [];
+                const cliSessions = await getGeminiCliSessions(actualProjectDir, {
+                    geminiCliProjectsRef,
+                });
+                const uiIds = new Set(uiSessions.map(s => s.id));
+                project.geminiSessions = [...uiSessions, ...cliSessions.filter(s => !uiIds.has(s.id))];
+            }
+            catch (e) {
+                console.warn(`Could not load Gemini sessions for tracked project ${projectName}:`, e.message);
+            }
+            applyCustomSessionNames(project.geminiSessions, 'gemini');
+            try {
+                const taskMasterResult = await detectTaskMasterFolder(actualProjectDir);
+                let taskMasterStatus = 'not-configured';
+                if (taskMasterResult.hasTaskmaster && taskMasterResult.hasEssentialFiles) {
+                    taskMasterStatus = 'taskmaster-only';
+                }
+                project.taskmaster = {
+                    status: taskMasterStatus,
+                    hasTaskmaster: taskMasterResult.hasTaskmaster,
+                    hasEssentialFiles: taskMasterResult.hasEssentialFiles,
+                    metadata: taskMasterResult.metadata
+                };
+            }
+            catch (error) {
+                console.warn(`TaskMaster detection failed for tracked project ${projectName}:`, error.message);
+                project.taskmaster = {
+                    status: 'error',
+                    hasTaskmaster: false,
+                    hasEssentialFiles: false,
+                    error: error.message
+                };
+            }
+            projects.push(project);
+        }
+    }
+    if (progressCallback) {
+        progressCallback({
+            phase: 'complete',
+            current: totalProjects,
+            total: totalProjects
+        });
+    }
+    return projects;
+}
+async function getSessions(projectName, limit = 5, offset = 0) {
+    const projectDir = path.join(os.homedir(), '.claude', 'projects', projectName);
+    try {
+        const files = await fs.readdir(projectDir);
+        // agent-*.jsonl files contain session start data at this point. This needs to be revisited
+        // periodically to make sure only accurate data is there and no new functionality is added there
+        const jsonlFiles = files.filter(file => file.endsWith('.jsonl') && !file.startsWith('agent-'));
+        if (jsonlFiles.length === 0) {
+            return { sessions: [], hasMore: false, total: 0 };
+        }
+        // Sort files by modification time (newest first)
+        const filesWithStats = await Promise.all(jsonlFiles.map(async (file) => {
+            const filePath = path.join(projectDir, file);
+            const stats = await fs.stat(filePath);
+            return { file, mtime: stats.mtime };
+        }));
+        filesWithStats.sort((a, b) => b.mtime - a.mtime);
+        const allSessions = new Map();
+        const allEntries = [];
+        const uuidToSessionMap = new Map();
+        // Collect all sessions and entries from all files
+        for (const { file } of filesWithStats) {
+            const jsonlFile = path.join(projectDir, file);
+            const result = await parseJsonlSessions(jsonlFile);
+            result.sessions.forEach(session => {
+                if (!allSessions.has(session.id)) {
+                    allSessions.set(session.id, session);
+                }
+            });
+            allEntries.push(...result.entries);
+            // Early exit optimization for large projects
+            if (allSessions.size >= (limit + offset) * 2 && allEntries.length >= Math.min(3, filesWithStats.length)) {
+                break;
+            }
+        }
+        // Build UUID-to-session mapping for timeline detection
+        allEntries.forEach(entry => {
+            if (entry.uuid && entry.sessionId) {
+                uuidToSessionMap.set(entry.uuid, entry.sessionId);
+            }
+        });
+        // Group sessions by first user message ID
+        const sessionGroups = new Map(); // firstUserMsgId -> { latestSession, allSessions[] }
+        const sessionToFirstUserMsgId = new Map(); // sessionId -> firstUserMsgId
+        // Find the first user message for each session
+        allEntries.forEach(entry => {
+            if (entry.sessionId && entry.type === 'user' && entry.parentUuid === null && entry.uuid) {
+                // This is a first user message in a session (parentUuid is null)
+                const firstUserMsgId = entry.uuid;
+                if (!sessionToFirstUserMsgId.has(entry.sessionId)) {
+                    sessionToFirstUserMsgId.set(entry.sessionId, firstUserMsgId);
+                    const session = allSessions.get(entry.sessionId);
+                    if (session) {
+                        if (!sessionGroups.has(firstUserMsgId)) {
+                            sessionGroups.set(firstUserMsgId, {
+                                latestSession: session,
+                                allSessions: [session]
+                            });
+                        }
+                        else {
+                            const group = sessionGroups.get(firstUserMsgId);
+                            group.allSessions.push(session);
+                            // Update latest session if this one is more recent
+                            if (new Date(session.lastActivity) > new Date(group.latestSession.lastActivity)) {
+                                group.latestSession = session;
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        // Collect all sessions that don't belong to any group (standalone sessions)
+        const groupedSessionIds = new Set();
+        sessionGroups.forEach(group => {
+            group.allSessions.forEach(session => groupedSessionIds.add(session.id));
+        });
+        const standaloneSessionsArray = Array.from(allSessions.values())
+            .filter(session => !groupedSessionIds.has(session.id));
+        // Combine grouped sessions (only show latest from each group) + standalone sessions
+        const latestFromGroups = Array.from(sessionGroups.values()).map(group => {
+            const session = { ...group.latestSession };
+            // Add metadata about grouping
+            if (group.allSessions.length > 1) {
+                session.isGrouped = true;
+                session.groupSize = group.allSessions.length;
+                session.groupSessions = group.allSessions.map(s => s.id);
+            }
+            return session;
+        });
+        const visibleSessions = [...latestFromGroups, ...standaloneSessionsArray]
+            .filter(session => !session.summary.startsWith('{ "'))
+            .sort((a, b) => new Date(b.lastActivity) - new Date(a.lastActivity));
+        const total = visibleSessions.length;
+        const paginatedSessions = visibleSessions.slice(offset, offset + limit);
+        const hasMore = offset + limit < total;
+        return {
+            sessions: paginatedSessions,
+            hasMore,
+            total,
+            offset,
+            limit
+        };
+    }
+    catch (error) {
+        console.error(`Error reading sessions for project ${projectName}:`, error);
+        return { sessions: [], hasMore: false, total: 0 };
+    }
+}
+async function parseJsonlSessions(filePath) {
+    const sessions = new Map();
+    const entries = [];
+    const pendingSummaries = new Map(); // leafUuid -> summary for entries without sessionId
+    try {
+        const fileStream = fsSync.createReadStream(filePath);
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity
+        });
+        for await (const line of rl) {
+            if (line.trim()) {
+                try {
+                    const entry = JSON.parse(line);
+                    entries.push(entry);
+                    // Handle summary entries that don't have sessionId yet
+                    if (entry.type === 'summary' && entry.summary && !entry.sessionId && entry.leafUuid) {
+                        pendingSummaries.set(entry.leafUuid, entry.summary);
+                    }
+                    if (entry.sessionId) {
+                        if (!sessions.has(entry.sessionId)) {
+                            sessions.set(entry.sessionId, {
+                                id: entry.sessionId,
+                                summary: 'New Session',
+                                messageCount: 0,
+                                lastActivity: new Date(),
+                                cwd: entry.cwd || '',
+                                lastUserMessage: null,
+                                lastAssistantMessage: null
+                            });
+                        }
+                        const session = sessions.get(entry.sessionId);
+                        // Apply pending summary if this entry has a parentUuid that matches a pending summary
+                        if (session.summary === 'New Session' && entry.parentUuid && pendingSummaries.has(entry.parentUuid)) {
+                            session.summary = pendingSummaries.get(entry.parentUuid);
+                        }
+                        // Update summary from summary entries with sessionId
+                        if (entry.type === 'summary' && entry.summary) {
+                            session.summary = entry.summary;
+                        }
+                        // Track last user and assistant messages (skip system messages)
+                        if (entry.message?.role === 'user' && entry.message?.content) {
+                            const content = entry.message.content;
+                            // Extract text from array format if needed
+                            let textContent = content;
+                            if (Array.isArray(content) && content.length > 0 && content[0].type === 'text') {
+                                textContent = content[0].text;
+                            }
+                            const isSystemMessage = typeof textContent === 'string' && (textContent.startsWith('<command-name>') ||
+                                textContent.startsWith('<command-message>') ||
+                                textContent.startsWith('<command-args>') ||
+                                textContent.startsWith('<local-command-stdout>') ||
+                                textContent.startsWith('<system-reminder>') ||
+                                textContent.startsWith('Caveat:') ||
+                                textContent.startsWith('This session is being continued from a previous') ||
+                                textContent.startsWith('Invalid API key') ||
+                                textContent.includes('{"subtasks":') || // Filter Task Master prompts
+                                textContent.includes('CRITICAL: You MUST respond with ONLY a JSON') || // Filter Task Master system prompts
+                                textContent === 'Warmup' // Explicitly filter out "Warmup"
+                            );
+                            if (typeof textContent === 'string' && textContent.length > 0 && !isSystemMessage) {
+                                session.lastUserMessage = textContent;
+                            }
+                        }
+                        else if (entry.message?.role === 'assistant' && entry.message?.content) {
+                            // Skip API error messages using the isApiErrorMessage flag
+                            if (entry.isApiErrorMessage === true) {
+                                // Skip this message entirely
+                            }
+                            else {
+                                // Track last assistant text message
+                                let assistantText = null;
+                                if (Array.isArray(entry.message.content)) {
+                                    for (const part of entry.message.content) {
+                                        if (part.type === 'text' && part.text) {
+                                            assistantText = part.text;
+                                        }
+                                    }
+                                }
+                                else if (typeof entry.message.content === 'string') {
+                                    assistantText = entry.message.content;
+                                }
+                                // Additional filter for assistant messages with system content
+                                const isSystemAssistantMessage = typeof assistantText === 'string' && (assistantText.startsWith('Invalid API key') ||
+                                    assistantText.includes('{"subtasks":') ||
+                                    assistantText.includes('CRITICAL: You MUST respond with ONLY a JSON'));
+                                if (assistantText && !isSystemAssistantMessage) {
+                                    session.lastAssistantMessage = assistantText;
+                                }
+                            }
+                        }
+                        session.messageCount++;
+                        if (entry.timestamp) {
+                            session.lastActivity = new Date(entry.timestamp);
+                        }
+                    }
+                }
+                catch (parseError) {
+                    // Skip malformed lines silently
+                }
+            }
+        }
+        // After processing all entries, set final summary based on last message if no summary exists
+        for (const session of sessions.values()) {
+            if (session.summary === 'New Session') {
+                // Prefer last user message, fall back to last assistant message
+                const lastMessage = session.lastUserMessage || session.lastAssistantMessage;
+                if (lastMessage) {
+                    session.summary = lastMessage.length > 50 ? lastMessage.substring(0, 50) + '...' : lastMessage;
+                }
+            }
+        }
+        // Filter out sessions that contain JSON responses (Task Master errors)
+        const allSessions = Array.from(sessions.values());
+        const filteredSessions = allSessions.filter(session => {
+            const shouldFilter = session.summary.startsWith('{ "');
+            if (shouldFilter) {
+            }
+            // Log a sample of summaries to debug
+            if (Math.random() < 0.01) { // Log 1% of sessions
+            }
+            return !shouldFilter;
+        });
+        return {
+            sessions: filteredSessions,
+            entries: entries
+        };
+    }
+    catch (error) {
+        console.error('Error reading JSONL file:', error);
+        return { sessions: [], entries: [] };
+    }
+}
+// Parse an agent JSONL file and extract tool uses
+async function parseAgentTools(filePath) {
+    const tools = [];
+    try {
+        const fileStream = fsSync.createReadStream(filePath);
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity
+        });
+        for await (const line of rl) {
+            if (line.trim()) {
+                try {
+                    const entry = JSON.parse(line);
+                    // Look for assistant messages with tool_use
+                    if (entry.message?.role === 'assistant' && Array.isArray(entry.message?.content)) {
+                        for (const part of entry.message.content) {
+                            if (part.type === 'tool_use') {
+                                tools.push({
+                                    toolId: part.id,
+                                    toolName: part.name,
+                                    toolInput: part.input,
+                                    timestamp: entry.timestamp
+                                });
+                            }
+                        }
+                    }
+                    // Look for tool results
+                    if (entry.message?.role === 'user' && Array.isArray(entry.message?.content)) {
+                        for (const part of entry.message.content) {
+                            if (part.type === 'tool_result') {
+                                // Find the matching tool and add result
+                                const tool = tools.find(t => t.toolId === part.tool_use_id);
+                                if (tool) {
+                                    tool.toolResult = {
+                                        content: typeof part.content === 'string' ? part.content :
+                                            Array.isArray(part.content) ? part.content.map(c => c.text || '').join('\n') :
+                                                JSON.stringify(part.content),
+                                        isError: Boolean(part.is_error)
+                                    };
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (parseError) {
+                    // Skip malformed lines
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Error parsing agent file ${filePath}:`, error.message);
+    }
+    return tools;
+}
+// Get messages for a specific session with pagination support
+async function getSessionMessages(projectName, sessionId, limit = null, offset = 0) {
+    const projectDir = path.join(os.homedir(), '.claude', 'projects', projectName);
+    try {
+        const files = await fs.readdir(projectDir);
+        // agent-*.jsonl files contain subagent tool history - we'll process them separately
+        const jsonlFiles = files.filter(file => file.endsWith('.jsonl') && !file.startsWith('agent-'));
+        const agentFiles = files.filter(file => file.endsWith('.jsonl') && file.startsWith('agent-'));
+        if (jsonlFiles.length === 0) {
+            return { messages: [], total: 0, hasMore: false };
+        }
+        const messages = [];
+        // Map of agentId -> tools for subagent tool grouping
+        const agentToolsCache = new Map();
+        // Process all JSONL files to find messages for this session
+        for (const file of jsonlFiles) {
+            const jsonlFile = path.join(projectDir, file);
+            const fileStream = fsSync.createReadStream(jsonlFile);
+            const rl = readline.createInterface({
+                input: fileStream,
+                crlfDelay: Infinity
+            });
+            for await (const line of rl) {
+                if (line.trim()) {
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.sessionId === sessionId) {
+                            messages.push(entry);
+                        }
+                    }
+                    catch (parseError) {
+                        // Silently skip malformed JSONL lines (common with concurrent writes)
+                    }
+                }
+            }
+        }
+        // Collect agentIds from Task tool results
+        const agentIds = new Set();
+        for (const message of messages) {
+            if (message.toolUseResult?.agentId) {
+                agentIds.add(message.toolUseResult.agentId);
+            }
+        }
+        // Load agent tools for each agentId found
+        for (const agentId of agentIds) {
+            const agentFileName = `agent-${agentId}.jsonl`;
+            if (agentFiles.includes(agentFileName)) {
+                const agentFilePath = path.join(projectDir, agentFileName);
+                const tools = await parseAgentTools(agentFilePath);
+                agentToolsCache.set(agentId, tools);
+            }
+        }
+        // Attach agent tools to their parent Task messages
+        for (const message of messages) {
+            if (message.toolUseResult?.agentId) {
+                const agentId = message.toolUseResult.agentId;
+                const agentTools = agentToolsCache.get(agentId);
+                if (agentTools && agentTools.length > 0) {
+                    message.subagentTools = agentTools;
+                }
+            }
+        }
+        // Sort messages by timestamp
+        const sortedMessages = messages.sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0));
+        const total = sortedMessages.length;
+        // If no limit is specified, return all messages (backward compatibility)
+        if (limit === null) {
+            return sortedMessages;
+        }
+        // Apply pagination - for recent messages, we need to slice from the end
+        // offset 0 should give us the most recent messages
+        const startIndex = Math.max(0, total - offset - limit);
+        const endIndex = total - offset;
+        const paginatedMessages = sortedMessages.slice(startIndex, endIndex);
+        const hasMore = startIndex > 0;
+        return {
+            messages: paginatedMessages,
+            total,
+            hasMore,
+            offset,
+            limit
+        };
+    }
+    catch (error) {
+        console.error(`Error reading messages for session ${sessionId}:`, error);
+        return limit === null ? [] : { messages: [], total: 0, hasMore: false };
+    }
+}
+// Rename a project's display name
+async function renameProject(projectName, newDisplayName) {
+    const config = await loadProjectConfig();
+    if (!newDisplayName || newDisplayName.trim() === '') {
+        // Remove custom name if empty, will fall back to auto-generated
+        if (config[projectName]) {
+            delete config[projectName].displayName;
+        }
+    }
+    else {
+        // Set custom display name, preserving other properties (manuallyAdded, originalPath)
+        config[projectName] = {
+            ...config[projectName],
+            displayName: newDisplayName.trim()
+        };
+    }
+    await saveProjectConfig(config);
+    return true;
+}
+// Delete a session from a project
+async function deleteSession(projectName, sessionId) {
+    const projectDir = path.join(os.homedir(), '.claude', 'projects', projectName);
+    try {
+        const files = await fs.readdir(projectDir);
+        const jsonlFiles = files.filter(file => file.endsWith('.jsonl'));
+        if (jsonlFiles.length === 0) {
+            throw new Error('No session files found for this project');
+        }
+        // Check all JSONL files to find which one contains the session
+        for (const file of jsonlFiles) {
+            const jsonlFile = path.join(projectDir, file);
+            const content = await fs.readFile(jsonlFile, 'utf8');
+            const lines = content.split('\n').filter(line => line.trim());
+            // Check if this file contains the session
+            const hasSession = lines.some(line => {
+                try {
+                    const data = JSON.parse(line);
+                    return data.sessionId === sessionId;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (hasSession) {
+                // Filter out all entries for this session
+                const filteredLines = lines.filter(line => {
+                    try {
+                        const data = JSON.parse(line);
+                        return data.sessionId !== sessionId;
+                    }
+                    catch {
+                        return true; // Keep malformed lines
+                    }
+                });
+                // Write back the filtered content
+                await fs.writeFile(jsonlFile, filteredLines.join('\n') + (filteredLines.length > 0 ? '\n' : ''));
+                return true;
+            }
+        }
+        throw new Error(`Session ${sessionId} not found in any files`);
+    }
+    catch (error) {
+        console.error(`Error deleting session ${sessionId} from project ${projectName}:`, error);
+        throw error;
+    }
+}
+// Check if a project is empty (has no sessions)
+async function isProjectEmpty(projectName) {
+    try {
+        const sessionsResult = await getSessions(projectName, 1, 0);
+        return sessionsResult.total === 0;
+    }
+    catch (error) {
+        console.error(`Error checking if project ${projectName} is empty:`, error);
+        return false;
+    }
+}
+// Remove a project from the UI.
+// When deleteData=true, also delete session/memory files on disk (destructive).
+async function deleteProject(projectName, force = false, deleteData = false) {
+    const projectDir = path.join(os.homedir(), '.claude', 'projects', projectName);
+    try {
+        const isEmpty = await isProjectEmpty(projectName);
+        if (!isEmpty && !force) {
+            throw new Error('Cannot delete project with existing sessions');
+        }
+        const config = await loadProjectConfig();
+        // Destructive path: delete underlying data when explicitly requested
+        if (deleteData) {
+            let projectPath = config[projectName]?.path || config[projectName]?.originalPath;
+            if (!projectPath) {
+                projectPath = await extractProjectDirectory(projectName);
+            }
+            // Remove the Claude project directory (session logs, memory, subagent data)
+            await fs.rm(projectDir, { recursive: true, force: true });
+            // Delete Codex sessions associated with this project
+            if (projectPath) {
+                try {
+                    const codexSessions = await getCodexSessions(projectPath, { limit: 0 });
+                    for (const session of codexSessions) {
+                        try {
+                            await deleteCodexSession(session.id);
+                        }
+                        catch (err) {
+                            console.warn(`Failed to delete Codex session ${session.id}:`, err.message);
+                        }
+                    }
+                }
+                catch (err) {
+                    console.warn('Failed to delete Codex sessions:', err.message);
+                }
+                // Delete Cursor sessions directory if it exists
+                try {
+                    const hash = crypto.createHash('md5').update(projectPath).digest('hex');
+                    const cursorProjectDir = path.join(os.homedir(), '.cursor', 'chats', hash);
+                    await fs.rm(cursorProjectDir, { recursive: true, force: true });
+                }
+                catch (err) {
+                    // Cursor dir may not exist, ignore
+                }
+            }
+        }
+        // Always remove from project config
+        delete config[projectName];
+        await saveProjectConfig(config);
+        return true;
+    }
+    catch (error) {
+        console.error(`Error removing project ${projectName}:`, error);
+        throw error;
+    }
+}
+// Add a project manually to the config (without creating folders)
+async function addProjectManually(projectPath, displayName = null) {
+    const absolutePath = path.resolve(projectPath);
+    try {
+        // Check if the path exists
+        await fs.access(absolutePath);
+    }
+    catch (error) {
+        throw new Error(`Path does not exist: ${absolutePath}`);
+    }
+    // Generate project name (encode path for use as directory name)
+    const projectName = encodeProjectName(absolutePath);
+    // Check if project already exists in config
+    const config = await loadProjectConfig();
+    if (config[projectName]) {
+        if (config[projectName].manuallyAdded) {
+            throw new Error(`Project already configured for path: ${absolutePath}`);
+        }
+        // Upgrade discovered project to manual tracking.
+        config[projectName] = {
+            ...config[projectName],
+            manuallyAdded: true,
+            originalPath: absolutePath
+        };
+        delete config[projectName].autoDiscovered;
+        if (displayName) {
+            config[projectName].displayName = displayName;
+        }
+        await saveProjectConfig(config);
+        clearProjectDirectoryCache();
+        return {
+            name: projectName,
+            path: absolutePath,
+            fullPath: absolutePath,
+            displayName: displayName || await generateDisplayName(projectName, absolutePath),
+            isManuallyAdded: true,
+            sessions: [],
+            cursorSessions: []
+        };
+    }
+    // Allow adding projects even if the directory exists - this enables tracking
+    // existing Claude Code or Cursor projects in the UI
+    // Add to config as manually added project
+    config[projectName] = {
+        manuallyAdded: true,
+        originalPath: absolutePath
+    };
+    if (displayName) {
+        config[projectName].displayName = displayName;
+    }
+    await saveProjectConfig(config);
+    return {
+        name: projectName,
+        path: absolutePath,
+        fullPath: absolutePath,
+        displayName: displayName || await generateDisplayName(projectName, absolutePath),
+        isManuallyAdded: true,
+        sessions: [],
+        cursorSessions: []
+    };
+}
+// Fetch Cursor sessions for a given project path
+async function getCursorSessions(projectPath) {
+    try {
+        // Calculate cwdID hash for the project path (Cursor uses MD5 hash)
+        const cwdId = crypto.createHash('md5').update(projectPath).digest('hex');
+        const cursorChatsPath = path.join(os.homedir(), '.cursor', 'chats', cwdId);
+        // Check if the directory exists
+        try {
+            await fs.access(cursorChatsPath);
+        }
+        catch (error) {
+            // No sessions for this project
+            return [];
+        }
+        // List all session directories
+        const sessionDirs = await fs.readdir(cursorChatsPath);
+        const sessions = [];
+        for (const sessionId of sessionDirs) {
+            const sessionPath = path.join(cursorChatsPath, sessionId);
+            const storeDbPath = path.join(sessionPath, 'store.db');
+            try {
+                // Check if store.db exists
+                await fs.access(storeDbPath);
+                // Capture store.db mtime as a reliable fallback timestamp
+                let dbStatMtimeMs = null;
+                try {
+                    const stat = await fs.stat(storeDbPath);
+                    dbStatMtimeMs = stat.mtimeMs;
+                }
+                catch (_) { }
+                // Open SQLite database
+                const db = new Database(storeDbPath, { readonly: true, fileMustExist: true });
+                // Get metadata from meta table
+                const metaRows = db.prepare('SELECT key, value FROM meta').all();
+                // Parse metadata
+                let metadata = {};
+                for (const row of metaRows) {
+                    if (row.value) {
+                        try {
+                            // Try to decode as hex-encoded JSON
+                            const hexMatch = row.value.toString().match(/^[0-9a-fA-F]+$/);
+                            if (hexMatch) {
+                                const jsonStr = Buffer.from(row.value, 'hex').toString('utf8');
+                                metadata[row.key] = JSON.parse(jsonStr);
+                            }
+                            else {
+                                metadata[row.key] = row.value.toString();
+                            }
+                        }
+                        catch (e) {
+                            metadata[row.key] = row.value.toString();
+                        }
+                    }
+                }
+                // Get message count
+                const messageCountResult = db.prepare('SELECT COUNT(*) as count FROM blobs').get();
+                db.close();
+                // Extract session info
+                const sessionName = metadata.title || metadata.sessionTitle || 'Untitled Session';
+                // Determine timestamp - prefer createdAt from metadata, fall back to db file mtime
+                let createdAt = null;
+                if (metadata.createdAt) {
+                    createdAt = new Date(metadata.createdAt).toISOString();
+                }
+                else if (dbStatMtimeMs) {
+                    createdAt = new Date(dbStatMtimeMs).toISOString();
+                }
+                else {
+                    createdAt = new Date().toISOString();
+                }
+                sessions.push({
+                    id: sessionId,
+                    name: sessionName,
+                    createdAt: createdAt,
+                    lastActivity: createdAt, // For compatibility with Claude sessions
+                    messageCount: messageCountResult.count || 0,
+                    projectPath: projectPath
+                });
+            }
+            catch (error) {
+                console.warn(`Could not read Cursor session ${sessionId}:`, error.message);
+            }
+        }
+        // Sort sessions by creation time (newest first)
+        sessions.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+        // Return only the first 5 sessions for performance
+        return sessions.slice(0, 5);
+    }
+    catch (error) {
+        console.error('Error fetching Cursor sessions:', error);
+        return [];
+    }
+}
+function normalizeComparablePath(inputPath) {
+    if (!inputPath || typeof inputPath !== 'string') {
+        return '';
+    }
+    const withoutLongPathPrefix = inputPath.startsWith('\\\\?\\')
+        ? inputPath.slice(4)
+        : inputPath;
+    const normalized = path.normalize(withoutLongPathPrefix.trim());
+    if (!normalized) {
+        return '';
+    }
+    const resolved = path.resolve(normalized);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+async function findCodexJsonlFiles(dir) {
+    const files = [];
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...await findCodexJsonlFiles(fullPath));
+            }
+            else if (entry.name.endsWith('.jsonl')) {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch (error) {
+        // Skip directories we can't read
+    }
+    return files;
+}
+async function buildCodexSessionsIndex() {
+    const codexSessionsDir = path.join(os.homedir(), '.codex', 'sessions');
+    const sessionsByProject = new Map();
+    try {
+        await fs.access(codexSessionsDir);
+    }
+    catch (error) {
+        return sessionsByProject;
+    }
+    const jsonlFiles = await findCodexJsonlFiles(codexSessionsDir);
+    for (const filePath of jsonlFiles) {
+        try {
+            const sessionData = await parseCodexSessionFile(filePath);
+            if (!sessionData || !sessionData.id) {
+                continue;
+            }
+            const normalizedProjectPath = normalizeComparablePath(sessionData.cwd);
+            if (!normalizedProjectPath) {
+                continue;
+            }
+            const session = {
+                id: sessionData.id,
+                summary: sessionData.summary || 'Codex Session',
+                messageCount: sessionData.messageCount || 0,
+                lastActivity: sessionData.timestamp ? new Date(sessionData.timestamp) : new Date(),
+                cwd: sessionData.cwd,
+                model: sessionData.model,
+                filePath,
+                provider: 'codex',
+            };
+            if (!sessionsByProject.has(normalizedProjectPath)) {
+                sessionsByProject.set(normalizedProjectPath, []);
+            }
+            sessionsByProject.get(normalizedProjectPath).push(session);
+        }
+        catch (error) {
+            console.warn(`Could not parse Codex session file ${filePath}:`, error.message);
+        }
+    }
+    for (const sessions of sessionsByProject.values()) {
+        sessions.sort((a, b) => new Date(b.lastActivity) - new Date(a.lastActivity));
+    }
+    return sessionsByProject;
+}
+// Fetch Codex sessions for a given project path
+async function getCodexSessions(projectPath, options = {}) {
+    const { limit = 5, indexRef = null } = options;
+    try {
+        const normalizedProjectPath = normalizeComparablePath(projectPath);
+        if (!normalizedProjectPath) {
+            return [];
+        }
+        if (indexRef && !indexRef.sessionsByProject) {
+            indexRef.sessionsByProject = await buildCodexSessionsIndex();
+        }
+        const sessionsByProject = indexRef?.sessionsByProject || await buildCodexSessionsIndex();
+        const sessions = sessionsByProject.get(normalizedProjectPath) || [];
+        // Return limited sessions for performance (0 = unlimited for deletion)
+        return limit > 0 ? sessions.slice(0, limit) : [...sessions];
+    }
+    catch (error) {
+        console.error('Error fetching Codex sessions:', error);
+        return [];
+    }
+}
+function isVisibleCodexUserMessage(payload) {
+    if (!payload || payload.type !== 'user_message') {
+        return false;
+    }
+    // Codex logs internal context (environment, instructions) as non-plain user_message kinds.
+    if (payload.kind && payload.kind !== 'plain') {
+        return false;
+    }
+    if (typeof payload.message !== 'string' || payload.message.trim().length === 0) {
+        return false;
+    }
+    return true;
+}
+// Parse a Codex session JSONL file to extract metadata
+async function parseCodexSessionFile(filePath) {
+    try {
+        const fileStream = fsSync.createReadStream(filePath);
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity
+        });
+        let sessionMeta = null;
+        let lastTimestamp = null;
+        let lastUserMessage = null;
+        let messageCount = 0;
+        for await (const line of rl) {
+            if (line.trim()) {
+                try {
+                    const entry = JSON.parse(line);
+                    // Track timestamp
+                    if (entry.timestamp) {
+                        lastTimestamp = entry.timestamp;
+                    }
+                    // Extract session metadata
+                    if (entry.type === 'session_meta' && entry.payload) {
+                        sessionMeta = {
+                            id: entry.payload.id,
+                            cwd: entry.payload.cwd,
+                            model: entry.payload.model || entry.payload.model_provider,
+                            timestamp: entry.timestamp,
+                            git: entry.payload.git
+                        };
+                    }
+                    // Count visible user messages and extract summary from the latest plain user input.
+                    if (entry.type === 'event_msg' && isVisibleCodexUserMessage(entry.payload)) {
+                        messageCount++;
+                        if (entry.payload.message) {
+                            lastUserMessage = entry.payload.message;
+                        }
+                    }
+                    if (entry.type === 'response_item' && entry.payload?.type === 'message' && entry.payload.role === 'assistant') {
+                        messageCount++;
+                    }
+                }
+                catch (parseError) {
+                    // Skip malformed lines
+                }
+            }
+        }
+        if (sessionMeta) {
+            return {
+                ...sessionMeta,
+                timestamp: lastTimestamp || sessionMeta.timestamp,
+                summary: lastUserMessage ?
+                    (lastUserMessage.length > 50 ? lastUserMessage.substring(0, 50) + '...' : lastUserMessage) :
+                    'Codex Session',
+                messageCount
+            };
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('Error parsing Codex session file:', error);
+        return null;
+    }
+}
+// Get messages for a specific Codex session
+async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
+    try {
+        const codexSessionsDir = path.join(os.homedir(), '.codex', 'sessions');
+        // Find the session file by searching for the session ID
+        const findSessionFile = async (dir) => {
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        const found = await findSessionFile(fullPath);
+                        if (found)
+                            return found;
+                    }
+                    else if (entry.name.includes(sessionId) && entry.name.endsWith('.jsonl')) {
+                        return fullPath;
+                    }
+                }
+            }
+            catch (error) {
+                // Skip directories we can't read
+            }
+            return null;
+        };
+        const sessionFilePath = await findSessionFile(codexSessionsDir);
+        if (!sessionFilePath) {
+            console.warn(`Codex session file not found for session ${sessionId}`);
+            return { messages: [], total: 0, hasMore: false };
+        }
+        const messages = [];
+        let tokenUsage = null;
+        const fileStream = fsSync.createReadStream(sessionFilePath);
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity
+        });
+        // Helper to extract text from Codex content array
+        const extractText = (content) => {
+            if (!Array.isArray(content))
+                return content;
+            return content
+                .map(item => {
+                if (item.type === 'input_text' || item.type === 'output_text') {
+                    return item.text;
+                }
+                if (item.type === 'text') {
+                    return item.text;
+                }
+                return '';
+            })
+                .filter(Boolean)
+                .join('\n');
+        };
+        for await (const line of rl) {
+            if (line.trim()) {
+                try {
+                    const entry = JSON.parse(line);
+                    // Extract token usage from token_count events (keep latest)
+                    if (entry.type === 'event_msg' && entry.payload?.type === 'token_count' && entry.payload?.info) {
+                        const info = entry.payload.info;
+                        if (info.total_token_usage) {
+                            tokenUsage = {
+                                used: info.total_token_usage.total_tokens || 0,
+                                total: info.model_context_window || 200000
+                            };
+                        }
+                    }
+                    // Use event_msg.user_message for user-visible inputs.
+                    if (entry.type === 'event_msg' && isVisibleCodexUserMessage(entry.payload)) {
+                        messages.push({
+                            type: 'user',
+                            timestamp: entry.timestamp,
+                            message: {
+                                role: 'user',
+                                content: entry.payload.message
+                            }
+                        });
+                    }
+                    // response_item.message may include internal prompts for non-assistant roles.
+                    // Keep only assistant output from response_item.
+                    if (entry.type === 'response_item' &&
+                        entry.payload?.type === 'message' &&
+                        entry.payload.role === 'assistant') {
+                        const content = entry.payload.content;
+                        const textContent = extractText(content);
+                        // Only add if there's actual content
+                        if (textContent?.trim()) {
+                            messages.push({
+                                type: 'assistant',
+                                timestamp: entry.timestamp,
+                                message: {
+                                    role: 'assistant',
+                                    content: textContent
+                                }
+                            });
+                        }
+                    }
+                    if (entry.type === 'response_item' && entry.payload?.type === 'reasoning') {
+                        const summaryText = entry.payload.summary
+                            ?.map(s => s.text)
+                            .filter(Boolean)
+                            .join('\n');
+                        if (summaryText?.trim()) {
+                            messages.push({
+                                type: 'thinking',
+                                timestamp: entry.timestamp,
+                                message: {
+                                    role: 'assistant',
+                                    content: summaryText
+                                }
+                            });
+                        }
+                    }
+                    if (entry.type === 'response_item' && entry.payload?.type === 'function_call') {
+                        let toolName = entry.payload.name;
+                        let toolInput = entry.payload.arguments;
+                        // Map Codex tool names to Claude equivalents
+                        if (toolName === 'shell_command') {
+                            toolName = 'Bash';
+                            try {
+                                const args = JSON.parse(entry.payload.arguments);
+                                toolInput = JSON.stringify({ command: args.command });
+                            }
+                            catch (e) {
+                                // Keep original if parsing fails
+                            }
+                        }
+                        messages.push({
+                            type: 'tool_use',
+                            timestamp: entry.timestamp,
+                            toolName: toolName,
+                            toolInput: toolInput,
+                            toolCallId: entry.payload.call_id
+                        });
+                    }
+                    if (entry.type === 'response_item' && entry.payload?.type === 'function_call_output') {
+                        messages.push({
+                            type: 'tool_result',
+                            timestamp: entry.timestamp,
+                            toolCallId: entry.payload.call_id,
+                            output: entry.payload.output
+                        });
+                    }
+                    if (entry.type === 'response_item' && entry.payload?.type === 'custom_tool_call') {
+                        const toolName = entry.payload.name || 'custom_tool';
+                        const input = entry.payload.input || '';
+                        if (toolName === 'apply_patch') {
+                            // Parse Codex patch format and convert to Claude Edit format
+                            const fileMatch = input.match(/\*\*\* Update File: (.+)/);
+                            const filePath = fileMatch ? fileMatch[1].trim() : 'unknown';
+                            // Extract old and new content from patch
+                            const lines = input.split('\n');
+                            const oldLines = [];
+                            const newLines = [];
+                            for (const line of lines) {
+                                if (line.startsWith('-') && !line.startsWith('---')) {
+                                    oldLines.push(line.substring(1));
+                                }
+                                else if (line.startsWith('+') && !line.startsWith('+++')) {
+                                    newLines.push(line.substring(1));
+                                }
+                            }
+                            messages.push({
+                                type: 'tool_use',
+                                timestamp: entry.timestamp,
+                                toolName: 'Edit',
+                                toolInput: JSON.stringify({
+                                    file_path: filePath,
+                                    old_string: oldLines.join('\n'),
+                                    new_string: newLines.join('\n')
+                                }),
+                                toolCallId: entry.payload.call_id
+                            });
+                        }
+                        else {
+                            messages.push({
+                                type: 'tool_use',
+                                timestamp: entry.timestamp,
+                                toolName: toolName,
+                                toolInput: input,
+                                toolCallId: entry.payload.call_id
+                            });
+                        }
+                    }
+                    if (entry.type === 'response_item' && entry.payload?.type === 'custom_tool_call_output') {
+                        messages.push({
+                            type: 'tool_result',
+                            timestamp: entry.timestamp,
+                            toolCallId: entry.payload.call_id,
+                            output: entry.payload.output || ''
+                        });
+                    }
+                }
+                catch (parseError) {
+                    // Skip malformed lines
+                }
+            }
+        }
+        // Sort by timestamp
+        messages.sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0));
+        const total = messages.length;
+        // Apply pagination if limit is specified
+        if (limit !== null) {
+            const startIndex = Math.max(0, total - offset - limit);
+            const endIndex = total - offset;
+            const paginatedMessages = messages.slice(startIndex, endIndex);
+            const hasMore = startIndex > 0;
+            return {
+                messages: paginatedMessages,
+                total,
+                hasMore,
+                offset,
+                limit,
+                tokenUsage
+            };
+        }
+        return { messages, tokenUsage };
+    }
+    catch (error) {
+        console.error(`Error reading Codex session messages for ${sessionId}:`, error);
+        return { messages: [], total: 0, hasMore: false };
+    }
+}
+async function deleteCodexSession(sessionId) {
+    try {
+        const codexSessionsDir = path.join(os.homedir(), '.codex', 'sessions');
+        const findJsonlFiles = async (dir) => {
+            const files = [];
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        files.push(...await findJsonlFiles(fullPath));
+                    }
+                    else if (entry.name.endsWith('.jsonl')) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+            catch (error) { }
+            return files;
+        };
+        const jsonlFiles = await findJsonlFiles(codexSessionsDir);
+        for (const filePath of jsonlFiles) {
+            const sessionData = await parseCodexSessionFile(filePath);
+            if (sessionData && sessionData.id === sessionId) {
+                await fs.unlink(filePath);
+                return true;
+            }
+        }
+        throw new Error(`Codex session file not found for session ${sessionId}`);
+    }
+    catch (error) {
+        console.error(`Error deleting Codex session ${sessionId}:`, error);
+        throw error;
+    }
+}
+async function searchConversations(query, limit = 50, onProjectResult = null, signal = null) {
+    const safeQuery = typeof query === 'string' ? query.trim() : '';
+    const safeLimit = Math.max(1, Math.min(Number.isFinite(limit) ? limit : 50, 200));
+    const claudeDir = path.join(os.homedir(), '.claude', 'projects');
+    let config = await loadProjectConfig();
+    const codexSessionsIndexRef = { sessionsByProject: null };
+    const geminiCliProjectsRef = { entries: null };
+    const results = [];
+    let totalMatches = 0;
+    const words = safeQuery.toLowerCase().split(/\s+/).filter(w => w.length > 0);
+    if (words.length === 0)
+        return { results: [], totalMatches: 0, query: safeQuery };
+    const isAborted = () => signal?.aborted === true;
+    const isSystemMessage = (textContent) => {
+        return typeof textContent === 'string' && (textContent.startsWith('<command-name>') ||
+            textContent.startsWith('<command-message>') ||
+            textContent.startsWith('<command-args>') ||
+            textContent.startsWith('<local-command-stdout>') ||
+            textContent.startsWith('<system-reminder>') ||
+            textContent.startsWith('Caveat:') ||
+            textContent.startsWith('This session is being continued from a previous') ||
+            textContent.startsWith('Invalid API key') ||
+            textContent.includes('{"subtasks":') ||
+            textContent.includes('CRITICAL: You MUST respond with ONLY a JSON') ||
+            textContent === 'Warmup');
+    };
+    const extractText = (content) => {
+        if (typeof content === 'string')
+            return content;
+        if (Array.isArray(content)) {
+            return content
+                .filter(part => part.type === 'text' && part.text)
+                .map(part => part.text)
+                .join(' ');
+        }
+        return '';
+    };
+    const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const wordPatterns = words.map(w => new RegExp(`(?<!\\p{L})${escapeRegex(w)}(?!\\p{L})`, 'u'));
+    const allWordsMatch = (textLower) => {
+        return wordPatterns.every(p => p.test(textLower));
+    };
+    const buildSnippet = (text, textLower, snippetLen = 150) => {
+        let firstIndex = -1;
+        let firstWordLen = 0;
+        for (const w of words) {
+            const re = new RegExp(`(?<!\\p{L})${escapeRegex(w)}(?!\\p{L})`, 'u');
+            const m = re.exec(textLower);
+            if (m && (firstIndex === -1 || m.index < firstIndex)) {
+                firstIndex = m.index;
+                firstWordLen = w.length;
+            }
+        }
+        if (firstIndex === -1)
+            firstIndex = 0;
+        const halfLen = Math.floor(snippetLen / 2);
+        let start = Math.max(0, firstIndex - halfLen);
+        let end = Math.min(text.length, firstIndex + halfLen + firstWordLen);
+        let snippet = text.slice(start, end).replace(/\n/g, ' ');
+        const prefix = start > 0 ? '...' : '';
+        const suffix = end < text.length ? '...' : '';
+        snippet = prefix + snippet + suffix;
+        const snippetLower = snippet.toLowerCase();
+        const highlights = [];
+        for (const word of words) {
+            const re = new RegExp(`(?<!\\p{L})${escapeRegex(word)}(?!\\p{L})`, 'gu');
+            let match;
+            while ((match = re.exec(snippetLower)) !== null) {
+                highlights.push({ start: match.index, end: match.index + word.length });
+            }
+        }
+        highlights.sort((a, b) => a.start - b.start);
+        const merged = [];
+        for (const h of highlights) {
+            const last = merged[merged.length - 1];
+            if (last && h.start <= last.end) {
+                last.end = Math.max(last.end, h.end);
+            }
+            else {
+                merged.push({ ...h });
+            }
+        }
+        return { snippet, highlights: merged };
+    };
+    try {
+        config = await syncAutoDiscoveredProjects(config, codexSessionsIndexRef, geminiCliProjectsRef);
+    }
+    catch (error) {
+        console.warn('Failed to sync auto-discovered projects for search:', error.message);
+    }
+    const projectTargetsByName = new Map();
+    try {
+        await fs.access(claudeDir);
+        const entries = await fs.readdir(claudeDir, { withFileTypes: true });
+        const projectDirs = entries.filter(e => e.isDirectory());
+        for (const projectDir of projectDirs) {
+            projectTargetsByName.set(projectDir.name, {
+                projectName: projectDir.name,
+                claudeProjectDir: path.join(claudeDir, projectDir.name),
+                projectConfig: config[projectDir.name] || {},
+            });
+        }
+    }
+    catch {
+        // No Claude sessions directory; continue with tracked projects from config.
+    }
+    for (const [projectName, projectConfig] of Object.entries(config)) {
+        if (!isTrackedConfigProject(projectConfig)) {
+            continue;
+        }
+        const existingTarget = projectTargetsByName.get(projectName);
+        if (existingTarget) {
+            existingTarget.projectConfig = {
+                ...existingTarget.projectConfig,
+                ...projectConfig,
+            };
+            continue;
+        }
+        projectTargetsByName.set(projectName, {
+            projectName,
+            claudeProjectDir: null,
+            projectConfig,
+        });
+    }
+    const projectTargets = Array.from(projectTargetsByName.values());
+    const totalProjects = projectTargets.length;
+    let scannedProjects = 0;
+    for (const projectTarget of projectTargets) {
+        if (totalMatches >= safeLimit || isAborted())
+            break;
+        const projectName = projectTarget.projectName;
+        const projectConfig = projectTarget.projectConfig || {};
+        let actualProjectDir = projectConfig.originalPath;
+        if (!actualProjectDir) {
+            try {
+                actualProjectDir = await extractProjectDirectory(projectName);
+            }
+            catch {
+                actualProjectDir = projectName.replace(/-/g, '/');
+            }
+        }
+        const displayName = projectConfig.displayName
+            || await generateDisplayName(projectName, actualProjectDir);
+        const projectResult = {
+            projectName,
+            projectDisplayName: displayName,
+            sessions: []
+        };
+        if (projectTarget.claudeProjectDir) {
+            let files;
+            try {
+                files = await fs.readdir(projectTarget.claudeProjectDir);
+            }
+            catch {
+                files = [];
+            }
+            const jsonlFiles = files.filter(file => file.endsWith('.jsonl') && !file.startsWith('agent-'));
+            for (const file of jsonlFiles) {
+                if (totalMatches >= safeLimit || isAborted())
+                    break;
+                const filePath = path.join(projectTarget.claudeProjectDir, file);
+                const sessionMatches = new Map();
+                const sessionSummaries = new Map();
+                const pendingSummaries = new Map();
+                const sessionLastMessages = new Map();
+                let currentSessionId = null;
+                try {
+                    const fileStream = fsSync.createReadStream(filePath);
+                    const rl = readline.createInterface({
+                        input: fileStream,
+                        crlfDelay: Infinity
+                    });
+                    for await (const line of rl) {
+                        if (totalMatches >= safeLimit || isAborted())
+                            break;
+                        if (!line.trim())
+                            continue;
+                        let entry;
+                        try {
+                            entry = JSON.parse(line);
+                        }
+                        catch {
+                            continue;
+                        }
+                        if (entry.sessionId) {
+                            currentSessionId = entry.sessionId;
+                        }
+                        if (entry.type === 'summary' && entry.summary) {
+                            const sid = entry.sessionId || currentSessionId;
+                            if (sid) {
+                                sessionSummaries.set(sid, entry.summary);
+                            }
+                            else if (entry.leafUuid) {
+                                pendingSummaries.set(entry.leafUuid, entry.summary);
+                            }
+                        }
+                        if (entry.parentUuid && currentSessionId && !sessionSummaries.has(currentSessionId)) {
+                            const pending = pendingSummaries.get(entry.parentUuid);
+                            if (pending)
+                                sessionSummaries.set(currentSessionId, pending);
+                        }
+                        if (entry.message?.content && currentSessionId && !entry.isApiErrorMessage) {
+                            const role = entry.message.role;
+                            if (role === 'user' || role === 'assistant') {
+                                const text = extractText(entry.message.content);
+                                if (text && !isSystemMessage(text)) {
+                                    if (!sessionLastMessages.has(currentSessionId)) {
+                                        sessionLastMessages.set(currentSessionId, {});
+                                    }
+                                    const messages = sessionLastMessages.get(currentSessionId);
+                                    if (role === 'user')
+                                        messages.user = text;
+                                    else
+                                        messages.assistant = text;
+                                }
+                            }
+                        }
+                        if (!entry.message?.content)
+                            continue;
+                        if (entry.message.role !== 'user' && entry.message.role !== 'assistant')
+                            continue;
+                        if (entry.isApiErrorMessage)
+                            continue;
+                        const text = extractText(entry.message.content);
+                        if (!text || isSystemMessage(text))
+                            continue;
+                        const textLower = text.toLowerCase();
+                        if (!allWordsMatch(textLower))
+                            continue;
+                        const sessionId = entry.sessionId || currentSessionId || file.replace('.jsonl', '');
+                        if (!sessionMatches.has(sessionId)) {
+                            sessionMatches.set(sessionId, []);
+                        }
+                        const matches = sessionMatches.get(sessionId);
+                        if (matches.length < 2) {
+                            const { snippet, highlights } = buildSnippet(text, textLower);
+                            matches.push({
+                                role: entry.message.role,
+                                snippet,
+                                highlights,
+                                timestamp: entry.timestamp || null,
+                                provider: 'claude',
+                                messageUuid: entry.uuid || null
+                            });
+                            totalMatches++;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+                for (const [sessionId, matches] of sessionMatches) {
+                    projectResult.sessions.push({
+                        sessionId,
+                        provider: 'claude',
+                        sessionSummary: sessionSummaries.get(sessionId) || (() => {
+                            const messages = sessionLastMessages.get(sessionId);
+                            const lastMessage = messages?.user || messages?.assistant;
+                            return lastMessage
+                                ? (lastMessage.length > 50 ? lastMessage.substring(0, 50) + '...' : lastMessage)
+                                : 'New Session';
+                        })(),
+                        matches
+                    });
+                }
+            }
+        }
+        if (actualProjectDir && !isAborted() && totalMatches < safeLimit) {
+            await searchCodexSessionsForProject(actualProjectDir, projectResult, allWordsMatch, buildSnippet, safeLimit, () => totalMatches, (n) => { totalMatches += n; }, isAborted, codexSessionsIndexRef);
+        }
+        if (actualProjectDir && !isAborted() && totalMatches < safeLimit) {
+            await searchGeminiSessionsForProject(actualProjectDir, projectResult, allWordsMatch, buildSnippet, safeLimit, () => totalMatches, (n) => { totalMatches += n; }, isAborted, geminiCliProjectsRef);
+        }
+        scannedProjects++;
+        if (projectResult.sessions.length > 0) {
+            results.push(projectResult);
+            if (onProjectResult) {
+                onProjectResult({ projectResult, totalMatches, scannedProjects, totalProjects });
+            }
+        }
+        else if (onProjectResult && scannedProjects % 10 === 0) {
+            onProjectResult({ projectResult: null, totalMatches, scannedProjects, totalProjects });
+        }
+    }
+    return { results, totalMatches, query: safeQuery };
+}
+async function searchCodexSessionsForProject(projectPath, projectResult, allWordsMatch, buildSnippet, limit, getTotalMatches, addMatches, isAborted, codexSessionsIndexRef = null) {
+    const normalizedProjectPath = normalizeComparablePath(projectPath);
+    if (!normalizedProjectPath)
+        return;
+    if (codexSessionsIndexRef && !codexSessionsIndexRef.sessionsByProject) {
+        codexSessionsIndexRef.sessionsByProject = await buildCodexSessionsIndex();
+    }
+    const sessionsByProject = codexSessionsIndexRef?.sessionsByProject || await buildCodexSessionsIndex();
+    const indexedSessions = sessionsByProject.get(normalizedProjectPath) || [];
+    if (indexedSessions.length === 0)
+        return;
+    const sessionsByFile = new Map();
+    for (const session of indexedSessions) {
+        if (session?.filePath && !sessionsByFile.has(session.filePath)) {
+            sessionsByFile.set(session.filePath, session);
+        }
+    }
+    for (const [filePath, indexedSession] of sessionsByFile.entries()) {
+        if (getTotalMatches() >= limit || isAborted())
+            break;
+        try {
+            const fileStream = fsSync.createReadStream(filePath);
+            const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+            let lastUserMessage = null;
+            const matches = [];
+            for await (const line of rl) {
+                if (getTotalMatches() >= limit || isAborted())
+                    break;
+                if (!line.trim())
+                    continue;
+                let entry;
+                try {
+                    entry = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                let text = null;
+                let role = null;
+                if (entry.type === 'event_msg' && isVisibleCodexUserMessage(entry.payload) && entry.payload.message) {
+                    text = entry.payload.message;
+                    role = 'user';
+                    lastUserMessage = text;
+                }
+                else if (entry.type === 'response_item' && entry.payload?.type === 'message') {
+                    const contentParts = entry.payload.content || [];
+                    if (entry.payload.role === 'user') {
+                        text = contentParts
+                            .filter(p => p.type === 'input_text' && p.text)
+                            .map(p => p.text)
+                            .join(' ');
+                        role = 'user';
+                        if (text)
+                            lastUserMessage = text;
+                    }
+                    else if (entry.payload.role === 'assistant') {
+                        text = contentParts
+                            .filter(p => p.type === 'output_text' && p.text)
+                            .map(p => p.text)
+                            .join(' ');
+                        role = 'assistant';
+                    }
+                }
+                if (!text || !role)
+                    continue;
+                const textLower = text.toLowerCase();
+                if (!allWordsMatch(textLower))
+                    continue;
+                if (matches.length < 2) {
+                    const { snippet, highlights } = buildSnippet(text, textLower);
+                    matches.push({ role, snippet, highlights, timestamp: entry.timestamp || null, provider: 'codex' });
+                    addMatches(1);
+                }
+            }
+            if (matches.length > 0) {
+                projectResult.sessions.push({
+                    sessionId: indexedSession.id || path.basename(filePath, '.jsonl'),
+                    provider: 'codex',
+                    sessionSummary: lastUserMessage
+                        ? (lastUserMessage.length > 50 ? lastUserMessage.substring(0, 50) + '...' : lastUserMessage)
+                        : (indexedSession.summary || 'Codex Session'),
+                    matches
+                });
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+}
+async function searchGeminiSessionsForProject(projectPath, projectResult, allWordsMatch, buildSnippet, limit, getTotalMatches, addMatches, isAborted = () => false, geminiCliProjectsRef = null) {
+    // 1) Search in-memory sessions (created via UI)
+    for (const [sessionId, session] of sessionManager.sessions) {
+        if (getTotalMatches() >= limit || isAborted())
+            break;
+        if (session.projectPath !== projectPath)
+            continue;
+        const matches = [];
+        for (const msg of session.messages) {
+            if (getTotalMatches() >= limit || isAborted())
+                break;
+            if (msg.role !== 'user' && msg.role !== 'assistant')
+                continue;
+            const text = typeof msg.content === 'string' ? msg.content
+                : Array.isArray(msg.content) ? msg.content.filter(p => p.type === 'text').map(p => p.text).join(' ')
+                    : '';
+            if (!text)
+                continue;
+            const textLower = text.toLowerCase();
+            if (!allWordsMatch(textLower))
+                continue;
+            if (matches.length < 2) {
+                const { snippet, highlights } = buildSnippet(text, textLower);
+                matches.push({
+                    role: msg.role, snippet, highlights,
+                    timestamp: msg.timestamp ? msg.timestamp.toISOString() : null,
+                    provider: 'gemini'
+                });
+                addMatches(1);
+            }
+        }
+        if (matches.length > 0) {
+            const firstUserMsg = session.messages.find(m => m.role === 'user');
+            const summary = firstUserMsg?.content
+                ? (typeof firstUserMsg.content === 'string'
+                    ? (firstUserMsg.content.length > 50 ? firstUserMsg.content.substring(0, 50) + '...' : firstUserMsg.content)
+                    : 'Gemini Session')
+                : 'Gemini Session';
+            projectResult.sessions.push({
+                sessionId,
+                provider: 'gemini',
+                sessionSummary: summary,
+                matches
+            });
+        }
+    }
+    // 2) Search Gemini CLI sessions on disk (~/.gemini/tmp/<project>/chats/*.json)
+    const normalizedProjectPath = normalizeComparablePath(projectPath);
+    if (!normalizedProjectPath)
+        return;
+    const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
+    const trackedSessionIds = new Set();
+    for (const [sid] of sessionManager.sessions) {
+        trackedSessionIds.add(sid);
+    }
+    if (geminiCliProjectsRef && !geminiCliProjectsRef.entries) {
+        geminiCliProjectsRef.entries = await listGeminiCliProjectEntries();
+    }
+    const geminiCliEntries = geminiCliProjectsRef?.entries || await listGeminiCliProjectEntries();
+    for (const entry of geminiCliEntries) {
+        if (getTotalMatches() >= limit || isAborted())
+            break;
+        if (entry.normalizedProjectRoot !== normalizedProjectPath)
+            continue;
+        const projectDir = entry.projectDir;
+        const chatsDir = path.join(geminiTmpDir, projectDir, 'chats');
+        let chatFiles;
+        try {
+            chatFiles = await fs.readdir(chatsDir);
+        }
+        catch {
+            continue;
+        }
+        for (const chatFile of chatFiles) {
+            if (getTotalMatches() >= limit || isAborted())
+                break;
+            if (!chatFile.endsWith('.json'))
+                continue;
+            try {
+                const filePath = path.join(chatsDir, chatFile);
+                const data = await fs.readFile(filePath, 'utf8');
+                const session = JSON.parse(data);
+                if (!session.messages || !Array.isArray(session.messages))
+                    continue;
+                const cliSessionId = session.sessionId || chatFile.replace('.json', '');
+                if (trackedSessionIds.has(cliSessionId))
+                    continue;
+                const matches = [];
+                let firstUserText = null;
+                for (const msg of session.messages) {
+                    if (getTotalMatches() >= limit || isAborted())
+                        break;
+                    const role = msg.type === 'user' ? 'user'
+                        : (msg.type === 'gemini' || msg.type === 'assistant') ? 'assistant'
+                            : null;
+                    if (!role)
+                        continue;
+                    let text = '';
+                    if (typeof msg.content === 'string') {
+                        text = msg.content;
+                    }
+                    else if (Array.isArray(msg.content)) {
+                        text = msg.content
+                            .filter(p => p.text)
+                            .map(p => p.text)
+                            .join(' ');
+                    }
+                    if (!text)
+                        continue;
+                    if (role === 'user' && !firstUserText)
+                        firstUserText = text;
+                    const textLower = text.toLowerCase();
+                    if (!allWordsMatch(textLower))
+                        continue;
+                    if (matches.length < 2) {
+                        const { snippet, highlights } = buildSnippet(text, textLower);
+                        matches.push({
+                            role, snippet, highlights,
+                            timestamp: msg.timestamp || null,
+                            provider: 'gemini'
+                        });
+                        addMatches(1);
+                    }
+                }
+                if (matches.length > 0) {
+                    const summary = firstUserText
+                        ? (firstUserText.length > 50 ? firstUserText.substring(0, 50) + '...' : firstUserText)
+                        : 'Gemini CLI Session';
+                    projectResult.sessions.push({
+                        sessionId: cliSessionId,
+                        provider: 'gemini',
+                        sessionSummary: summary,
+                        matches
+                    });
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+}
+async function getGeminiCliSessions(projectPath, options = {}) {
+    const { geminiCliProjectsRef = null } = options;
+    const normalizedProjectPath = normalizeComparablePath(projectPath);
+    if (!normalizedProjectPath)
+        return [];
+    const sessions = [];
+    const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
+    if (geminiCliProjectsRef && !geminiCliProjectsRef.entries) {
+        geminiCliProjectsRef.entries = await listGeminiCliProjectEntries();
+    }
+    const geminiCliEntries = geminiCliProjectsRef?.entries || await listGeminiCliProjectEntries();
+    for (const entry of geminiCliEntries) {
+        if (entry.normalizedProjectRoot !== normalizedProjectPath)
+            continue;
+        const projectDir = entry.projectDir;
+        const chatsDir = path.join(geminiTmpDir, projectDir, 'chats');
+        let chatFiles;
+        try {
+            chatFiles = await fs.readdir(chatsDir);
+        }
+        catch {
+            continue;
+        }
+        for (const chatFile of chatFiles) {
+            if (!chatFile.endsWith('.json'))
+                continue;
+            try {
+                const filePath = path.join(chatsDir, chatFile);
+                const data = await fs.readFile(filePath, 'utf8');
+                const session = JSON.parse(data);
+                if (!session.messages || !Array.isArray(session.messages))
+                    continue;
+                const sessionId = session.sessionId || chatFile.replace('.json', '');
+                const firstUserMsg = session.messages.find(m => m.type === 'user');
+                let summary = 'Gemini CLI Session';
+                if (firstUserMsg) {
+                    const text = Array.isArray(firstUserMsg.content)
+                        ? firstUserMsg.content.filter(p => p.text).map(p => p.text).join(' ')
+                        : (typeof firstUserMsg.content === 'string' ? firstUserMsg.content : '');
+                    if (text) {
+                        summary = text.length > 50 ? text.substring(0, 50) + '...' : text;
+                    }
+                }
+                sessions.push({
+                    id: sessionId,
+                    summary,
+                    messageCount: session.messages.length,
+                    lastActivity: session.lastUpdated || session.startTime || null,
+                    provider: 'gemini'
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return sessions.sort((a, b) => new Date(b.lastActivity || 0) - new Date(a.lastActivity || 0));
+}
+async function getGeminiCliSessionMessages(sessionId) {
+    const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
+    let projectDirs;
+    try {
+        projectDirs = await fs.readdir(geminiTmpDir);
+    }
+    catch {
+        return [];
+    }
+    for (const projectDir of projectDirs) {
+        const chatsDir = path.join(geminiTmpDir, projectDir, 'chats');
+        let chatFiles;
+        try {
+            chatFiles = await fs.readdir(chatsDir);
+        }
+        catch {
+            continue;
+        }
+        for (const chatFile of chatFiles) {
+            if (!chatFile.endsWith('.json'))
+                continue;
+            try {
+                const filePath = path.join(chatsDir, chatFile);
+                const data = await fs.readFile(filePath, 'utf8');
+                const session = JSON.parse(data);
+                const fileSessionId = session.sessionId || chatFile.replace('.json', '');
+                if (fileSessionId !== sessionId)
+                    continue;
+                return (session.messages || []).map(msg => {
+                    const role = msg.type === 'user' ? 'user'
+                        : (msg.type === 'gemini' || msg.type === 'assistant') ? 'assistant'
+                            : msg.type;
+                    let content = '';
+                    if (typeof msg.content === 'string') {
+                        content = msg.content;
+                    }
+                    else if (Array.isArray(msg.content)) {
+                        content = msg.content.filter(p => p.text).map(p => p.text).join('\n');
+                    }
+                    return {
+                        type: 'message',
+                        message: { role, content },
+                        timestamp: msg.timestamp || null
+                    };
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return [];
+}
+export { getProjects, getSessions, getSessionMessages, parseJsonlSessions, renameProject, deleteSession, isProjectEmpty, deleteProject, addProjectManually, loadProjectConfig, saveProjectConfig, extractProjectDirectory, clearProjectDirectoryCache, getCodexSessions, getCodexSessionMessages, deleteCodexSession, getGeminiCliSessions, getGeminiCliSessionMessages, searchConversations };
+//# sourceMappingURL=projects.js.map