@axhub/genie 0.1.7 → 0.1.9

package/server/projects.js

@@ -2,7 +2,7 @@
  * PROJECT DISCOVERY AND MANAGEMENT SYSTEM
  * ========================================
  * 
- * This module manages project discovery for both Claude CLI and Cursor CLI sessions.
+ * This module manages project discovery for Claude CLI and local agent sessions.
  * 
  * ## Architecture Overview
  * 
@@ -11,11 +11,9 @@
  *    - 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
+ * 2. **Manual project metadata**
+ *    - Project metadata is stored in ~/.claude/project-config.json
+ *    - Manually added workspaces remain visible even without existing sessions
  * 
  * ## Project Discovery Strategy
  * 
@@ -24,25 +22,15 @@
  *    - 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**:
+ * 2. **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
+ *    - Allows discovering additional local provider sessions 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.
+ *   existing local session history may no longer align with the new path.
  * 
  * ## Error Handling
  * 
@@ -59,12 +47,10 @@
 
 import { promises as fs } from 'fs';
 import fsSync from 'fs';
+import os from 'os';
 import path from 'path';
 import readline from 'readline';
 import crypto from 'crypto';
-import sqlite3 from 'sqlite3';
-import { open } from 'sqlite';
-import os from 'os';
 import { parseCodexTokenCountInfo } from './utils/codexTokenUsage.js';
 
 // Import TaskMaster detection functions
@@ -197,12 +183,131 @@ async function detectTaskMasterFolder(projectPath) {
 
 // Cache for extracted project directories
 const projectDirectoryCache = new Map();
+const PROVIDER_SESSION_LOOKUP_CACHE_TTL_MS = 5000;
+const providerSessionLookupCache = {
+  codex: { key: null, data: null, promise: null, expiresAt: 0 },
+  gemini: { key: null, data: null, promise: null, expiresAt: 0 },
+  opencode: { key: null, data: null, promise: null, expiresAt: 0 }
+};
+
+function normalizeComparableProjectPath(projectPath) {
+  if (typeof projectPath !== 'string' || !projectPath.trim()) {
+    return '';
+  }
+
+  const withoutWindowsLongPathPrefix = projectPath.startsWith('\\\\?\\')
+    ? projectPath.slice(4)
+    : projectPath;
+
+  return path.normalize(withoutWindowsLongPathPrefix);
+}
+
+function groupSessionsByNormalizedProjectPath(projectPaths, sessions, limit = 5) {
+  const groupedSessions = new Map();
+  const trackedPaths = new Set(
+    (projectPaths || [])
+      .map(normalizeComparableProjectPath)
+      .filter(Boolean)
+  );
+
+  for (const normalizedPath of trackedPaths) {
+    groupedSessions.set(normalizedPath, []);
+  }
+
+  for (const session of sessions) {
+    const normalizedCwd = normalizeComparableProjectPath(session?.cwd);
+    if (!normalizedCwd || !trackedPaths.has(normalizedCwd)) {
+      continue;
+    }
+
+    groupedSessions.get(normalizedCwd).push(session);
+  }
+
+  for (const [normalizedPath, grouped] of groupedSessions.entries()) {
+    grouped.sort((a, b) => new Date(b.lastActivity || 0) - new Date(a.lastActivity || 0));
+    groupedSessions.set(normalizedPath, limit > 0 ? grouped.slice(0, limit) : grouped);
+  }
+
+  return groupedSessions;
+}
+
+async function findFilesRecursively(rootDir, matcher) {
+  const discoveredFiles = [];
+
+  const walk = 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()) {
+          await walk(fullPath);
+        } else if (matcher(entry.name, fullPath, entry)) {
+          discoveredFiles.push(fullPath);
+        }
+      }
+    } catch (_) {
+      // Skip unreadable directories without failing the whole discovery pass.
+    }
+  };
+
+  try {
+    await fs.access(rootDir);
+  } catch (_) {
+    return [];
+  }
+
+  await walk(rootDir);
+  return discoveredFiles;
+}
 
 // Clear cache when needed (called when project files change)
 function clearProjectDirectoryCache() {
   projectDirectoryCache.clear();
 }
 
