@axhub/genie 0.2.8 → 0.2.10

package/server/projects.js

@@ -51,13 +51,68 @@ 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';
+import { listAcpSessions } from './acp-runtime/session-store.js';
+import { mergeSessionLists } from './session-core/sessionListMerge.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 trimText(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+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 +152,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 '';
   }
 
@@ -120,6 +180,40 @@ function extractVisibleUserMessage(value) {
   return text;
 }
 
+function extractCodexMessageText(content) {
+  if (!Array.isArray(content)) {
+    return typeof content === 'string' ? content : '';
+  }
+
+  return content
+    .map((item) => {
+      if (item?.type === 'input_text' || item?.type === 'output_text' || item?.type === 'text') {
+        return item.text;
+      }
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+function shouldIncludeCodexTranscriptMessage(entry) {
+  const payload = entry?.payload;
+  if (entry?.type !== 'response_item' || payload?.type !== 'message') {
+    return false;
+  }
+
+  const role = String(payload.role || '').trim().toLowerCase();
+  if (role !== 'user' && role !== 'assistant') {
+    return false;
+  }
+
+  if (role === 'assistant' && String(payload.phase || '').trim().toLowerCase() === 'commentary') {
+    return false;
+  }
+
+  return true;
+}
+
 function isInjectedContextContent(value) {
   const text = String(value || '').trim();
   if (!text) {
@@ -128,145 +222,28 @@ 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>');
-}
-
-// 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}`
-        };
-    }
+  return /^<dynamic_context(?:\s|>)/i.test(text)
+    || text.includes('<environment_context>')
+    || /<subagent_notification(?:\s|>)/i.test(text);
 }
 
 // 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 +320,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 +406,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,190 +463,182 @@ 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
-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
+function decodeProjectNameFallback(projectName) {
+  return String(projectName || '').replace(/-/g, '/');
+}
+
+async function readPackageDisplayName(projectPath) {
   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;
+    const raw = await fs.readFile(path.join(projectPath, 'package.json'), 'utf8');
+    const parsed = JSON.parse(raw);
+    return trimText(parsed?.name) || null;
+  } catch {
+    return null;
+  }
+}
+
+function lastPathSegment(projectPath) {
+  const normalized = path.normalize(projectPath);
+  const segment = path.basename(normalized);
+  return segment || normalized;
+}
+
+async function generateDisplayName(projectName, actualProjectDir = null) {
+  const preferredPath = actualProjectDir || decodeProjectNameFallback(projectName);
+  return (await readPackageDisplayName(preferredPath)) || lastPathSegment(preferredPath);
+}
+
+async function summarizeProjectDirectoryHistory(projectDirectoryPath) {
+  const cwdCounts = new Map();
+  let latestSeen = { cwd: null, timestamp: 0 };
+  const files = (await fs.readdir(projectDirectoryPath))
+    .filter((fileName) => fileName.endsWith('.jsonl') && !fileName.startsWith('agent-'));
+
+  for (const fileName of files) {
+    const stream = fsSync.createReadStream(path.join(projectDirectoryPath, fileName));
+    const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+    for await (const line of lines) {
+      if (!line.trim()) {
+        continue;
+      }
+
+      try {
+        const entry = JSON.parse(line);
+        const cwd = trimText(entry?.cwd);
+        if (!cwd) {
+          continue;
+        }
+
+        cwdCounts.set(cwd, (cwdCounts.get(cwd) || 0) + 1);
+        const timestamp = Date.parse(entry?.timestamp || '') || 0;
+        if (timestamp >= latestSeen.timestamp) {
+          latestSeen = { cwd, timestamp };
+        }
+      } catch {
+      }
     }
-  } 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 { cwdCounts, latestSeen };
+}
+
+function chooseProjectDirectory(projectName, cwdCounts, latestSeen) {
+  if (cwdCounts.size === 0) {
+    return decodeProjectNameFallback(projectName);
   }
-  
-  return projectPath;
+
+  if (cwdCounts.size === 1) {
+    return Array.from(cwdCounts.keys())[0];
+  }
+
+  let topPath = null;
+  let topCount = -1;
+  for (const [cwd, count] of cwdCounts.entries()) {
+    if (count > topCount) {
+      topPath = cwd;
+      topCount = count;
+    }
+  }
+
+  if (latestSeen.cwd && (cwdCounts.get(latestSeen.cwd) || 0) >= Math.max(1, Math.floor(topCount / 4))) {
+    return latestSeen.cwd;
+  }
+
+  return topPath || decodeProjectNameFallback(projectName);
 }
 
