@axhub/genie 0.2.10 → 0.2.12

package/server/projects.js

@@ -51,10 +51,11 @@ import os from 'os';
 import path from 'path';
 import readline from 'readline';
 import crypto from 'crypto';
+import { spawn } from 'child_process';
 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 { deleteAcpSessionRecord, listAcpSessions } from './acp-runtime/session-store.js';
 import { mergeSessionLists } from './session-core/sessionListMerge.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -244,6 +245,7 @@ const projectListCache = {
   expiresAt: 0
 };
 const codexSessionFileCache = new Map();
+let codexAppServerClientOverride = null;
 const providerSessionLookupCache = {
   codex: { key: null, data: null, promise: null, expiresAt: 0 },
   gemini: { key: null, data: null, promise: null, expiresAt: 0 },
@@ -332,6 +334,309 @@ function cacheCodexSessionFilePath(sessionId, filePath) {
   codexSessionFileCache.set(sessionId, filePath);
 }
 
+class CodexAppServerClient {
+  constructor({ command = process.env.CODEX_APP_SERVER_COMMAND || 'codex' } = {}) {
+    this.command = command;
+    this.process = null;
+    this.readline = null;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.initialized = false;
+    this.initializePromise = null;
+    this.stopped = false;
+  }
+
+  start() {
+    if (this.process) {
+      return;
+    }
+
+    this.stopped = false;
+    this.process = spawn(this.command, ['app-server', '--listen', 'stdio://'], {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    this.readline = readline.createInterface({
+      input: this.process.stdout,
+      crlfDelay: Infinity
+    });
+
+    this.readline.on('line', (line) => this.handleLine(line));
+    this.process.stderr.on('data', (buffer) => {
+      const text = String(buffer || '').trim().split('\n')[0]?.slice(0, 500);
+      if (text) {
+        console.warn(`[codex app-server] ${text}`);
+      }
+    });
+
+    const rejectPending = (error) => {
+      for (const pending of this.pending.values()) {
+        pending.reject(error);
+      }
+      this.pending.clear();
+      this.process = null;
+      this.readline = null;
+      this.initialized = false;
+      this.initializePromise = null;
+    };
+
+    this.process.on('error', (error) => rejectPending(error));
+    this.process.on('exit', (code, signal) => {
+      if (this.stopped) {
+        rejectPending(new Error('codex app-server stopped'));
+        return;
+      }
+      rejectPending(new Error(`codex app-server exited unexpectedly: ${code ?? signal ?? 'unknown'}`));
+    });
+  }
+
+  handleLine(line) {
+    if (!line.trim()) {
+      return;
+    }
+
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch (_) {
+      return;
+    }
+
+    if (typeof message.id === 'number' && this.pending.has(message.id)) {
+      const pending = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      if (message.error) {
+        pending.reject(new Error(message.error.message || JSON.stringify(message.error)));
+      } else {
+        pending.resolve(message.result);
+      }
+      return;
+    }
+
+    if (typeof message.id === 'number' && typeof message.method === 'string') {
+      this.send({
+        jsonrpc: '2.0',
+        id: message.id,
+        result: {}
+      });
+    }
+  }
+
+  send(payload) {
+    this.start();
+    if (!this.process?.stdin?.writable) {
+      throw new Error('codex app-server is not writable');
+    }
+    this.process.stdin.write(`${JSON.stringify(payload)}\n`);
+  }
+
+  call(method, params) {
+    this.start();
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.send({
+        jsonrpc: '2.0',
+        id,
+        method,
+        params
+      });
+    });
+  }
+
+  async ensureInitialized() {
+    if (this.initialized) {
+      return;
+    }
+    if (this.initializePromise) {
+      await this.initializePromise;
+      return;
+    }
+
+    this.initializePromise = this.call('initialize', {
+      clientInfo: {
+        name: 'axhub-genie',
+        version: '0.2.11'
+      },
+      capabilities: {
+        experimentalApi: true
+      }
+    }).then(() => {
+      this.send({
+        jsonrpc: '2.0',
+        method: 'initialized'
+      });
+      this.initialized = true;
+    }).finally(() => {
+      this.initializePromise = null;
+    });
+
+    await this.initializePromise;
+  }
+
+  async listThreads({ cwd, limit = 5, cursor = null } = {}) {
+    await this.ensureInitialized();
+    return this.call('thread/list', {
+      archived: false,
+      sortKey: 'updated_at',
+      modelProviders: [],
+      cwd,
+      limit,
+      cursor: cursor || null
+    });
+  }
+
+  stop() {
+    this.stopped = true;
+    this.readline?.close();
+    this.process?.kill();
+    this.process = null;
+    this.readline = null;
+    this.pending.clear();
+    this.initialized = false;
+    this.initializePromise = null;
+  }
+}
+
+let codexAppServerClient = null;
+
+function getCodexAppServerClient() {
+  if (codexAppServerClientOverride) {
+    return codexAppServerClientOverride;
+  }
+
+  if (!codexAppServerClient) {
+    codexAppServerClient = new CodexAppServerClient();
+  }
+
+  return codexAppServerClient;
+}
+
+function setCodexAppServerClientForTests(client) {
+  if (!client) {
+    codexAppServerClient?.stop?.();
+    codexAppServerClient = null;
+  }
+  codexAppServerClientOverride = client;
+}
+
+function normalizeCodexAppServerTimestamp(updatedAt) {
+  const timestamp = Number(updatedAt);
+  if (!Number.isFinite(timestamp) || timestamp <= 0) {
+    return new Date(0);
+  }
+
+  return new Date(timestamp * 1000);
+}
+
+function mapCodexAppServerThreadToSession(thread) {
+  if (!thread || typeof thread !== 'object' || typeof thread.id !== 'string' || !thread.id.trim()) {
+    return null;
+  }
+
+  const session = {
+    id: thread.id.trim(),
+    summary: typeof thread.preview === 'string' && thread.preview.trim() ? thread.preview.trim() : 'Codex Session',
+    messageCount: 0,
+    lastActivity: normalizeCodexAppServerTimestamp(thread.updatedAt),
+    cwd: typeof thread.cwd === 'string' ? thread.cwd : '',
+    model: null,
+    filePath: typeof thread.path === 'string' && thread.path.trim() ? thread.path.trim() : null,
+    provider: 'codex',
+    source: 'app-server'
+  };
+
+  if (session.filePath) {
+    cacheCodexSessionFilePath(session.id, session.filePath);
+  }
+
+  return session;
+}
+
+async function getCodexSessionsFromAppServer(projectPath, options = {}) {
+  const { limit = 5 } = options;
+  const normalizedProjectPath = normalizeComparableProjectPath(projectPath);
+  if (!normalizedProjectPath) {
+    return [];
+  }
+
+  const payload = await getCodexAppServerClient().listThreads({
+    cwd: projectPath,
+    limit,
+    cursor: null
+  });
+  const threads = Array.isArray(payload?.data) ? payload.data : [];
+
+  return threads
+    .map(mapCodexAppServerThreadToSession)
+    .filter(Boolean)
+    .filter((session) => normalizeComparableProjectPath(session.cwd) === normalizedProjectPath)
+    .slice(0, limit > 0 ? limit : undefined);
+}
+
+async function findCodexAppServerSessionById(sessionId, options = {}) {
+  const normalizedSessionId = trimText(sessionId);
+  if (!normalizedSessionId) {
+    return null;
+  }
+
+  const { limit = 50 } = options;
+  let cursor = null;
+
+  do {
+    const payload = await getCodexAppServerClient().listThreads({
+      cwd: undefined,
+      limit,
+      cursor
+    });
+    const threads = Array.isArray(payload?.data) ? payload.data : [];
+    const matchedThread = threads.find((thread) => trimText(thread?.id) === normalizedSessionId);
+
+    if (matchedThread) {
+      return mapCodexAppServerThreadToSession(matchedThread);
+    }
+
+    cursor = payload?.nextCursor || null;
+  } while (cursor);
+
+  return null;
+}
+
+async function getCodexSessionsFromJsonl(projectPath, options = {}) {
+  const { limit = 5 } = options;
+  const sessions = [];
+  const normalizedProjectPath = normalizeComparableProjectPath(projectPath);
+  const jsonlFiles = await findFilesRecursively(
+    getCodexSessionsDir(),
+    (entryName) => entryName.endsWith('.jsonl')
+  );
+
+  for (const filePath of jsonlFiles) {
+    try {
+      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',
+          messageCount: sessionData.messageCount || 0,
+          lastActivity: sessionData.timestamp ? new Date(sessionData.timestamp) : new Date(),
+          cwd: sessionData.cwd,
+          model: sessionData.model,
+          filePath: filePath,
+          provider: 'codex'
+        });
+      }
+    } catch (error) {
+      console.warn(`Could not parse Codex session file ${filePath}:`, error.message);
+    }
+  }
+
+  sessions.sort((a, b) => new Date(b.lastActivity) - new Date(a.lastActivity));
+  return limit > 0 ? sessions.slice(0, limit) : sessions;
+}
+
 function findCodexSessionFilePathBySessionIdHint(sessionId, filePaths = []) {
   const normalizedSessionId = String(sessionId || '').trim();
   if (!normalizedSessionId || !Array.isArray(filePaths) || filePaths.length === 0) {
@@ -799,8 +1104,7 @@ async function getProjectsList(progressCallback = null) {
   return cloneProjectList(await projectListCache.promise);
 }
 
-async function buildProjectFromDefinition(definition, providerLookups = null) {
-  const normalizedProjectPath = normalizeComparableProjectPath(definition.fullPath);
+async function buildProjectFromDefinition(definition) {
   const project = {
     name: definition.name,
     path: definition.path,
@@ -819,66 +1123,21 @@ async function buildProjectFromDefinition(definition, providerLookups = null) {
   };
 
   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' });
-    }
+    const [claudeSessions, codexSessions, opencodeSessions, geminiSessions] = await Promise.all([
+      getLocalProviderSessions({ provider: 'claude', projectName: definition.name, projectPath: definition.fullPath, limit: 50 }),
+      getLocalProviderSessions({ provider: 'codex', projectName: definition.name, projectPath: definition.fullPath, limit: 50 }),
+      getLocalProviderSessions({ provider: 'opencode', projectName: definition.name, projectPath: definition.fullPath, limit: 50 }),
+      getLocalProviderSessions({ provider: 'gemini', projectName: definition.name, projectPath: definition.fullPath, limit: 50 })
+    ]);
+
+    project.sessions = claudeSessions;
+    project.codexSessions = codexSessions;
+    project.opencodeSessions = opencodeSessions;
+    project.geminiSessions = geminiSessions;
+    project.sessionMeta = {
+      hasMore: false,
+      total: claudeSessions.length
+    };
   } catch (error) {
     console.warn(`Could not load session details for project ${definition.name}:`, error.message);
   }
@@ -901,32 +1160,8 @@ 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, claudeAcpSessionsByProjectPath, codexAcpSessionsByProjectPath, geminiAcpSessionsByProjectPath, opencodeAcpSessionsByProjectPath] = await Promise.all([
-    buildCodexSessionsLookup(uniqueProjectPaths, { limit: 5 }),
-    buildGeminiSessionsLookup(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,
-      opencodeAcpSessionsByProjectPath
-    }));
+    projects.push(await buildProjectFromDefinition(definition));
   }
 
   // Emit completion after all projects (including manual) are processed
@@ -1378,12 +1613,20 @@ async function deleteSession(projectName, sessionId) {
         
         // Write back the filtered content
         await fs.writeFile(jsonlFile, filteredLines.join('\n') + (filteredLines.length > 0 ? '\n' : ''));
+        await deleteAcpSessionRecord('claude', sessionId).catch(() => {});
         return true;
       }
     }