+function clearProviderSessionLookupCaches() {
+  for (const cacheEntry of Object.values(providerSessionLookupCache)) {
+    cacheEntry.key = null;
+    cacheEntry.data = null;
+    cacheEntry.promise = null;
+    cacheEntry.expiresAt = 0;
+  }
+}
+
+async function getCachedProviderSessionLookup(providerName, cacheKey, buildLookup) {
+  const cacheEntry = providerSessionLookupCache[providerName];
+
+  if (!cacheEntry) {
+    return buildLookup();
+  }
+
+  if (
+    cacheEntry.key === cacheKey &&
+    cacheEntry.data &&
+    cacheEntry.expiresAt > Date.now()
+  ) {
+    return cacheEntry.data;
+  }
+
+  if (cacheEntry.key === cacheKey && cacheEntry.promise) {
+    return cacheEntry.promise;
+  }
+
+  cacheEntry.key = cacheKey;
+  cacheEntry.promise = Promise.resolve()
+    .then(buildLookup)
+    .then((lookup) => {
+      cacheEntry.data = lookup;
+      cacheEntry.expiresAt = Date.now() + PROVIDER_SESSION_LOOKUP_CACHE_TTL_MS;
+      return lookup;
+    })
+    .finally(() => {
+      cacheEntry.promise = null;
+    });
+
+  return cacheEntry.promise;
+}
+
 // Load project configuration file
 async function loadProjectConfig() {
   const configPath = path.join(os.homedir(), '.claude', 'project-config.json');
@@ -385,6 +490,7 @@ async function getProjects(progressCallback = null) {
   const config = await loadProjectConfig();
   const projects = [];
   const existingProjects = new Set();
+  const projectDefinitions = [];
   let totalProjects = 0;
   let processedProjects = 0;
   let directories = [];
@@ -420,8 +526,6 @@ async function getProjects(progressCallback = null) {
           });
         }
 
-        const projectPath = path.join(claudeDir, entry.name);
-        
         // Extract actual project directory from JSONL sessions
         const actualProjectDir = await extractProjectDirectory(entry.name);
         
@@ -430,81 +534,14 @@ async function getProjects(progressCallback = null) {
         const autoDisplayName = await generateDisplayName(entry.name, actualProjectDir);
         const fullPath = actualProjectDir;
         
-        const project = {
+        projectDefinitions.push({
           name: entry.name,
           path: actualProjectDir,
           displayName: customName || autoDisplayName,
           fullPath: fullPath,
           isCustomName: !!customName,
-          sessions: [],
-          cursorSessions: [],
-          codexSessions: [],
-          opencodeSessions: [],
-          geminiSessions: []
-        };
-        
-        // 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);
-        }
-        
-        // Also fetch Cursor sessions for this project
-        try {
-          project.cursorSessions = await getCursorSessions(actualProjectDir);
-        } catch (e) {
-          console.warn(`Could not load Cursor sessions for project ${entry.name}:`, e.message);
-          project.cursorSessions = [];
-        }
-
-        // Also fetch Codex sessions for this project
-        try {
-          project.codexSessions = await getCodexSessions(actualProjectDir);
-        } catch (e) {
-          console.warn(`Could not load Codex sessions for project ${entry.name}:`, e.message);
-          project.codexSessions = [];
-        }
-
-        try {
-          project.geminiSessions = await getGeminiSessions(actualProjectDir);
-        } catch (e) {
-          console.warn(`Could not load Gemini sessions for project ${entry.name}:`, e.message);
-          project.geminiSessions = [];
-        }
-
-        try {
-          project.opencodeSessions = await getOpencodeSessions(actualProjectDir);
-        } catch (e) {
-          console.warn(`Could not load OpenCode sessions for project ${entry.name}:`, e.message);
-          project.opencodeSessions = [];
-        }
-
-        // Add TaskMaster detection
-        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);
+          isManuallyAdded: false
+        });
     }
   } catch (error) {
     // If the directory doesn't exist (ENOENT), that's okay - just continue with empty projects
@@ -544,74 +581,80 @@ async function getProjects(progressCallback = null) {
         }
       }
       