-// 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 configuredPath = trimText(config?.[projectName]?.originalPath);
+  if (configuredPath) {
+    projectDirectoryCache.set(projectName, configuredPath);
+    return configuredPath;
   }
 
-  const projectDir = path.join(os.homedir(), '.claude', 'projects', projectName);
-  const cwdCounts = new Map();
-  let latestTimestamp = 0;
-  let latestCwd = null;
-  let extractedPath;
-  
+  const projectDirectoryPath = path.join(os.homedir(), '.claude', 'projects', projectName);
+
   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;
-    
+    const { cwdCounts, latestSeen } = await summarizeProjectDirectoryHistory(projectDirectoryPath);
+    const resolvedPath = chooseProjectDirectory(projectName, cwdCounts, latestSeen);
+    projectDirectoryCache.set(projectName, resolvedPath);
+    return resolvedPath;
   } catch (error) {
-    // If the directory doesn't exist, just use the decoded project name
-    if (error.code === 'ENOENT') {
-      extractedPath = projectName.replace(/-/g, '/');
-    } else {
+    if (error.code !== 'ENOENT') {
       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;
+
+    const fallbackPath = decodeProjectNameFallback(projectName);
+    projectDirectoryCache.set(projectName, fallbackPath);
+    return fallbackPath;
   }
 }
 
-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 +646,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,367 +737,507 @@ async function getProjects(progressCallback = null) {
     }
   }
 
