@axhub/genie 0.2.7 → 0.2.9

package/server/projects.js

@@ -51,13 +51,62 @@ import os from 'os';
 import path from 'path';
 import readline from 'readline';
 import crypto from 'crypto';
+import { fileURLToPath } from 'url';
 import { parseCodexTokenCountInfo } from './utils/codexTokenUsage.js';
 import { CODEX_MODELS } from '../shared/modelConstants.js';
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const KNOWN_CODEX_MODELS = new Set(
   (CODEX_MODELS?.OPTIONS || []).map((option) => String(option?.value || '').trim().toLowerCase()).filter(Boolean)
 );
 
+const PROJECT_CONFIG_PERMISSION_ERROR_CODES = new Set(['EACCES', 'EPERM', 'EROFS']);
+
+function getPrimaryProjectConfigPath() {
+  return path.join(os.homedir(), '.claude', 'project-config.json');
+}
+
+function getFallbackProjectConfigPath() {
+  const dataFilePath = process.env.DATA_FILE_PATH || path.join(__dirname, 'database', 'state.json');
+  return path.join(path.dirname(dataFilePath), 'project-config.json');
+}
+
+function getProjectConfigPaths() {
+  return [...new Set([
+    getPrimaryProjectConfigPath(),
+    getFallbackProjectConfigPath()
+  ])];
+}
+
+function isProjectConfigPermissionError(error) {
+  return Boolean(error && PROJECT_CONFIG_PERMISSION_ERROR_CODES.has(error.code));
+}
+
+function normalizeProjectConfig(rawConfig) {
+  if (!rawConfig || typeof rawConfig !== 'object' || Array.isArray(rawConfig)) {
+    return {};
+  }
+
+  return rawConfig;
+}
+
+async function writeProjectConfigFile(configPath, config) {
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+
+async function removeProjectConfigFile(configPath) {
+  try {
+    await fs.rm(configPath, { force: true });
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+}
+
 function isRecognizedCodexModel(value) {
   if (typeof value !== 'string') return false;
   const normalized = value.trim().toLowerCase();
@@ -97,7 +146,12 @@ function extractVisibleUserMessage(value) {
     return '';
   }
 
-  if (text.startsWith('# AGENTS.md instructions for ') || text.includes('<environment_context>')) {
+  if (
+    text.startsWith('# AGENTS.md instructions for ') ||
+    text.includes('<environment_context>') ||
+    text.startsWith('<subagent_notification>') ||
+    text.startsWith('</subagent_notification>')
+  ) {
     return '';
   }
 
@@ -128,12 +182,16 @@ function isInjectedContextContent(value) {
 
   if (
     text.startsWith('# AGENTS.md instructions for ') ||
-    text.startsWith('[DYNAMIC CONTEXT V1]')
+    text.startsWith('[DYNAMIC CONTEXT V1]') ||
+    text.startsWith('<subagent_notification>') ||
+    text.startsWith('</subagent_notification>')
   ) {
     return true;
   }
 
-  return /^<dynamic_context(?:\s|>)/i.test(text) || text.includes('<environment_context>');
+  return /^<dynamic_context(?:\s|>)/i.test(text)
+    || text.includes('<environment_context>')
+    || /<subagent_notification(?:\s|>)/i.test(text);
 }
 
 // Import TaskMaster detection functions
@@ -266,7 +324,14 @@ async function detectTaskMasterFolder(projectPath) {
 
 // Cache for extracted project directories
 const projectDirectoryCache = new Map();
+const PROJECT_LIST_CACHE_TTL_MS = 15000;
 const PROVIDER_SESSION_LOOKUP_CACHE_TTL_MS = 5000;
+const projectListCache = {
+  data: null,
+  promise: null,
+  expiresAt: 0
+};
+const codexSessionFileCache = new Map();
 const providerSessionLookupCache = {
   codex: { key: null, data: null, promise: null, expiresAt: 0 },
   gemini: { key: null, data: null, promise: null, expiresAt: 0 },
@@ -343,9 +408,81 @@ async function findFilesRecursively(rootDir, matcher) {
   return discoveredFiles;
 }
 
+function getCodexSessionsDir() {
+  return path.join(os.homedir(), '.codex', 'sessions');
+}
+
+function cacheCodexSessionFilePath(sessionId, filePath) {
+  if (!sessionId || !filePath) {
+    return;
+  }
+
+  codexSessionFileCache.set(sessionId, filePath);
+}
+
+function findCodexSessionFilePathBySessionIdHint(sessionId, filePaths = []) {
+  const normalizedSessionId = String(sessionId || '').trim();
+  if (!normalizedSessionId || !Array.isArray(filePaths) || filePaths.length === 0) {
+    return null;
+  }
+
+  return filePaths.find((filePath) => {
+    const basename = path.basename(filePath, '.jsonl');
+    return basename === normalizedSessionId || basename.includes(normalizedSessionId);
+  }) || null;
+}
+
+async function resolveCodexSessionFile(sessionId) {
+  if (!sessionId) {
+    return null;
+  }
+
+  const cachedPath = codexSessionFileCache.get(sessionId);
+  if (cachedPath) {
+    try {
+      await fs.access(cachedPath);
+      return cachedPath;
+    } catch (_) {
+      codexSessionFileCache.delete(sessionId);
+    }
+  }
+
+  const jsonlFiles = await findFilesRecursively(
+    getCodexSessionsDir(),
+    (entryName) => entryName.endsWith('.jsonl')
+  );
+
+  const hintedFilePath = findCodexSessionFilePathBySessionIdHint(sessionId, jsonlFiles);
+  if (hintedFilePath) {
+    cacheCodexSessionFilePath(sessionId, hintedFilePath);
+    return hintedFilePath;
+  }
+
+  for (const filePath of jsonlFiles) {
+    try {
+      const sessionData = await parseCodexSessionFile(filePath);
+      if (sessionData?.id === sessionId) {
+        cacheCodexSessionFilePath(sessionId, filePath);
+        return filePath;
+      }
+    } catch (error) {
+      console.warn(`Could not parse Codex session file ${filePath}:`, error.message);
+    }
+  }
+
+  return null;
+}
+
+function clearProjectListCache() {
+  projectListCache.data = null;
+  projectListCache.promise = null;
+  projectListCache.expiresAt = 0;
+}
+
 // Clear cache when needed (called when project files change)
 function clearProjectDirectoryCache() {
   projectDirectoryCache.clear();
+  clearProjectListCache();
 }
 
 function clearProviderSessionLookupCaches() {
@@ -357,6 +494,27 @@ function clearProviderSessionLookupCaches() {
   }
 }
 
+function appendBoundedMessage(buffer, message, maxSize = null) {
+  if (!message) {
+    return;
+  }
+
+  if (maxSize === null) {
+    buffer.push(message);
+    return;
+  }
+
+  if (maxSize <= 0) {
+    return;
+  }
+
+  if (buffer.length === maxSize) {
+    buffer.shift();
+  }
+
+  buffer.push(message);
+}
+
 async function getCachedProviderSessionLookup(providerName, cacheKey, buildLookup) {
   const cacheEntry = providerSessionLookupCache[providerName];
 
@@ -393,31 +551,54 @@ async function getCachedProviderSessionLookup(providerName, cacheKey, buildLooku
 
 // 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 {};
+  const mergedConfig = {};
+
+  for (const configPath of getProjectConfigPaths()) {
+    try {
+      const configData = await fs.readFile(configPath, 'utf8');
+      Object.assign(mergedConfig, normalizeProjectConfig(JSON.parse(configData)));
+    } catch (error) {
+      // Return merged config from any readable location.
+    }
   }
+
+  return mergedConfig;
 }
 
 // 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') {
+  const normalizedConfig = normalizeProjectConfig(config);
+  const [primaryConfigPath, ...fallbackConfigPaths] = getProjectConfigPaths();
+  let lastPermissionError = null;
+
+  for (const configPath of [primaryConfigPath, ...fallbackConfigPaths]) {
+    try {
+      await writeProjectConfigFile(configPath, normalizedConfig);
+
+      if (configPath === primaryConfigPath) {
+        for (const fallbackConfigPath of fallbackConfigPaths) {
+          await removeProjectConfigFile(fallbackConfigPath);
+        }
+      }
+
+      clearProjectDirectoryCache();
+      return;
+    } catch (error) {
+      if (isProjectConfigPermissionError(error)) {
+        lastPermissionError = error;
+        continue;
+      }
+
       throw error;
     }
   }
-  
-  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+
+  if (lastPermissionError) {
+    const saveError = new Error('Unable to save the project list because both Claude config storage and the app data directory are not writable.');
+    saveError.code = lastPermissionError.code;
+    saveError.cause = lastPermissionError;
+    throw saveError;
+  }
 }
 
 // Generate better display name from path
@@ -568,15 +749,17 @@ async function extractProjectDirectory(projectName) {
   }
 }
 
-async function getProjects(progressCallback = null) {
+function cloneProjectList(projects = []) {
+  return projects.map((project) => ({ ...project }));
+}
+
+async function collectProjectDefinitions(progressCallback = null) {
   const claudeDir = path.join(os.homedir(), '.claude', 'projects');
   const config = await loadProjectConfig();
-  const projects = [];
   const existingProjects = new Set();
   const projectDefinitions = [];
   let totalProjects = 0;
   let processedProjects = 0;
-  let directories = [];
 
   try {
     // Check if the .claude/projects directory exists
@@ -584,7 +767,7 @@ async function getProjects(progressCallback = null) {
 
     // First, get existing Claude projects from the file system
     const entries = await fs.readdir(claudeDir, { withFileTypes: true });
-    directories = entries.filter(e => e.isDirectory());
+    const directories = entries.filter(e => e.isDirectory());
 
     // Build set of existing project names for later
     directories.forEach(e => existingProjects.add(e.name));
@@ -675,69 +858,173 @@ async function getProjects(progressCallback = null) {
     }
   }
 
-  const uniqueProjectPaths = Array.from(new Set(
-    projectDefinitions
-      .map((definition) => normalizeComparableProjectPath(definition.fullPath))
-      .filter(Boolean)
-  ));
+  return {
+    projectDefinitions,
+    totalProjects
+  };
+}
 
-  const [codexSessionsByProjectPath, geminiSessionsByProjectPath, opencodeSessionsByProjectPath] = await Promise.all([
-    buildCodexSessionsLookup(uniqueProjectPaths, { limit: 5 }),
-    buildGeminiSessionsLookup(uniqueProjectPaths, { limit: 5 }),
-    buildOpencodeSessionsLookup(uniqueProjectPaths, { limit: 5 })
-  ]);
+async function getProjectsList(progressCallback = null) {
+  if (
+    projectListCache.data &&
+    projectListCache.expiresAt > Date.now()
+  ) {
+    const cachedProjects = cloneProjectList(projectListCache.data);
+    if (progressCallback) {
+      progressCallback({
+        phase: 'complete',
+        current: cachedProjects.length,
+        total: cachedProjects.length
+      });
+    }
+    return cachedProjects;
+  }
 
-  for (const definition of projectDefinitions) {
-    const normalizedProjectPath = normalizeComparableProjectPath(definition.fullPath);
-    const project = {
+  if (!progressCallback && projectListCache.promise) {
+    return cloneProjectList(await projectListCache.promise);
+  }
+
+  const loadProjectsList = async () => {
+    const { projectDefinitions, totalProjects } = await collectProjectDefinitions(progressCallback);
+    const lightweightProjects = projectDefinitions.map((definition) => ({
       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) || []
-    };
+      isManuallyAdded: !!definition.isManuallyAdded
+    }));
 
-    if (!definition.isManuallyAdded) {
-      try {
-        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 sessions for project ${definition.name}:`, e.message);
-      }
+    projectListCache.data = lightweightProjects;
+    projectListCache.expiresAt = Date.now() + PROJECT_LIST_CACHE_TTL_MS;
+
+    if (progressCallback) {
+      progressCallback({
+        phase: 'complete',
+        current: totalProjects,
+        total: totalProjects
+      });
     }
 
-    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
+    return lightweightProjects;
+  };
+
+  if (progressCallback) {
+    return loadProjectsList();
+  }
+
+  projectListCache.promise = loadProjectsList().finally(() => {
+    projectListCache.promise = null;
+  });
+
+  return cloneProjectList(await projectListCache.promise);
+}
+
+async function buildProjectFromDefinition(definition, providerLookups = null) {
+  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: [],
+    opencodeSessions: [],
+    geminiSessions: [],
+    sessionMeta: {
+      hasMore: false,
+      total: 0
+    }
+  };
+
+  try {
+    if (providerLookups) {
+      project.codexSessions = providerLookups.codexSessionsByProjectPath?.get(normalizedProjectPath) || [];
+      project.opencodeSessions = providerLookups.opencodeSessionsByProjectPath?.get(normalizedProjectPath) || [];
+      project.geminiSessions = providerLookups.geminiSessionsByProjectPath?.get(normalizedProjectPath) || [];
+    } else {
+      const [codexSessions, opencodeSessions, geminiSessions] = await Promise.all([
+        getCodexSessions(definition.fullPath, { limit: 5 }),
+        getOpencodeSessions(definition.fullPath, { limit: 5 }),
+        getGeminiSessions(definition.fullPath, { limit: 5 })
+      ]);
+      project.codexSessions = codexSessions;
+      project.opencodeSessions = opencodeSessions;
+      project.geminiSessions = geminiSessions;
+    }
+
+    if (!definition.isManuallyAdded) {
+      const sessionResult = await getSessions(definition.name, 5, 0);
+      project.sessions = sessionResult.sessions || [];
+      project.sessionMeta = {
+        hasMore: sessionResult.hasMore,
+        total: sessionResult.total
       };
     }
+  } catch (error) {
+    console.warn(`Could not load session details for project ${definition.name}:`, error.message);
+  }
+
+  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
+    };
+  }
+
+  return project;
+}
+
+async function getProjectDetails(projectName) {
+  const projectList = await getProjectsList();
+  const definition = projectList.find((project) => project.name === projectName);
 
-    projects.push(project);
+  if (!definition) {
+    throw new Error(`Project not found: ${projectName}`);
+  }
+
+  return buildProjectFromDefinition(definition);
+}
+
+async function getProjects(progressCallback = null) {
+  const projects = [];
+  const { projectDefinitions, totalProjects } = await collectProjectDefinitions(progressCallback);
+
+  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) {
+    projects.push(await buildProjectFromDefinition(definition, {
+      codexSessionsByProjectPath,
+      opencodeSessionsByProjectPath,
+      geminiSessionsByProjectPath
+    }));
   }
 
   // Emit completion after all projects (including manual) are processed
@@ -880,6 +1167,43 @@ async function getSessions(projectName, limit = 5, offset = 0) {
   }
 }
 
+async function getClaudeSessionMetadata(sessionId) {
+  try {
+    const normalizedSessionId = String(sessionId || '').trim();
+    if (!normalizedSessionId) {
+      return null;
+    }
+
+    const claudeProjectsDir = path.join(os.homedir(), '.claude', 'projects');
+    const jsonlFiles = await findFilesRecursively(
+      claudeProjectsDir,
+      (entryName) => entryName.endsWith('.jsonl') && !entryName.startsWith('agent-')
+    );
+
+    for (const filePath of jsonlFiles) {
+      try {
+        const result = await parseJsonlSessions(filePath);
+        const matchedSession = (result?.sessions || []).find((session) => session?.id === normalizedSessionId);
+        if (matchedSession) {
+          return {
+            ...matchedSession,
+            filePath,
+            projectName: path.basename(path.dirname(filePath)),
+            provider: 'claude'
+          };
+        }
+      } catch {}
+    }
+
+    return null;
+  } catch (error) {
+    if (error?.code !== 'ENOENT') {
+      console.error(`Error reading Claude session metadata for ${sessionId}:`, error);
+    }
+    return null;
+  }
+}
+
 async function parseJsonlSessions(filePath) {
   const sessions = new Map();
   const entries = [];
@@ -1107,14 +1431,27 @@ async function getSessionMessages(projectName, sessionId, limit = null, offset =
 // Rename a project's display name
 async function renameProject(projectName, newDisplayName) {
   const config = await loadProjectConfig();
+  const existingConfig = config[projectName] && typeof config[projectName] === 'object'
+    ? config[projectName]
+    : {};
+  const trimmedDisplayName = typeof newDisplayName === 'string'
+    ? newDisplayName.trim()
+    : '';
   
-  if (!newDisplayName || newDisplayName.trim() === '') {
-    // Remove custom name if empty, will fall back to auto-generated
-    delete config[projectName];
+  if (!trimmedDisplayName) {
+    // Remove only the custom display name while preserving other metadata such as
+    // manuallyAdded/originalPath so externally added projects do not disappear.
+    const { displayName: _removedDisplayName, ...remainingConfig } = existingConfig;
+
+    if (Object.keys(remainingConfig).length === 0) {
+      delete config[projectName];
+    } else {
+      config[projectName] = remainingConfig;
+    }
   } else {
-    // Set custom display name
     config[projectName] = {
-      displayName: newDisplayName.trim()
+      ...existingConfig,
+      displayName: trimmedDisplayName
     };
   }
   
@@ -1252,7 +1589,41 @@ async function addProjectManually(projectPath, displayName = null) {
   const projectDir = path.join(os.homedir(), '.claude', 'projects', projectName);
 
   if (config[projectName]) {
-    throw new Error(`Project already configured for path: ${absolutePath}`);
+    const existingConfig = config[projectName] && typeof config[projectName] === 'object'
+      ? config[projectName]
+      : {};
+    const hasManualMetadata = Boolean(existingConfig.manuallyAdded || existingConfig.originalPath || existingConfig.path);
+
+    if (hasManualMetadata) {
+      throw new Error(`Project already configured for path: ${absolutePath}`);
+    }
+
+    // Recover historical broken entries that lost their manual-project metadata
+    // during a rename, which otherwise makes the project invisible in the sidebar
+    // while still blocking re-adding the same workspace.
+    config[projectName] = {
+      ...existingConfig,
+      manuallyAdded: true,
+      originalPath: absolutePath
+    };
+
+    if (displayName) {
+      config[projectName].displayName = displayName;
+    }
+
+    await saveProjectConfig(config);
+
+    return {
+      name: projectName,
+      path: absolutePath,
+      fullPath: absolutePath,
+      displayName: config[projectName].displayName || await generateDisplayName(projectName, absolutePath),
+      isManuallyAdded: true,
+      sessions: [],
+      codexSessions: [],
+      opencodeSessions: [],
+      geminiSessions: []
+    };
   }
 
   // Allow adding projects even if the directory exists - this enables tracking
@@ -1289,7 +1660,7 @@ async function getCodexSessions(projectPath, options = {}) {
     const sessions = [];
     const normalizedProjectPath = normalizeComparableProjectPath(projectPath);
     const jsonlFiles = await findFilesRecursively(
-      path.join(os.homedir(), '.codex', 'sessions'),
+      getCodexSessionsDir(),
       (entryName) => entryName.endsWith('.jsonl')
     );
 
@@ -1299,6 +1670,7 @@ async function getCodexSessions(projectPath, options = {}) {
         const sessionData = await parseCodexSessionFile(filePath);
 
         if (sessionData && normalizeComparableProjectPath(sessionData.cwd) === normalizedProjectPath) {
+          cacheCodexSessionFilePath(sessionData.id, filePath);
           sessions.push({
             id: sessionData.id,
             summary: sessionData.summary || 'Codex Session',
@@ -1327,15 +1699,17 @@ async function getCodexSessions(projectPath, options = {}) {
   }
 }
 
-const OPENCODE_SESSION_DIR_CANDIDATES = [
-  path.join(os.homedir(), '.opencode', 'sessions'),
-  path.join(os.homedir(), '.config', 'opencode', 'sessions')
-];
+function getOpencodeSessionDirCandidates() {
+  return [
+    path.join(os.homedir(), '.opencode', 'sessions'),
+    path.join(os.homedir(), '.config', 'opencode', 'sessions')
+  ];
+}
 
 async function findOpencodeSessionFiles() {
   const files = [];
 
-  for (const baseDir of OPENCODE_SESSION_DIR_CANDIDATES) {
+  for (const baseDir of getOpencodeSessionDirCandidates()) {
     const discovered = await findFilesRecursively(
       baseDir,
       (entryName, _fullPath, entry) => entry.isFile() && entryName.endsWith('.jsonl')
@@ -1600,6 +1974,34 @@ async function findOpencodeSessionFileById(sessionId) {
   return null;
 }
 
+async function getOpencodeSessionMetadata(sessionId) {
+  try {
+    const normalizedSessionId = String(sessionId || '').trim();
+    if (!normalizedSessionId) {
+      return null;
+    }
+
+    const sessionFilePath = await findOpencodeSessionFileById(normalizedSessionId);
+    if (!sessionFilePath) {
+      return null;
+    }
+
+    const sessionData = await parseOpencodeSessionFile(sessionFilePath);
+    if (!sessionData) {
+      return null;
+    }
+
+    return {
+      ...sessionData,
+      filePath: sessionFilePath,
+      provider: 'opencode'
+    };
+  } catch (error) {
+    console.error(`Error reading OpenCode session metadata for ${sessionId}:`, error);
+    return null;
+  }
+}
+
 async function getOpencodeSessionMessages(sessionId, limit = null, offset = 0) {
   try {
     const sessionFilePath = await findOpencodeSessionFileById(sessionId);
@@ -1730,43 +2132,42 @@ async function deleteOpencodeSession(sessionId) {
   }
 }
 
-async function getGeminiSessions(projectPath, options = {}) {
-  const { limit = 5 } = options;
-  try {
-    const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
-    try {
-      await fs.access(geminiTmpDir);
-    } catch {
-      return [];
-    }
+async function findGeminiSessionFiles() {
+  return findFilesRecursively(
+    path.join(os.homedir(), '.gemini', 'tmp'),
+    (entryName, fullPath) => (
+      entryName.endsWith('.json') &&
+      /[\\/]chats[\\/]/.test(fullPath)
+    )
+  );
+}
 
-    const projectHash = crypto.createHash('sha256').update(projectPath).digest('hex');
-    const chatsDir = path.join(geminiTmpDir, projectHash, 'chats');
+function inferGeminiProjectHash(filePath, parsedSession = null) {
+  const explicitHash = typeof parsedSession?.projectHash === 'string'
+    ? parsedSession.projectHash.trim()
+    : '';
+  if (explicitHash) {
+    return explicitHash.toLowerCase();
+  }
 
-    try {
-      await fs.access(chatsDir);
-    } catch {
-      return [];
-    }
+  const parentDir = path.basename(path.dirname(path.dirname(filePath)));
+  if (/^[a-f0-9]{64}$/i.test(parentDir)) {
+    return parentDir.toLowerCase();
+  }
 
-    const entries = await fs.readdir(chatsDir, { withFileTypes: true });
-    const sessionFiles = entries
-      .filter(e => e.isFile() && e.name.endsWith('.json'))
-      .map(e => path.join(chatsDir, e.name));
+  return '';
+}
 
-    const sessions = [];
-    for (const filePath of sessionFiles) {
-      try {
-        const sessionData = await parseGeminiSessionFile(filePath);
-        if (!sessionData?.id) continue;
-        sessions.push(sessionData);
-      } catch (error) {
-        console.warn(`Could not parse Gemini session file ${filePath}:`, error.message);
-      }
-    }
+async function getGeminiSessions(projectPath, options = {}) {
+  const { limit = 5 } = options;
+  const normalizedProjectPath = normalizeComparableProjectPath(projectPath);
+  if (!normalizedProjectPath) {
+    return [];
+  }
 
-    sessions.sort((a, b) => new Date(b.lastActivity) - new Date(a.lastActivity));
-    return limit > 0 ? sessions.slice(0, limit) : sessions;
+  try {
+    const lookup = await buildGeminiSessionsLookup([normalizedProjectPath], { limit });
+    return lookup.get(normalizedProjectPath) || [];
   } catch (error) {
     console.error('Error fetching Gemini sessions:', error);
     return [];
@@ -1805,11 +2206,36 @@ async function parseGeminiSessionFile(filePath) {
     lastActivity,
     createdAt: data?.startTime || lastActivity,
     model: messages.filter(m => m?.model).slice(-1)[0]?.model || null,
+    projectHash: inferGeminiProjectHash(filePath, data),
     provider: 'gemini',
     filePath
   };
 }
 
+async function getGeminiSessionMetadata(sessionId) {
+  try {
+    const normalizedSessionId = String(sessionId || '').trim();
+    if (!normalizedSessionId) {
+      return null;
+    }
+
+    const sessionFiles = await findGeminiSessionFiles();
+    for (const filePath of sessionFiles) {
+      try {
+        const sessionData = await parseGeminiSessionFile(filePath);
+        if (sessionData?.id === normalizedSessionId) {
+          return sessionData;
+        }
+      } catch {}
+    }
+
+    return null;
+  } catch (error) {
+    console.error(`Error reading Gemini session metadata for ${sessionId}:`, error);
+    return null;
+  }
+}
+
 async function buildCodexSessionsLookup(projectPaths, options = {}) {
   const { limit = 5 } = options;
   const normalizedProjectPaths = Array.from(new Set(
@@ -1823,7 +2249,7 @@ async function buildCodexSessionsLookup(projectPaths, options = {}) {
   const cacheKey = JSON.stringify({ projectPaths: normalizedProjectPaths, limit });
   return getCachedProviderSessionLookup('codex', cacheKey, async () => {
     const jsonlFiles = await findFilesRecursively(
-      path.join(os.homedir(), '.codex', 'sessions'),
+      getCodexSessionsDir(),
       (entryName) => entryName.endsWith('.jsonl')
     );
 
@@ -1832,6 +2258,7 @@ async function buildCodexSessionsLookup(projectPaths, options = {}) {
       try {
         const sessionData = await parseCodexSessionFile(filePath);
         if (sessionData?.id) {
+          cacheCodexSessionFilePath(sessionData.id, filePath);
           sessions.push({
             id: sessionData.id,
             summary: sessionData.summary || 'Codex Session',
@@ -1884,73 +2311,58 @@ async function buildGeminiSessionsLookup(projectPaths, options = {}) {
     (projectPaths || []).map(normalizeComparableProjectPath).filter(Boolean)
   ));
 
+  if (normalizedProjectPaths.length === 0) {
+    return new Map();
+  }
+
   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');
+    const projectHashToPath = new Map(
+      normalizedProjectPaths.map((normalizedProjectPath) => ([
+        crypto.createHash('sha256').update(normalizedProjectPath).digest('hex'),
+        normalizedProjectPath
+      ]))
+    );
+    const sessionsByProjectPath = new Map(
+      normalizedProjectPaths.map((normalizedProjectPath) => [normalizedProjectPath, []])
+    );
+    const sessionFiles = await findGeminiSessionFiles();
 
+    for (const filePath of sessionFiles) {
       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 sessionData = await parseGeminiSessionFile(filePath);
+        if (!sessionData?.id) {
+          continue;
+        }
 
-        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);
-          }
+        const normalizedProjectPath = projectHashToPath.get(sessionData.projectHash || '');
+        if (!normalizedProjectPath) {
+          continue;
         }
 
-        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, []);
+        sessionsByProjectPath.get(normalizedProjectPath)?.push(sessionData);
+      } catch (error) {
+        console.warn(`Could not parse Gemini session file ${filePath}:`, error.message);
       }
     }
 
+    for (const [normalizedProjectPath, sessions] of sessionsByProjectPath.entries()) {
+      sessions.sort((a, b) => new Date(b.lastActivity || 0) - new Date(a.lastActivity || 0));
+      sessionsByProjectPath.set(
+        normalizedProjectPath,
+        limit > 0 ? sessions.slice(0, limit) : sessions
+      );
+    }
+
     return sessionsByProjectPath;
   });
 }
 
 async function getGeminiSessionMessages(sessionId, limit = null, offset = 0) {
   try {
-    const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
-    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;
-            continue;
-          }
-          if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
-          try {
-            const raw = await fs.readFile(fullPath, 'utf8');
-            const parsed = JSON.parse(raw);
-            if (parsed?.sessionId === sessionId) {
-              return fullPath;
-            }
-          } catch {}
-        }
-      } catch {}
-      return null;
-    };
+    const sessionMetadata = await getGeminiSessionMetadata(sessionId);
+    const sessionFilePath = sessionMetadata?.filePath || null;
 
-    const sessionFilePath = await findSessionFile(geminiTmpDir);
     if (!sessionFilePath) {
       return { messages: [], total: 0, hasMore: false };
     }
@@ -2100,6 +2512,7 @@ async function parseCodexSessionFile(filePath) {
     }
 
     if (sessionMeta) {
+      cacheCodexSessionFilePath(sessionMeta.id, filePath);
       return {
         ...sessionMeta,
         model: lastResolvedModel || sessionMeta.model || null,
@@ -2122,35 +2535,18 @@ async function parseCodexSessionFile(filePath) {
 // 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);
+    const sessionFilePath = await resolveCodexSessionFile(sessionId);
 
     if (!sessionFilePath) {
       console.warn(`Codex session file not found for session ${sessionId}`);
       return { messages: [], total: 0, hasMore: false };
     }
 
+    const normalizedLimit = limit === null ? null : Math.max(0, Number(limit) || 0);
+    const normalizedOffset = Math.max(0, Number(offset) || 0);
+    const maxBufferedMessages = normalizedLimit === null ? null : normalizedLimit + normalizedOffset;
     const messages = [];
+    let total = 0;
     let tokenUsage = null;
     const fileStream = fsSync.createReadStream(sessionFilePath);
     const rl = readline.createInterface({
@@ -2175,6 +2571,11 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
         .join('\n');
     };
 
+    const appendMessage = (message) => {
+      total += 1;
+      appendBoundedMessage(messages, message, maxBufferedMessages);
+    };
+
     for await (const line of rl) {
       if (line.trim()) {
         try {
@@ -2200,7 +2601,7 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
 
             // Only add if there's actual content
             if (visibleTextContent?.trim()) {
-              messages.push({
+              appendMessage({
                 type: role === 'user' ? 'user' : 'assistant',
                 timestamp: entry.timestamp,
                 message: {
@@ -2217,7 +2618,7 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
               .filter(Boolean)
               .join('\n');
             if (summaryText?.trim()) {
-              messages.push({
+              appendMessage({
                 type: 'thinking',
                 timestamp: entry.timestamp,
                 message: {
@@ -2243,7 +2644,7 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
               }
             }
 
-            messages.push({
+            appendMessage({
               type: 'tool_use',
               timestamp: entry.timestamp,
               toolName: toolName,
@@ -2253,7 +2654,7 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
           }
 
           if (entry.type === 'response_item' && entry.payload?.type === 'function_call_output') {
-            messages.push({
+            appendMessage({
               type: 'tool_result',
               timestamp: entry.timestamp,
               toolCallId: entry.payload.call_id,
@@ -2283,7 +2684,7 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
                 }
               }
 
-              messages.push({
+              appendMessage({
                 type: 'tool_use',
                 timestamp: entry.timestamp,
                 toolName: 'Edit',
@@ -2295,7 +2696,7 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
                 toolCallId: entry.payload.call_id
               });
             } else {
-              messages.push({
+              appendMessage({
                 type: 'tool_use',
                 timestamp: entry.timestamp,
                 toolName: toolName,
@@ -2306,7 +2707,7 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
           }
 
           if (entry.type === 'response_item' && entry.payload?.type === 'custom_tool_call_output') {
-            messages.push({
+            appendMessage({
               type: 'tool_result',
               timestamp: entry.timestamp,
               toolCallId: entry.payload.call_id,
@@ -2320,29 +2721,31 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
       }
     }
 
-    // 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;
+    if (normalizedLimit !== null) {
+      const endIndex = Math.max(0, messages.length - normalizedOffset);
+      const startIndex = Math.max(0, endIndex - normalizedLimit);
       const paginatedMessages = messages.slice(startIndex, endIndex);
-      const hasMore = startIndex > 0;
+      const hasMore = total > normalizedOffset + paginatedMessages.length;
 
       return {
         messages: paginatedMessages,
         total,
         hasMore,
-        offset,
-        limit,
+        offset: normalizedOffset,
+        limit: normalizedLimit,
         tokenUsage
       };
     }
 
-    return { messages, tokenUsage };
+    return {
+      messages,
+      total,
+      hasMore: false,
+      offset: normalizedOffset,
+      limit: normalizedLimit,
+      tokenUsage
+    };
 
   } catch (error) {
     console.error(`Error reading Codex session messages for ${sessionId}:`, error);
@@ -2350,37 +2753,45 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
   }
 }
 
-async function deleteCodexSession(sessionId) {
-  try {
-    const codexSessionsDir = path.join(os.homedir(), '.codex', 'sessions');
+async function getCodexSessionMetadata(sessionId) {
+  if (!sessionId) {
+    return null;
+  }
 
-    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 sessionFilePath = await resolveCodexSessionFile(sessionId);
+  if (!sessionFilePath) {
+    return null;
+  }
 
-    const jsonlFiles = await findJsonlFiles(codexSessionsDir);
+  const sessionData = await parseCodexSessionFile(sessionFilePath);
+  if (!sessionData) {
+    return null;
+  }
 
-    for (const filePath of jsonlFiles) {
-      const sessionData = await parseCodexSessionFile(filePath);
-      if (sessionData && sessionData.id === sessionId) {
-        await fs.unlink(filePath);
-        return true;
-      }
+  const metadata = {
+    ...sessionData,
+    filePath: sessionFilePath,
+    provider: 'codex'
+  };
+
+  if (metadata.git === undefined) {
+    delete metadata.git;
+  }
+
+  return metadata;
+}
+
+async function deleteCodexSession(sessionId) {
+  try {
+    const sessionFilePath = await resolveCodexSessionFile(sessionId);
+
+    if (!sessionFilePath) {
+      throw new Error(`Codex session file not found for session ${sessionId}`);
     }
 
-    throw new Error(`Codex session file not found for session ${sessionId}`);
+    await fs.unlink(sessionFilePath);
+    codexSessionFileCache.delete(sessionId);
+    return true;
   } catch (error) {
     console.error(`Error deleting Codex session ${sessionId}:`, error);
     throw error;
@@ -2389,7 +2800,10 @@ async function deleteCodexSession(sessionId) {
 
 export {
   getProjects,
+  getProjectsList,
+  getProjectDetails,
   getSessions,
+  getClaudeSessionMetadata,
   getSessionMessages,
   parseJsonlSessions,
   renameProject,
@@ -2402,11 +2816,15 @@ export {
   extractProjectDirectory,
   clearProjectDirectoryCache,
   clearProviderSessionLookupCaches,
+  findCodexSessionFilePathBySessionIdHint,
   getCodexSessions,
   getCodexSessionMessages,
+  getCodexSessionMetadata,
   getOpencodeSessions,
+  getOpencodeSessionMetadata,
   getOpencodeSessionMessages,
   getGeminiSessions,
+  getGeminiSessionMetadata,
   getGeminiSessionMessages,
   deleteCodexSession,
   deleteOpencodeSession