-    
+
+    if (await deleteAcpSessionRecord('claude', sessionId).catch(() => false)) {
+      return true;
+    }
+
     throw new Error(`Session ${sessionId} not found in any files`);
   } catch (error) {
+    if (await deleteAcpSessionRecord('claude', sessionId).catch(() => false)) {
+      return true;
+    }
     console.error(`Error deleting session ${sessionId} from project ${projectName}:`, error);
     throw error;
   }
@@ -1533,47 +1776,27 @@ async function addProjectManually(projectPath, displayName = null) {
 }
 
 async function getCodexSessions(projectPath, options = {}) {
-  const { limit = 5 } = options;
-  try {
-    const sessions = [];
-    const normalizedProjectPath = normalizeComparableProjectPath(projectPath);
-    const jsonlFiles = await findFilesRecursively(
-      getCodexSessionsDir(),
-      (entryName) => entryName.endsWith('.jsonl')
-    );
-
-    // Process each file to find sessions matching the project path
-    for (const filePath of jsonlFiles) {
-      try {
-        const sessionData = await parseCodexSessionFile(filePath);
+  const { limit = 5, localOnly = false } = options;
+  if (localOnly) {
+    return getCodexSessionsFromJsonl(projectPath, { limit });
+  }
 
-        if (sessionData && normalizeComparableProjectPath(sessionData.cwd) === normalizedProjectPath) {
-          cacheCodexSessionFilePath(sessionData.id, filePath);
-          sessions.push({
-            id: sessionData.id,
-            summary: sessionData.summary || 'Codex Session',
-            messageCount: sessionData.messageCount || 0,
-            lastActivity: sessionData.timestamp ? new Date(sessionData.timestamp) : new Date(),
-            cwd: sessionData.cwd,
-            model: sessionData.model,
-            filePath: filePath,
-            provider: 'codex'
-          });
-        }
-      } catch (error) {
-        console.warn(`Could not parse Codex session file ${filePath}:`, error.message);
-      }
+  try {
+    const appServerSessions = await getCodexSessionsFromAppServer(projectPath, { limit });
+    if (appServerSessions.length > 0) {
+      return appServerSessions;
     }
 
-    // Sort sessions by last activity (newest first)
-    sessions.sort((a, b) => new Date(b.lastActivity) - new Date(a.lastActivity));
-
-    // Return limited sessions for performance (0 = unlimited for deletion)
-    return limit > 0 ? sessions.slice(0, limit) : sessions;
+    return await getCodexSessionsFromJsonl(projectPath, { limit });
 
   } catch (error) {
-    console.error('Error fetching Codex sessions:', error);
-    return [];
+    console.warn(`Codex app-server thread/list failed, falling back to JSONL scan: ${error.message}`);
+    try {
+      return await getCodexSessionsFromJsonl(projectPath, { limit });
+    } catch (fallbackError) {
+      console.error('Error fetching Codex sessions:', fallbackError);
+      return [];
+    }
   }
 }
 
@@ -1999,10 +2222,14 @@ async function deleteOpencodeSession(sessionId) {
   try {
     const sessionFilePath = await findOpencodeSessionFileById(sessionId);
     if (!sessionFilePath) {
+      if (await deleteAcpSessionRecord('opencode', sessionId).catch(() => false)) {
+        return true;
+      }
       throw new Error(`OpenCode session file not found for session ${sessionId}`);
     }
 
     await fs.unlink(sessionFilePath);
+    await deleteAcpSessionRecord('opencode', sessionId).catch(() => {});
     return true;
   } catch (error) {
     console.error(`Error deleting OpenCode session ${sessionId}:`, error);
@@ -2337,6 +2564,29 @@ async function getGeminiSessionMessages(sessionId, limit = null, offset = 0) {
   }
 }
 
+async function deleteGeminiSession(sessionId) {
+  try {
+    const sessionMetadata = await getGeminiSessionMetadata(sessionId);
+    const sessionFilePath = sessionMetadata?.filePath || null;
+
+    if (!sessionFilePath) {
+      if (await deleteAcpSessionRecord('gemini', sessionId).catch(() => false)) {
+        clearProviderSessionLookupCaches();
+        return true;
+      }
+      throw new Error(`Gemini session file not found for session ${sessionId}`);
+    }
+
+    await fs.unlink(sessionFilePath);
+    await deleteAcpSessionRecord('gemini', sessionId).catch(() => {});
+    clearProviderSessionLookupCaches();
+    return true;
+  } catch (error) {
+    console.error(`Error deleting Gemini session ${sessionId}:`, error);
+    throw error;
+  }
+}
+
 // Parse a Codex session JSONL file to extract metadata
 async function parseCodexSessionFile(filePath) {
   try {
@@ -2669,15 +2919,120 @@ async function getCodexSessionMetadata(sessionId) {
   return metadata;
 }
 
+function normalizeLocalProviderSession(session, provider, projectPath = null) {
+  if (!session || typeof session !== 'object') {
+    return null;
+  }
+
+  const sessionId = String(session.id || session.sessionId || '').trim();
+  if (!sessionId) {
+    return null;
+  }
+
+  const lastActivity = session.lastActivity || session.updatedAt || session.timestamp || session.createdAt || null;
+  const createdAt = session.createdAt || session.startTime || session.timestamp || lastActivity || null;
+  const cwd = session.cwd || session.projectPath || projectPath || null;
+  const summary = session.summary || session.title || session.name || `${provider} session`;
+
+  return {
+    ...session,
+    id: sessionId,
+    sessionId,
+    provider,
+    __provider: provider,
+    source: session.source || 'native-history',
+    runtime: 'native-history',
+    title: session.title || summary || sessionId,
+    summary: summary || null,
+    projectPath: cwd,
+    cwd,
+    createdAt,
+    updatedAt: session.updatedAt || lastActivity || createdAt,
+    lastActivity: lastActivity || createdAt,
+    model: session.model || null
+  };
+}
+
+async function getNativeProviderSessions({ provider, projectName = null, projectPath = null, limit = 50 } = {}) {
+  switch (provider) {
+    case 'claude': {
+      if (!projectName) {
+        return [];
+      }
+      try {
+        await fs.access(path.join(os.homedir(), '.claude', 'projects', projectName));
+      } catch (_) {
+        return [];
+      }
+      const result = await getSessions(projectName, limit > 0 ? limit : Number.MAX_SAFE_INTEGER, 0);
+      const sessions = Array.isArray(result?.sessions) ? result.sessions : [];
+      return sessions.map((session) => normalizeLocalProviderSession(session, 'claude', projectPath)).filter(Boolean);
+    }
+    case 'codex':
+      return (await getCodexSessions(projectPath, { limit, localOnly: true }))
+        .map((session) => normalizeLocalProviderSession(session, 'codex', projectPath))
+        .filter(Boolean);
+    case 'gemini':
+      return (await getGeminiSessions(projectPath, { limit }))
+        .map((session) => normalizeLocalProviderSession(session, 'gemini', projectPath))
+        .filter(Boolean);
+    case 'opencode':
+      return (await getOpencodeSessions(projectPath, { limit }))
+        .map((session) => normalizeLocalProviderSession(session, 'opencode', projectPath))
+        .filter(Boolean);
+    default:
+      return [];
+  }
+}
+
+async function getLocalProviderSessions({ provider, projectName = null, projectPath = null, limit = 50 } = {}) {
+  const [nativeSessions, acpSessions] = await Promise.all([
+    getNativeProviderSessions({ provider, projectName, projectPath, limit }),
+    listAcpSessions({ provider, projectPath }).catch(() => [])
+  ]);
+
+  return mergeSessionLists(nativeSessions, acpSessions, { fallbackProvider: provider })
+    .slice(0, limit > 0 ? limit : undefined);
+}
+
+async function getLocalProviderSessionMessages({
+  provider,
+  projectName = null,
+  sessionId,
+  limit = null,
+  offset = 0
+} = {}) {
+  switch (provider) {
+    case 'claude':
+      if (!projectName) {
+        return { messages: [], total: 0, hasMore: false, offset, limit };
+      }
+      return getSessionMessages(projectName, sessionId, limit, offset);
+    case 'codex':
+      return getCodexSessionMessages(sessionId, limit, offset);
+    case 'gemini':
+      return getGeminiSessionMessages(sessionId, limit, offset);
+    case 'opencode':
+      return getOpencodeSessionMessages(sessionId, limit, offset);
+    default:
+      return { messages: [], total: 0, hasMore: false, offset, limit };
+  }
+}
+
 async function deleteCodexSession(sessionId) {
   try {
     const sessionFilePath = await resolveCodexSessionFile(sessionId);
 
     if (!sessionFilePath) {
+      if (await deleteAcpSessionRecord('codex', sessionId).catch(() => false)) {
+        codexSessionFileCache.delete(sessionId);
+        return true;
+      }
       throw new Error(`Codex session file not found for session ${sessionId}`);
     }
 
     await fs.unlink(sessionFilePath);
+    await deleteAcpSessionRecord('codex', sessionId).catch(() => {});
     codexSessionFileCache.delete(sessionId);
     return true;
   } catch (error) {
@@ -2704,16 +3059,21 @@ export {
   extractProjectDirectory,
   clearProjectDirectoryCache,
   clearProviderSessionLookupCaches,
+  setCodexAppServerClientForTests,
   findCodexSessionFilePathBySessionIdHint,
+  findCodexAppServerSessionById,
   getCodexSessions,
   getCodexSessionMessages,
   getCodexSessionMetadata,
+  getLocalProviderSessions,
+  getLocalProviderSessionMessages,
   getOpencodeSessions,
   getOpencodeSessionMetadata,
   getOpencodeSessionMessages,
   getGeminiSessions,
   getGeminiSessionMetadata,
   getGeminiSessionMessages,
+  deleteGeminiSession,
   deleteCodexSession,
   deleteOpencodeSession
 };