+  return {
+    projectDefinitions,
+    totalProjects
+  };
+}
+
+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;
+  }
+
+  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
+    }));
+
+    projectListCache.data = lightweightProjects;
+    projectListCache.expiresAt = Date.now() + PROJECT_LIST_CACHE_TTL_MS;
+
+    if (progressCallback) {
+      progressCallback({
+        phase: 'complete',
+        current: totalProjects,
+        total: totalProjects
+      });
+    }
+
+    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 {
+    let claudeAcpSessions = [];
+    let codexAcpSessions = [];
+    let opencodeAcpSessions = [];
+    let geminiAcpSessions = [];
+
+    if (providerLookups) {
+      claudeAcpSessions = providerLookups.claudeAcpSessionsByProjectPath?.get(normalizedProjectPath) || [];
+      codexAcpSessions = providerLookups.codexAcpSessionsByProjectPath?.get(normalizedProjectPath) || [];
+      opencodeAcpSessions = providerLookups.opencodeAcpSessionsByProjectPath?.get(normalizedProjectPath) || [];
+      geminiAcpSessions = providerLookups.geminiAcpSessionsByProjectPath?.get(normalizedProjectPath) || [];
+
+      project.codexSessions = mergeSessionLists(
+        providerLookups.codexSessionsByProjectPath?.get(normalizedProjectPath) || [],
+        codexAcpSessions,
+        { fallbackProvider: 'codex' }
+      );
+      project.opencodeSessions = mergeSessionLists(
+        providerLookups.opencodeSessionsByProjectPath?.get(normalizedProjectPath) || [],
+        opencodeAcpSessions,
+        { fallbackProvider: 'opencode' }
+      );
+      project.geminiSessions = mergeSessionLists(
+        providerLookups.geminiSessionsByProjectPath?.get(normalizedProjectPath) || [],
+        geminiAcpSessions,
+        { fallbackProvider: 'gemini' }
+      );
+    } else {
+      const [codexSessions, opencodeSessions, geminiSessions, acpSessions] = await Promise.all([
+        getCodexSessions(definition.fullPath, { limit: 5 }),
+        getOpencodeSessions(definition.fullPath, { limit: 5 }),
+        getGeminiSessions(definition.fullPath, { limit: 5 }),
+        listAcpSessions({ projectPath: definition.fullPath })
+      ]);
+      claudeAcpSessions = acpSessions.filter((session) => session.provider === 'claude');
+      codexAcpSessions = acpSessions.filter((session) => session.provider === 'codex');
+      opencodeAcpSessions = acpSessions.filter((session) => session.provider === 'opencode');
+      geminiAcpSessions = acpSessions.filter((session) => session.provider === 'gemini');
+      project.codexSessions = mergeSessionLists(codexSessions, codexAcpSessions, { fallbackProvider: 'codex' });
+      project.opencodeSessions = mergeSessionLists(opencodeSessions, opencodeAcpSessions, { fallbackProvider: 'opencode' });
+      project.geminiSessions = mergeSessionLists(geminiSessions, geminiAcpSessions, { fallbackProvider: 'gemini' });
+    }
+
+    if (!definition.isManuallyAdded) {
+      const sessionResult = await getSessions(definition.name, 5, 0);
+      project.sessions = mergeSessionLists(
+        (sessionResult.sessions || []).map((session) => ({
+          ...session,
+          provider: 'claude',
+          source: session?.source || 'legacy'
+        })),
+        claudeAcpSessions,
+        { fallbackProvider: 'claude' }
+      );
+      project.sessionMeta = {
+        hasMore: sessionResult.hasMore,
+        total: sessionResult.total
+      };
+    } else {
+      project.sessions = mergeSessionLists([], claudeAcpSessions, { fallbackProvider: 'claude' });
+    }
+  } catch (error) {
+    console.warn(`Could not load session details for project ${definition.name}:`, error.message);
+  }
+
+  return project;
+}
+
+async function getProjectDetails(projectName) {
+  const projectList = await getProjectsList();
+  const definition = projectList.find((project) => project.name === projectName);
+
+  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([
+  const [codexSessionsByProjectPath, geminiSessionsByProjectPath, opencodeSessionsByProjectPath, claudeAcpSessionsByProjectPath, codexAcpSessionsByProjectPath, geminiAcpSessionsByProjectPath, opencodeAcpSessionsByProjectPath] = await Promise.all([
     buildCodexSessionsLookup(uniqueProjectPaths, { limit: 5 }),
     buildGeminiSessionsLookup(uniqueProjectPaths, { limit: 5 }),
-    buildOpencodeSessionsLookup(uniqueProjectPaths, { limit: 5 })
+    buildOpencodeSessionsLookup(uniqueProjectPaths, { limit: 5 }),
+    buildAcpProviderSessionsLookup('claude', uniqueProjectPaths, { limit: 5 }),
+    buildAcpProviderSessionsLookup('codex', uniqueProjectPaths, { limit: 5 }),
+    buildAcpProviderSessionsLookup('gemini', uniqueProjectPaths, { limit: 5 }),
+    buildAcpProviderSessionsLookup('opencode', 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) || []
-    };
+    projects.push(await buildProjectFromDefinition(definition, {
+      claudeAcpSessionsByProjectPath,
+      codexSessionsByProjectPath,
+      codexAcpSessionsByProjectPath,
+      geminiSessionsByProjectPath,
+      geminiAcpSessionsByProjectPath,
+      opencodeSessionsByProjectPath,
+      opencodeAcpSessionsByProjectPath
+    }));
+  }
 
-    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);
-      }
-    }
+  // Emit completion after all projects (including manual) are processed
+  if (progressCallback) {
+    progressCallback({
+      phase: 'complete',
+      current: totalProjects,
+      total: totalProjects
+    });
+  }
+
+  return projects;
+}
+
+function createClaudeSessionRecord(sessionId) {
+  return {
+    id: sessionId,
+    summary: 'New Session',
+    messageCount: 0,
+    lastActivity: new Date(0),
+    cwd: '',
+    lastUserMessage: null,
+    lastAssistantMessage: null,
+    rootMessageId: null
+  };
+}
+
+function truncateSummary(text, maxLength = 50) {
+  const normalized = trimText(text);
+  if (!normalized) {
+    return 'New Session';
+  }
+
+  return normalized.length > maxLength ? `${normalized.slice(0, maxLength)}...` : normalized;
+}
+
+function extractClaudeTextContent(content) {
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  if (Array.isArray(content)) {
+    return content
+      .filter((part) => part?.type === 'text' && typeof part?.text === 'string')
+      .map((part) => part.text)
+      .join('\n')
+      .trim();
+  }
+
+  return '';
+}
+
+function isIgnoredClaudePrompt(text) {
+  return text.startsWith('<command-name>')
+    || text.startsWith('<command-message>')
+    || text.startsWith('<command-args>')
+    || text.startsWith('<local-command-stdout>')
+    || text.startsWith('<system-reminder>')
+    || text.startsWith('Caveat:')
+    || text.startsWith('This session is being continued from a previous')
+    || text.startsWith('Invalid API key')
+    || text.includes('{"subtasks":')
+    || text.includes('CRITICAL: You MUST respond with ONLY a JSON')
+    || text === 'Warmup';
+}
 
