@axhub/genie 0.2.9 → 0.2.10

package/server/projects.js

@@ -54,6 +54,8 @@ 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);
@@ -64,6 +66,10 @@ const KNOWN_CODEX_MODELS = new Set(
 
 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');
 }
@@ -174,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) {
@@ -194,134 +234,6 @@ function isInjectedContextContent(value) {
     || /<subagent_notification(?:\s|>)/i.test(text);
 }
 
-// Import TaskMaster detection functions
-async function detectTaskMasterFolder(projectPath) {
-    try {
-        const taskMasterPath = path.join(projectPath, '.taskmaster');
-        
-        // Check if .taskmaster directory exists
-        try {
-            const stats = await fs.stat(taskMasterPath);
-            if (!stats.isDirectory()) {
-                return {
-                    hasTaskmaster: false,
-                    reason: '.taskmaster exists but is not a directory'
-                };
-            }
-        } catch (error) {
-            if (error.code === 'ENOENT') {
-                return {
-                    hasTaskmaster: false,
-                    reason: '.taskmaster directory not found'
-                };
-            }
-            throw error;
-        }
-
-        // Check for key TaskMaster files
-        const keyFiles = [
-            'tasks/tasks.json',
-            'config.json'
-        ];
-        
-        const fileStatus = {};
-        let hasEssentialFiles = true;
-
-        for (const file of keyFiles) {
-            const filePath = path.join(taskMasterPath, file);
-            try {
-                await fs.access(filePath);
-                fileStatus[file] = true;
-            } catch (error) {
-                fileStatus[file] = false;
-                if (file === 'tasks/tasks.json') {
-                    hasEssentialFiles = false;
-                }
-            }
-        }
-
-        // Parse tasks.json if it exists for metadata
-        let taskMetadata = null;
-        if (fileStatus['tasks/tasks.json']) {
-            try {
-                const tasksPath = path.join(taskMasterPath, 'tasks/tasks.json');
-                const tasksContent = await fs.readFile(tasksPath, 'utf8');
-                const tasksData = JSON.parse(tasksContent);
-                
-                // Handle both tagged and legacy formats
-                let tasks = [];
-                if (tasksData.tasks) {
-                    // Legacy format
-                    tasks = tasksData.tasks;
-                } else {
-                    // Tagged format - get tasks from all tags
-                    Object.values(tasksData).forEach(tagData => {
-                        if (tagData.tasks) {
-                            tasks = tasks.concat(tagData.tasks);
-                        }
-                    });
-                }
-
-                // Calculate task statistics
-                const stats = tasks.reduce((acc, task) => {
-                    acc.total++;
-                    acc[task.status] = (acc[task.status] || 0) + 1;
-                    
-                    // Count subtasks
-                    if (task.subtasks) {
-                        task.subtasks.forEach(subtask => {
-                            acc.subtotalTasks++;
-                            acc.subtasks = acc.subtasks || {};
-                            acc.subtasks[subtask.status] = (acc.subtasks[subtask.status] || 0) + 1;
-                        });
-                    }
-                    
-                    return acc;
-                }, { 
-                    total: 0, 
-                    subtotalTasks: 0,
-                    pending: 0, 
-                    'in-progress': 0, 
-                    done: 0, 
-                    review: 0,
-                    deferred: 0,
-                    cancelled: 0,
-                    subtasks: {}
-                });
-
-                taskMetadata = {
-                    taskCount: stats.total,
-                    subtaskCount: stats.subtotalTasks,
-                    completed: stats.done || 0,
-                    pending: stats.pending || 0,
-                    inProgress: stats['in-progress'] || 0,
-                    review: stats.review || 0,
-                    completionPercentage: stats.total > 0 ? Math.round((stats.done / stats.total) * 100) : 0,
-                    lastModified: (await fs.stat(tasksPath)).mtime.toISOString()
-                };
-            } catch (parseError) {
-                console.warn('Failed to parse tasks.json:', parseError.message);
-                taskMetadata = { error: 'Failed to parse tasks.json' };
-            }
-        }
-
-        return {
-            hasTaskmaster: true,
-            hasEssentialFiles,
-            files: fileStatus,
-            metadata: taskMetadata,
-            path: taskMasterPath
-        };
-
-    } catch (error) {
-        console.error('Error detecting TaskMaster folder:', error);
-        return {
-            hasTaskmaster: false,
-            reason: `Error checking directory: ${error.message}`
-        };
-    }
-}
-
 // Cache for extracted project directories
 const projectDirectoryCache = new Map();
 const PROJECT_LIST_CACHE_TTL_MS = 15000;
@@ -601,151 +513,118 @@ async function saveProjectConfig(config) {
   }
 }
 