-       const project = {
+      projectDefinitions.push({
           name: projectName,
           path: actualProjectDir,
           displayName: projectConfig.displayName || await generateDisplayName(projectName, actualProjectDir),
           fullPath: actualProjectDir,
           isCustomName: !!projectConfig.displayName,
-          isManuallyAdded: true,
-          sessions: [],
-          cursorSessions: [],
-          codexSessions: [],
-          opencodeSessions: [],
-          geminiSessions: []
-        };
-
-      // Try to fetch Cursor sessions for manual projects too
-      try {
-        project.cursorSessions = await getCursorSessions(actualProjectDir);
-      } catch (e) {
-        console.warn(`Could not load Cursor sessions for manual project ${projectName}:`, e.message);
-      }
-
-      // Try to fetch Codex sessions for manual projects too
-      try {
-        project.codexSessions = await getCodexSessions(actualProjectDir);
-      } catch (e) {
-        console.warn(`Could not load Codex sessions for manual project ${projectName}:`, e.message);
-      }
+          isManuallyAdded: true
+        });
+    }
+  }
 
-      try {
-        project.geminiSessions = await getGeminiSessions(actualProjectDir);
-      } catch (e) {
-        console.warn(`Could not load Gemini sessions for manual project ${projectName}:`, e.message);
-      }
+  const uniqueProjectPaths = Array.from(new Set(
+    projectDefinitions
+      .map((definition) => normalizeComparableProjectPath(definition.fullPath))
+      .filter(Boolean)
+  ));
+
+  const [codexSessionsByProjectPath, geminiSessionsByProjectPath, opencodeSessionsByProjectPath] = await Promise.all([
+    buildCodexSessionsLookup(uniqueProjectPaths, { limit: 5 }),
+    buildGeminiSessionsLookup(uniqueProjectPaths, { limit: 5 }),
+    buildOpencodeSessionsLookup(uniqueProjectPaths, { limit: 5 })
+  ]);
+
+  for (const definition of projectDefinitions) {
+    const normalizedProjectPath = normalizeComparableProjectPath(definition.fullPath);
+    const project = {
+      name: definition.name,
+      path: definition.path,
+      displayName: definition.displayName,
+      fullPath: definition.fullPath,
+      isCustomName: definition.isCustomName,
+      isManuallyAdded: !!definition.isManuallyAdded,
+      sessions: [],
+      codexSessions: codexSessionsByProjectPath.get(normalizedProjectPath) || [],
+      opencodeSessions: opencodeSessionsByProjectPath.get(normalizedProjectPath) || [],
+      geminiSessions: geminiSessionsByProjectPath.get(normalizedProjectPath) || []
+    };
 
+    if (!definition.isManuallyAdded) {
       try {
-        project.opencodeSessions = await getOpencodeSessions(actualProjectDir);
+        const sessionResult = await getSessions(definition.name, 5, 0);
+        project.sessions = sessionResult.sessions || [];
+        project.sessionMeta = {
+          hasMore: sessionResult.hasMore,
+          total: sessionResult.total
+        };
       } catch (e) {
-        console.warn(`Could not load OpenCode sessions for manual project ${projectName}:`, e.message);
+        console.warn(`Could not load sessions for project ${definition.name}:`, e.message);
       }
+    }
 
-      // Add TaskMaster detection for manual projects
-      try {
-        const taskMasterResult = await detectTaskMasterFolder(actualProjectDir);
-        
-        // Determine TaskMaster status
-        let taskMasterStatus = 'not-configured';
-        if (taskMasterResult.hasTaskmaster && taskMasterResult.hasEssentialFiles) {
-          taskMasterStatus = 'taskmaster-only'; // We don't check MCP for manual projects in bulk
-        }
-        
-        project.taskmaster = {
-          status: taskMasterStatus,
-          hasTaskmaster: taskMasterResult.hasTaskmaster,
-          hasEssentialFiles: taskMasterResult.hasEssentialFiles,
-          metadata: taskMasterResult.metadata
-        };
-      } catch (error) {
-        console.warn(`TaskMaster detection failed for manual project ${projectName}:`, error.message);
-        project.taskmaster = {
-          status: 'error',
-          hasTaskmaster: false,
-          hasEssentialFiles: false,
-          error: error.message
-        };
-      }
-      
-      projects.push(project);
+    try {
+      const taskMasterResult = await detectTaskMasterFolder(definition.fullPath);
+      const taskMasterStatus = definition.isManuallyAdded
+        ? (taskMasterResult.hasTaskmaster && taskMasterResult.hasEssentialFiles ? 'taskmaster-only' : 'not-configured')
+        : (taskMasterResult.hasTaskmaster && taskMasterResult.hasEssentialFiles ? 'configured' : 'not-configured');
+
+      project.taskmaster = {
+        status: taskMasterStatus,
+        hasTaskmaster: taskMasterResult.hasTaskmaster,
+        hasEssentialFiles: taskMasterResult.hasEssentialFiles,
+        metadata: taskMasterResult.metadata
+      };
+    } catch (error) {
+      console.warn(`TaskMaster detection failed for project ${definition.name}:`, error.message);
+      project.taskmaster = {
+        status: 'error',
+        hasTaskmaster: false,
+        hasEssentialFiles: false,
+        error: error.message
+      };
     }
+
+    projects.push(project);
   }
 
   // Emit completion after all projects (including manual) are processed