-    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
-      };
-    }
+function mergeClaudeSession(target, incoming) {
+  if (incoming.messageCount > target.messageCount) {
+    target.messageCount = incoming.messageCount;
+  }
 
-    projects.push(project);
+  if (incoming.summary !== 'New Session' && (target.summary === 'New Session' || incoming.lastActivity > target.lastActivity)) {
+    target.summary = incoming.summary;
   }
 
-  // Emit completion after all projects (including manual) are processed
-  if (progressCallback) {
-    progressCallback({
-      phase: 'complete',
-      current: totalProjects,
-      total: totalProjects
-    });
+  if (incoming.lastActivity > target.lastActivity) {
+    target.lastActivity = incoming.lastActivity;
+    target.lastUserMessage = incoming.lastUserMessage || target.lastUserMessage;
+    target.lastAssistantMessage = incoming.lastAssistantMessage || target.lastAssistantMessage;
   }
 
-  return projects;
+  if (!target.cwd && incoming.cwd) {
+    target.cwd = incoming.cwd;
+  }
+
+  if (!target.rootMessageId && incoming.rootMessageId) {
+    target.rootMessageId = incoming.rootMessageId;
+  }
 }
 
 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 };
+    const files = (await fs.readdir(projectDir))
+      .filter((fileName) => fileName.endsWith('.jsonl') && !fileName.startsWith('agent-'));
+
+    if (files.length === 0) {
+      return { sessions: [], hasMore: false, total: 0, offset, limit };
     }
-    
-    // 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);
+
+    const filesByRecency = await Promise.all(files.map(async (fileName) => {
+      const filePath = path.join(projectDir, fileName);
+      const stat = await fs.stat(filePath);
+      return { filePath, modifiedAt: stat.mtime.getTime() };
+    }));
+    filesByRecency.sort((left, right) => right.modifiedAt - left.modifiedAt);
+
+    const sessionsById = new Map();
+
+    for (const { filePath } of filesByRecency) {
+      const parsed = await parseJsonlSessions(filePath);
+      for (const session of parsed.sessions) {
+        const existing = sessionsById.get(session.id);
+        if (!existing) {
+          sessionsById.set(session.id, session);
+          continue;
         }
-      });
-      
-      allEntries.push(...result.entries);
-      
-      // Early exit optimization for large projects
-      if (allSessions.size >= (limit + offset) * 2 && allEntries.length >= Math.min(3, filesWithStats.length)) {
-        break;
+        mergeClaudeSession(existing, session);
       }
     }
-    
-    // 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;
-              }
-            }
-          }
-        }
-      }
-    });
+    const groupedSessions = new Map();
 