-// Generate better display name from path
-async function generateDisplayName(projectName, actualProjectDir = null) {
-  // Use actual project directory if provided, otherwise decode from project name
-  let projectPath = actualProjectDir || projectName.replace(/-/g, '/');
-  
-  // Try to read package.json from the project path
+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;
   }
 }
 
@@ -940,55 +819,70 @@ async function buildProjectFromDefinition(definition, providerLookups = null) {
   };
 
   try {
+    let claudeAcpSessions = [];
+    let codexAcpSessions = [];
+    let opencodeAcpSessions = [];
+    let geminiAcpSessions = [];
+
     if (providerLookups) {
-      project.codexSessions = providerLookups.codexSessionsByProjectPath?.get(normalizedProjectPath) || [];
-      project.opencodeSessions = providerLookups.opencodeSessionsByProjectPath?.get(normalizedProjectPath) || [];
-      project.geminiSessions = providerLookups.geminiSessionsByProjectPath?.get(normalizedProjectPath) || [];
+      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] = await Promise.all([
+      const [codexSessions, opencodeSessions, geminiSessions, acpSessions] = await Promise.all([
         getCodexSessions(definition.fullPath, { limit: 5 }),
         getOpencodeSessions(definition.fullPath, { limit: 5 }),
-        getGeminiSessions(definition.fullPath, { limit: 5 })
+        getGeminiSessions(definition.fullPath, { limit: 5 }),
+        listAcpSessions({ projectPath: definition.fullPath })
       ]);
-      project.codexSessions = codexSessions;
-      project.opencodeSessions = opencodeSessions;
-      project.geminiSessions = geminiSessions;
+      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 = sessionResult.sessions || [];
+      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);
   }
 
-  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;
 }
 
@@ -1013,17 +907,25 @@ async function getProjects(progressCallback = null) {
       .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) {
     projects.push(await buildProjectFromDefinition(definition, {
+      claudeAcpSessionsByProjectPath,
       codexSessionsByProjectPath,
+      codexAcpSessionsByProjectPath,
+      geminiSessionsByProjectPath,
+      geminiAcpSessionsByProjectPath,
       opencodeSessionsByProjectPath,
-      geminiSessionsByProjectPath
+      opencodeAcpSessionsByProjectPath
     }));
   }
 
@@ -1039,131 +941,149 @@ async function getProjects(progressCallback = null) {
   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';
+}
+
+function mergeClaudeSession(target, incoming) {
+  if (incoming.messageCount > target.messageCount) {
+    target.messageCount = incoming.messageCount;
+  }
+
+  if (incoming.summary !== 'New Session' && (target.summary === 'New Session' || incoming.lastActivity > target.lastActivity)) {
+    target.summary = incoming.summary;
+  }
+
+  if (incoming.lastActivity > target.lastActivity) {
+    target.lastActivity = incoming.lastActivity;
+    target.lastUserMessage = incoming.lastUserMessage || target.lastUserMessage;
+    target.lastAssistantMessage = incoming.lastAssistantMessage || target.lastAssistantMessage;
+  }
+
+  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 };
   }
 }
 
@@ -1207,159 +1127,117 @@ async function getClaudeSessionMetadata(sessionId) {
 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);
-
-          // 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 stream = fsSync.createReadStream(filePath);
+    const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });
 
-            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);
@@ -2279,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(
@@ -2501,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++;
           }
@@ -2554,23 +2459,6 @@ 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);
@@ -2587,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;