@@ -1094,15 +1137,6 @@ async function deleteProject(projectName, force = false) {
       } 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
-      }
     }
 
     // Remove from project config
@@ -1139,7 +1173,7 @@ async function addProjectManually(projectPath, displayName = null) {
   }
 
   // Allow adding projects even if the directory exists - this enables tracking
-  // existing Claude Code or Cursor projects in the UI
+  // existing Claude Code projects in the UI
 
   // Add to config as manually added project
   config[projectName] = {
@@ -1160,174 +1194,28 @@ async function addProjectManually(projectPath, displayName = null) {
     fullPath: absolutePath,
     displayName: displayName || await generateDisplayName(projectName, absolutePath),
     isManuallyAdded: true,
-    sessions: [],
-    cursorSessions: [],
-    codexSessions: [],
+    sessions: [],    codexSessions: [],
     opencodeSessions: [],
     geminiSessions: []
   };
 }
 
-// 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 = await open({
-          filename: storeDbPath,
-          driver: sqlite3.Database,
-          mode: sqlite3.OPEN_READONLY
-        });
-        
-        // Get metadata from meta table
-        const metaRows = await db.all(`
-          SELECT key, value FROM meta
-        `);
-        
-        // 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 = await db.get(`
-          SELECT COUNT(*) as count FROM blobs
-        `);
-        
-        await 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 [];
-  }
-}
-
-
-// Fetch Codex sessions for a given project path
 async function getCodexSessions(projectPath, options = {}) {
   const { limit = 5 } = options;
   try {
-    const codexSessionsDir = path.join(os.homedir(), '.codex', 'sessions');
     const sessions = [];
-
-    // Check if the directory exists
-    try {
-      await fs.access(codexSessionsDir);
-    } catch (error) {
-      // No Codex sessions directory
-      return [];
-    }
-
-    // Recursively find all .jsonl files in the sessions directory
-    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) {
-        // Skip directories we can't read
-      }
-      return files;
-    };
-
-    const jsonlFiles = await findJsonlFiles(codexSessionsDir);
+    const normalizedProjectPath = normalizeComparableProjectPath(projectPath);
+    const jsonlFiles = await findFilesRecursively(
+      path.join(os.homedir(), '.codex', 'sessions'),
+      (entryName) => entryName.endsWith('.jsonl')
+    );
 
     // Process each file to find sessions matching the project path
     for (const filePath of jsonlFiles) {
       try {
         const sessionData = await parseCodexSessionFile(filePath);
 
-        // Check if this session matches the project path
-        // Handle Windows long paths with \\?\ prefix
-        const sessionCwd = sessionData?.cwd || '';
-        const cleanSessionCwd = sessionCwd.startsWith('\\\\?\\') ? sessionCwd.slice(4) : sessionCwd;
-        const cleanProjectPath = projectPath.startsWith('\\\\?\\') ? projectPath.slice(4) : projectPath;
-
-        if (sessionData && (sessionData.cwd === projectPath || cleanSessionCwd === cleanProjectPath || path.relative(cleanSessionCwd, cleanProjectPath) === '')) {
+        if (sessionData && normalizeComparableProjectPath(sessionData.cwd) === normalizedProjectPath) {
           sessions.push({
             id: sessionData.id,
             summary: sessionData.summary || 'Codex Session',
@@ -1364,25 +1252,12 @@ const OPENCODE_SESSION_DIR_CANDIDATES = [
 async function findOpencodeSessionFiles() {
   const files = [];
 
-  const walk = async (dirPath) => {
-    try {
-      const entries = await fs.readdir(dirPath, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-          await walk(fullPath);
-        } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
-          files.push(fullPath);
-        }
-      }
-    } catch (_) {}
-  };
-
   for (const baseDir of OPENCODE_SESSION_DIR_CANDIDATES) {
-    try {
-      await fs.access(baseDir);
-      await walk(baseDir);
-    } catch (_) {}
+    const discovered = await findFilesRecursively(
+      baseDir,
+      (entryName, _fullPath, entry) => entry.isFile() && entryName.endsWith('.jsonl')
+    );
+    files.push(...discovered);
   }
 
   return Array.from(new Set(files));
@@ -1852,6 +1727,120 @@ async function parseGeminiSessionFile(filePath) {
   };
 }
 
+async function buildCodexSessionsLookup(projectPaths, options = {}) {
+  const { limit = 5 } = options;
+  const normalizedProjectPaths = Array.from(new Set(
+    (projectPaths || []).map(normalizeComparableProjectPath).filter(Boolean)
+  ));
+
+  if (normalizedProjectPaths.length === 0) {
+    return new Map();
+  }
+
+  const cacheKey = JSON.stringify({ projectPaths: normalizedProjectPaths, limit });
+  return getCachedProviderSessionLookup('codex', cacheKey, async () => {
+    const jsonlFiles = await findFilesRecursively(
+      path.join(os.homedir(), '.codex', 'sessions'),
+      (entryName) => entryName.endsWith('.jsonl')
+    );
+
+    const sessions = [];
+    for (const filePath of jsonlFiles) {
+      try {
+        const sessionData = await parseCodexSessionFile(filePath);
+        if (sessionData?.id) {
+          sessions.push({
+            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'
+          });
+        }
+      } catch (error) {
+        console.warn(`Could not parse Codex session file ${filePath}:`, error.message);
+      }
+    }
+
+    return groupSessionsByNormalizedProjectPath(normalizedProjectPaths, sessions, limit);
+  });
+}
+
+async function buildOpencodeSessionsLookup(projectPaths, options = {}) {
+  const { limit = 5 } = options;
+  const normalizedProjectPaths = Array.from(new Set(
+    (projectPaths || []).map(normalizeComparableProjectPath).filter(Boolean)
+  ));
+
+  if (normalizedProjectPaths.length === 0) {
+    return new Map();
+  }
+
+  const cacheKey = JSON.stringify({ projectPaths: normalizedProjectPaths, limit });
+  return getCachedProviderSessionLookup('opencode', cacheKey, async () => {
+    const sessionFiles = await findOpencodeSessionFiles();
+    const sessions = [];
+
+    for (const filePath of sessionFiles) {
+      const sessionData = await parseOpencodeSessionFile(filePath);
+      if (sessionData?.id) {
+        sessions.push(sessionData);
+      }
+    }
+
+    return groupSessionsByNormalizedProjectPath(normalizedProjectPaths, sessions, limit);
+  });
+}
+
+async function buildGeminiSessionsLookup(projectPaths, options = {}) {
+  const { limit = 5 } = options;
+  const normalizedProjectPaths = Array.from(new Set(
+    (projectPaths || []).map(normalizeComparableProjectPath).filter(Boolean)
+  ));
+
+  const cacheKey = JSON.stringify({ projectPaths: normalizedProjectPaths, limit });
+  return getCachedProviderSessionLookup('gemini', cacheKey, async () => {
+    const sessionsByProjectPath = new Map();
+
+    for (const normalizedProjectPath of normalizedProjectPaths) {
+      const projectHash = crypto.createHash('sha256').update(normalizedProjectPath).digest('hex');
+      const chatsDir = path.join(os.homedir(), '.gemini', 'tmp', projectHash, 'chats');
+
+      try {
+        const entries = await fs.readdir(chatsDir, { withFileTypes: true });
+        const sessionFiles = entries
+          .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+          .map((entry) => path.join(chatsDir, entry.name));
+
+        const sessions = [];
+        for (const filePath of sessionFiles) {
+          try {
+            const sessionData = await parseGeminiSessionFile(filePath);
+            if (sessionData?.id) {
+              sessions.push(sessionData);
+            }
+          } catch (error) {
+            console.warn(`Could not parse Gemini session file ${filePath}:`, error.message);
+          }
+        }
+
+        sessions.sort((a, b) => new Date(b.lastActivity || 0) - new Date(a.lastActivity || 0));
+        sessionsByProjectPath.set(
+          normalizedProjectPath,
+          limit > 0 ? sessions.slice(0, limit) : sessions
+        );
+      } catch (_) {
+        sessionsByProjectPath.set(normalizedProjectPath, []);
+      }
+    }
+
+    return sessionsByProjectPath;
+  });
+}
+
 async function getGeminiSessionMessages(sessionId, limit = null, offset = 0) {
   try {
     const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
@@ -1966,9 +1955,16 @@ async function parseCodexSessionFile(filePath) {
       crlfDelay: Infinity
     });
 
+    const isUsableCodexModel = (value) => {
+      if (typeof value !== 'string') return false;
+      const normalized = value.trim().toLowerCase();
+      return normalized.length > 0 && normalized !== 'custom' && normalized !== 'default';
+    };
+
     let sessionMeta = null;
     let lastTimestamp = null;
     let lastUserMessage = null;
+    let lastResolvedModel = null;
     let messageCount = 0;
 
     for await (const line of rl) {
@@ -1990,6 +1986,16 @@ async function parseCodexSessionFile(filePath) {
               timestamp: entry.timestamp,
               git: entry.payload.git
             };
+
+            if (isUsableCodexModel(entry.payload.model)) {
+              lastResolvedModel = entry.payload.model;
+            } else if (isUsableCodexModel(entry.payload.model_provider)) {
+              lastResolvedModel = entry.payload.model_provider;
+            }
+          }
+
+          if (entry.type === 'turn_context' && isUsableCodexModel(entry.payload?.model)) {
+            lastResolvedModel = entry.payload.model;
           }
 
           // Count messages and extract user messages for summary
@@ -2013,6 +2019,7 @@ async function parseCodexSessionFile(filePath) {
     if (sessionMeta) {
       return {
         ...sessionMeta,
+        model: lastResolvedModel || sessionMeta.model || null,
         timestamp: lastTimestamp || sessionMeta.timestamp,
         summary: lastUserMessage ?
           (lastUserMessage.length > 50 ? lastUserMessage.substring(0, 50) + '...' : lastUserMessage) :
@@ -2309,10 +2316,12 @@ export {
   saveProjectConfig,
   extractProjectDirectory,
   clearProjectDirectoryCache,
+  clearProviderSessionLookupCaches,
   getCodexSessions,
   getCodexSessionMessages,
   getOpencodeSessions,
   getOpencodeSessionMessages,
+  getGeminiSessions,
   getGeminiSessionMessages,
   deleteCodexSession,
   deleteOpencodeSession