-    // 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));
-    });
+    for (const session of sessionsById.values()) {
+      const groupKey = session.rootMessageId || `session:${session.id}`;
+      const currentGroup = groupedSessions.get(groupKey) || [];
+      currentGroup.push(session);
+      groupedSessions.set(groupKey, currentGroup);
+    }
+
+    const visibleSessions = Array.from(groupedSessions.values()).map((group) => {
+      const ordered = [...group].sort((left, right) => right.lastActivity - left.lastActivity);
+      const primary = { ...ordered[0] };
 
-    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);
+      if (ordered.length > 1) {
+        primary.isGrouped = true;
+        primary.groupSize = ordered.length;
+        primary.groupSessions = ordered.map((session) => session.id);
       }
-      return session;
-    });
-    const visibleSessions = [...latestFromGroups, ...standaloneSessionsArray]
-      .filter(session => !session.summary.startsWith('{ "'))
-      .sort((a, b) => new Date(b.lastActivity) - new Date(a.lastActivity));
+
+      return primary;
+    }).sort((left, right) => right.lastActivity - left.lastActivity);
 
     const total = visibleSessions.length;
-    const paginatedSessions = visibleSessions.slice(offset, offset + limit);
-    const hasMore = offset + limit < total;
-    
+    const sessions = visibleSessions.slice(offset, offset + limit);
+
     return {
-      sessions: paginatedSessions,
-      hasMore,
+      sessions,
+      hasMore: offset + limit < total,
       total,
       offset,
       limit
     };
   } catch (error) {
     console.error(`Error reading sessions for project ${projectName}:`, error);
-    return { sessions: [], hasMore: false, total: 0 };
+    return { sessions: [], hasMore: false, total: 0, offset, limit };
+  }
+}
+
+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 = [];
-  const pendingSummaries = new Map(); // leafUuid -> summary for entries without sessionId
+  const pendingSummaries = new Map();
 
   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);
+    const stream = fsSync.createReadStream(filePath);
+    const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });
 
-          // 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);
+    for await (const line of lines) {
+      if (!line.trim()) {
+        continue;
+      }
 
-            // 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);
-            }
+      try {
+        const entry = JSON.parse(line);
+        entries.push(entry);
 
-            // Update summary from summary entries with sessionId
-            if (entry.type === 'summary' && entry.summary) {
-              session.summary = entry.summary;
-            }
+        if (entry.type === 'summary' && trimText(entry.summary) && !entry.sessionId && trimText(entry.leafUuid)) {
+          pendingSummaries.set(entry.leafUuid, trimText(entry.summary));
+        }
 
-            // Track last user and assistant messages (skip system messages)
-            if (entry.message?.role === 'user' && entry.message?.content) {
-              const content = entry.message.content;
+        const sessionId = trimText(entry.sessionId);
+        if (!sessionId) {
+          continue;
+        }
 
-              // 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 session = sessions.get(sessionId) || createClaudeSessionRecord(sessionId);
+        sessions.set(sessionId, session);
 
-              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;
-                }
+        if (!session.cwd && trimText(entry.cwd)) {
+          session.cwd = trimText(entry.cwd);
+        }
 
-                // 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 (trimText(entry.timestamp)) {
+          session.lastActivity = new Date(entry.timestamp);
+        }
 
-                if (assistantText && !isSystemAssistantMessage) {
-                  session.lastAssistantMessage = assistantText;
-                }
-              }
-            }
+        if (entry.type === 'summary' && trimText(entry.summary)) {
+          session.summary = trimText(entry.summary);
+        } else if (session.summary === 'New Session' && trimText(entry.parentUuid) && pendingSummaries.has(entry.parentUuid)) {
+          session.summary = pendingSummaries.get(entry.parentUuid);
+        }
 
-            session.messageCount++;
+        if (!session.rootMessageId && entry.type === 'user' && entry.parentUuid === null && trimText(entry.uuid)) {
+          session.rootMessageId = trimText(entry.uuid);
+        }
 
-            if (entry.timestamp) {
-              session.lastActivity = new Date(entry.timestamp);
-            }
+        if (entry.message?.role === 'user') {
+          const text = extractClaudeTextContent(entry.message.content);
+          if (text && !isIgnoredClaudePrompt(text)) {
+            session.lastUserMessage = text;
+          }
+        } else if (entry.message?.role === 'assistant' && entry.isApiErrorMessage !== true) {
+          const text = extractClaudeTextContent(entry.message.content);
+          if (text && !isIgnoredClaudePrompt(text)) {
+            session.lastAssistantMessage = text;
           }
-        } 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;
-        }
+        session.messageCount += 1;
+      } catch {
       }
     }
 
-    // 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;
-    });
+    const normalizedSessions = Array.from(sessions.values())
+      .map((session) => {
+        if (session.summary === 'New Session') {
+          session.summary = truncateSummary(session.lastUserMessage || session.lastAssistantMessage || 'New Session');
+        } else {
+          session.summary = truncateSummary(session.summary, 80);
+        }
 
+        return session;
+      })
+      .filter((session) => !session.summary.startsWith('{ "'));
 
     return {
-      sessions: filteredSessions,
-      entries: entries
+      sessions: normalizedSessions,
+      entries
     };
-
   } catch (error) {
     console.error('Error reading JSONL file:', error);
     return { sessions: [], entries: [] };
   }
 }
 
+async function resolveClaudeProjectDir(projectName, sessionId = null) {
+  const defaultProjectDir = path.join(os.homedir(), '.claude', 'projects', projectName);
+
+  try {
+    await fs.access(defaultProjectDir);
+    return defaultProjectDir;
+  } catch (error) {
+    if (error?.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  if (!sessionId) {
+    return defaultProjectDir;
+  }
+
+  const sessionMetadata = await getClaudeSessionMetadata(sessionId);
+  if (sessionMetadata?.filePath) {
+    return path.dirname(sessionMetadata.filePath);
+  }
+
+  return defaultProjectDir;
+}
+
 // 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);
+  const projectDir = await resolveClaudeProjectDir(projectName, sessionId);
 
   try {
     const files = await fs.readdir(projectDir);
@@ -1336,7 +1538,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')
     );
 
@@ -1346,6 +1548,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',
@@ -1374,15 +1577,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')
@@ -1647,6 +1852,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);
@@ -1857,6 +2090,30 @@ async function parseGeminiSessionFile(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(
@@ -1870,7 +2127,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')
     );
 
@@ -1879,6 +2136,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',
@@ -1899,6 +2157,24 @@ async function buildCodexSessionsLookup(projectPaths, options = {}) {
   });
 }
 
+async function buildAcpProviderSessionsLookup(provider, 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 sessions = await listAcpSessions({ provider });
+  return groupSessionsByNormalizedProjectPath(
+    normalizedProjectPaths,
+    sessions.map((session) => ({ ...session, provider, source: 'acp' })),
+    limit
+  );
+}
+
 async function buildOpencodeSessionsLookup(projectPaths, options = {}) {
   const { limit = 5 } = options;
   const normalizedProjectPaths = Array.from(new Set(
@@ -1980,19 +2256,8 @@ async function buildGeminiSessionsLookup(projectPaths, options = {}) {
 
 async function getGeminiSessionMessages(sessionId, limit = null, offset = 0) {
   try {
-    const sessionFiles = await findGeminiSessionFiles();
-    let sessionFilePath = null;
-
-    for (const filePath of sessionFiles) {
-      try {
-        const raw = await fs.readFile(filePath, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (parsed?.sessionId === sessionId) {
-          sessionFilePath = filePath;
-          break;
-        }
-      } catch {}
-    }
+    const sessionMetadata = await getGeminiSessionMetadata(sessionId);
+    const sessionFilePath = sessionMetadata?.filePath || null;
 
     if (!sessionFilePath) {
       return { messages: [], total: 0, hasMore: false };
@@ -2132,6 +2397,15 @@ async function parseCodexSessionFile(filePath) {
             }
           }
 
+          if (shouldIncludeCodexTranscriptMessage(entry) && String(entry.payload.role).trim().toLowerCase() === 'user') {
+            const visibleUserMessage = extractVisibleUserMessage(extractCodexMessageText(entry.payload.content));
+            if (!visibleUserMessage) {
+              continue;
+            }
+            messageCount++;
+            lastUserMessage = visibleUserMessage;
+          }
+
           if (entry.type === 'response_item' && entry.payload?.type === 'message' && entry.payload.role === 'assistant') {
             messageCount++;
           }
@@ -2143,6 +2417,7 @@ async function parseCodexSessionFile(filePath) {
     }
 
     if (sessionMeta) {
+      cacheCodexSessionFilePath(sessionMeta.id, filePath);
       return {
         ...sessionMeta,
         model: lastResolvedModel || sessionMeta.model || null,
@@ -2165,35 +2440,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({
@@ -2201,21 +2459,9 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
       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');
+    const appendMessage = (message) => {
+      total += 1;
+      appendBoundedMessage(messages, message, maxBufferedMessages);
     };
 
     for await (const line of rl) {
@@ -2229,10 +2475,10 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
           }
 
           // Extract messages from response_item
-          if (entry.type === 'response_item' && entry.payload?.type === 'message') {
+          if (shouldIncludeCodexTranscriptMessage(entry)) {
             const content = entry.payload.content;
             const role = entry.payload.role || 'assistant';
-            const textContent = extractText(content);
+            const textContent = extractCodexMessageText(content);
             const visibleTextContent = role === 'user'
               ? extractVisibleUserMessage(textContent)
               : textContent;
@@ -2243,7 +2489,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: {
@@ -2260,7 +2506,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: {
@@ -2286,7 +2532,7 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
               }
             }
 
-            messages.push({
+            appendMessage({
               type: 'tool_use',
               timestamp: entry.timestamp,
               toolName: toolName,
@@ -2296,7 +2542,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,
@@ -2326,7 +2572,7 @@ async function getCodexSessionMessages(sessionId, limit = null, offset = 0) {
                 }
               }
 
-              messages.push({
+              appendMessage({
                 type: 'tool_use',
                 timestamp: entry.timestamp,
                 toolName: 'Edit',
@@ -2338,7 +2584,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,
@@ -2349,7 +2595,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,
@@ -2363,29 +2609,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);
@@ -2393,37 +2641,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 sessionData = await parseCodexSessionFile(sessionFilePath);
+  if (!sessionData) {
+    return null;
+  }
 
-    const jsonlFiles = await findJsonlFiles(codexSessionsDir);
+  const metadata = {
+    ...sessionData,
+    filePath: sessionFilePath,
+    provider: 'codex'
+  };
 
-    for (const filePath of jsonlFiles) {
-      const sessionData = await parseCodexSessionFile(filePath);
-      if (sessionData && sessionData.id === sessionId) {
-        await fs.unlink(filePath);
-        return true;
-      }
+  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;
@@ -2432,7 +2688,10 @@ async function deleteCodexSession(sessionId) {
 
 export {
   getProjects,
+  getProjectsList,
+  getProjectDetails,
   getSessions,
+  getClaudeSessionMetadata,
   getSessionMessages,
   parseJsonlSessions,
   renameProject,
@@ -2445,11 +2704,15 @@ export {
   extractProjectDirectory,
   clearProjectDirectoryCache,
   clearProviderSessionLookupCaches,
+  findCodexSessionFilePathBySessionIdHint,
   getCodexSessions,
   getCodexSessionMessages,
+  getCodexSessionMetadata,
   getOpencodeSessions,
+  getOpencodeSessionMetadata,
   getOpencodeSessionMessages,
   getGeminiSessions,
+  getGeminiSessionMetadata,
   getGeminiSessionMessages,
   deleteCodexSession,
   deleteOpencodeSession