@axhub/genie 0.2.6 → 0.2.8

package/server/routes/cli-auth.js

@@ -1,9 +1,9 @@
 import express from 'express';
-import { constants as fsConstants } from 'fs';
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import { listOpencodeModels } from '../opencode-cli.js';
+import { resolveCommandPath } from '../utils/resolveCommandPath.js';
 
 const router = express.Router();
 const INSTALLATION_CACHE_TTL_MS = 12 * 60 * 60 * 1000;
@@ -22,78 +22,6 @@ const PROVIDER_INSTALL_HINTS = {
 const installationStatusCache = new Map(); // provider -> status
 const installationStatusInFlight = new Map(); // provider -> Promise
 
-function getLocatorCommand() {
-  return process.platform === 'win32' ? 'where' : 'which';
-}
-
-async function isRunnableCommand(candidatePath) {
-  try {
-    if (process.platform === 'win32') {
-      await fs.access(candidatePath, fsConstants.F_OK);
-      return true;
-    }
-
-    await fs.access(candidatePath, fsConstants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function resolveCommandPath(command) {
-  const normalizedCommand = String(command || '').trim();
-  if (!normalizedCommand) {
-    return {
-      found: false,
-      resolvedPath: null,
-      reason: 'Command name is empty'
-    };
-  }
-
-  const isDirectPath = normalizedCommand.includes(path.sep) || (process.platform === 'win32' && normalizedCommand.includes('/'));
-  const pathEntries = isDirectPath
-    ? ['']
-    : String(process.env.PATH || '')
-      .split(path.delimiter)
-      .map((entry) => entry.trim())
-      .filter(Boolean);
-
-  const windowsExtensions = process.platform === 'win32'
-    ? String(process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
-      .split(';')
-      .map((ext) => ext.trim())
-      .filter(Boolean)
-    : [''];
-
-  const candidatePaths = [];
-  for (const baseDir of pathEntries) {
-    const baseCandidate = isDirectPath ? normalizedCommand : path.join(baseDir, normalizedCommand);
-    candidatePaths.push(baseCandidate);
-
-    if (process.platform === 'win32' && !path.extname(baseCandidate)) {
-      for (const ext of windowsExtensions) {
-        candidatePaths.push(`${baseCandidate}${ext}`);
-      }
-    }
-  }
-
-  for (const candidatePath of candidatePaths) {
-    if (await isRunnableCommand(candidatePath)) {
-      return {
-        found: true,
-        resolvedPath: candidatePath,
-        reason: null
-      };
-    }
-  }
-
-  return {
-    found: false,
-    resolvedPath: null,
-    reason: `${normalizedCommand} not found in PATH`
-  };
-}
-
 function buildInstallationStatus(provider, command, installed, resolvedPath, reason, cacheHit = false) {
   return {
     success: true,

package/server/routes/commands.js

@@ -199,13 +199,8 @@ Custom commands can be created in:
     }, {});
 
     const currentProvider = context?.provider || 'claude';
-    const providerDefaults = {
-      claude: CLAUDE_MODELS.DEFAULT,
-      codex: CODEX_MODELS.DEFAULT,
-      gemini: GEMINI_MODELS.DEFAULT,
-      opencode: OPENCODE_MODELS.DEFAULT
-    };
-    const currentModel = context?.model || providerDefaults[currentProvider] || CLAUDE_MODELS.DEFAULT;
+    const discoveredCurrentModel = providerDiscovery.find((item) => item.provider === currentProvider)?.currentModel || null;
+    const currentModel = context?.model || discoveredCurrentModel || null;
     const opencodeDiscovery = providerDiscovery.find((item) => item.provider === 'opencode') || null;
 
     return {
@@ -220,7 +215,7 @@ Custom commands can be created in:
         opencodeDiscovery,
         message: args.length > 0
           ? `Switching to model: ${args[0]}`
-          : `Current model: ${currentModel}`
+          : (currentModel ? `Current model: ${currentModel}` : 'Current model is managed by the active provider configuration.')
       }
     };
   },
@@ -254,7 +249,7 @@ Custom commands can be created in:
         packageName,
         uptime: uptimeFormatted,
         uptimeSeconds: Math.floor(uptime),
-        model: context?.model || 'claude-sonnet-4.5',
+        model: context?.model || null,
         provider: context?.provider || 'claude',
         nodeVersion: process.version,
         platform: process.platform

package/server/routes/git.js

@@ -610,26 +610,9 @@ Generate the commit message:`;
           const parsed = typeof data === 'string' ? JSON.parse(data) : data;
           console.log('🔍 Writer received message type:', parsed.type);
 
-          // Handle different message formats from supported providers
-          // Claude SDK sends: {type: 'claude-response', data: {message: {content: [...]}}}
-          if (parsed.type === 'claude-response' && parsed.data) {
-            const message = parsed.data.message || parsed.data;
-            console.log('📦 Claude response message:', JSON.stringify(message, null, 2).substring(0, 500));
-            if (message.content && Array.isArray(message.content)) {
-              // Extract text from content array
-              for (const item of message.content) {
-                if (item.type === 'text' && item.text) {
-                  console.log('✅ Extracted text chunk:', item.text.substring(0, 100));
-                  responseText += item.text;
-                }
-              }
-            }
-          }
-          else if (parsed.type === 'claude-response' && parsed.data?.type === 'content_block_delta' && parsed.data?.delta?.text) {
-            responseText += parsed.data.delta.text;
-          }
-          // Also handle direct text messages
-          else if (parsed.type === 'text' && parsed.text) {
+          if (parsed.type === 'conversation-event' && parsed.event?.kind === 'assistant_text_delta' && parsed.event?.payload?.text) {
+            responseText += parsed.event.payload.text;
+          } else if (parsed.type === 'text' && parsed.text) {
             console.log('✅ Direct text:', parsed.text.substring(0, 100));
             responseText += parsed.text;
           }

package/server/routes/projects.js

@@ -1,13 +1,23 @@
 import express from 'express';
 import { promises as fs } from 'fs';
 import path from 'path';
-import os from 'os';
 import { addProjectManually } from '../projects.js';
+import {
+  DEFAULT_WORKSPACES_ROOT,
+  HAS_WORKSPACES_ROOT_RESTRICTION,
+  WORKSPACES_ROOTS,
+  formatAllowedWorkspaceRoots,
+  isPathWithinAllowedRoots,
+  resolveAllowedWorkspaceRoots
+} from '../utils/workspaceRoots.js';
 
-const router = express.Router();
+export {
+  DEFAULT_WORKSPACES_ROOT,
+  HAS_WORKSPACES_ROOT_RESTRICTION,
+  WORKSPACES_ROOTS
+} from '../utils/workspaceRoots.js';
 
-// Configure allowed workspace root (defaults to user's home directory)
-export const WORKSPACES_ROOT = process.env.WORKSPACES_ROOT || os.homedir();
+const router = express.Router();
 
 // System-critical paths that should never be used as workspace directories
 export const FORBIDDEN_PATHS = [
@@ -42,8 +52,14 @@ export const FORBIDDEN_PATHS = [
  * @param {string} requestedPath - The path to validate
  * @returns {Promise<{valid: boolean, resolvedPath?: string, error?: string}>}
  */
-export async function validateWorkspacePath(requestedPath) {
+export async function validateWorkspacePath(requestedPath, options = {}) {
   try {
+    const {
+      fsImpl = fs,
+      hasWorkspaceRootRestriction = HAS_WORKSPACES_ROOT_RESTRICTION,
+      allowedWorkspaceRoots = WORKSPACES_ROOTS
+    } = options;
+
     // Resolve to absolute path
     let absolutePath = path.resolve(requestedPath);
 
@@ -79,14 +95,14 @@ export async function validateWorkspacePath(requestedPath) {
     let realPath;
     try {
       // Check if path exists to resolve real path
-      await fs.access(absolutePath);
-      realPath = await fs.realpath(absolutePath);
+      await fsImpl.access(absolutePath);
+      realPath = await fsImpl.realpath(absolutePath);
     } catch (error) {
       if (error.code === 'ENOENT') {
         // Path doesn't exist yet - check parent directory
         let parentPath = path.dirname(absolutePath);
         try {
-          const parentRealPath = await fs.realpath(parentPath);
+          const parentRealPath = await fsImpl.realpath(parentPath);
 
           // Reconstruct the full path with real parent
           realPath = path.join(parentRealPath, path.basename(absolutePath));
@@ -104,31 +120,36 @@ export async function validateWorkspacePath(requestedPath) {
       }
     }
 
-    // Resolve the workspace root to its real path
-    const resolvedWorkspaceRoot = await fs.realpath(WORKSPACES_ROOT);
+    if (hasWorkspaceRootRestriction && allowedWorkspaceRoots.length > 0) {
+      const resolvedWorkspaceRoots = await resolveAllowedWorkspaceRoots({
+        fsImpl,
+        allowedWorkspaceRoots
+      });
 
-    // Ensure the resolved path is contained within the allowed workspace root
-    if (!realPath.startsWith(resolvedWorkspaceRoot + path.sep) &&
-        realPath !== resolvedWorkspaceRoot) {
-      return {
-        valid: false,
-        error: `Workspace path must be within the allowed workspace root: ${WORKSPACES_ROOT}`
-      };
+      if (!isPathWithinAllowedRoots(realPath, resolvedWorkspaceRoots)) {
+        return {
+          valid: false,
+          error: `Workspace path must be within one of the allowed workspace roots: ${formatAllowedWorkspaceRoots(allowedWorkspaceRoots)}`
+        };
+      }
     }
 
     // Additional symlink check for existing paths
     try {
-      await fs.access(absolutePath);
-      const stats = await fs.lstat(absolutePath);
+      await fsImpl.access(absolutePath);
+      const stats = await fsImpl.lstat(absolutePath);
 
-      if (stats.isSymbolicLink()) {
+      if (stats.isSymbolicLink() && hasWorkspaceRootRestriction && allowedWorkspaceRoots.length > 0) {
+        const resolvedWorkspaceRoots = await resolveAllowedWorkspaceRoots({
+          fsImpl,
+          allowedWorkspaceRoots
+        });
         // Verify symlink target is also within allowed root
-        const linkTarget = await fs.readlink(absolutePath);
+        const linkTarget = await fsImpl.readlink(absolutePath);
         const resolvedTarget = path.resolve(path.dirname(absolutePath), linkTarget);
-        const realTarget = await fs.realpath(resolvedTarget);
+        const realTarget = await fsImpl.realpath(resolvedTarget);
 
-        if (!realTarget.startsWith(resolvedWorkspaceRoot + path.sep) &&
-            realTarget !== resolvedWorkspaceRoot) {
+        if (!isPathWithinAllowedRoots(realTarget, resolvedWorkspaceRoots)) {
           return {
             valid: false,
             error: 'Symlink target is outside the allowed workspace root'

package/server/routes/session-core.js

@@ -2,10 +2,17 @@ import express from 'express';
 import { getProjects } from '../projects.js';
 import { discoverAllProviders, discoverProvider } from '../session-core/providerDiscovery.js';
 import { getProviderAdapter } from '../session-core/providerAdapters.js';
+import { listAcpSessions } from '../acp-runtime/session-store.js';
 
 const router = express.Router();
 
-function flattenProjectSessions(project) {
+router.use((req, res, next) => {
+  res.setHeader('X-Runtime-Engine', 'acp');
+  next();
+});
+
+async function flattenProjectSessions(project) {
+  const projectPath = project.fullPath || project.path || null;
   const groups = [
     { provider: 'claude', items: project.sessions || [] },
     { provider: 'codex', items: project.codexSessions || [] },
@@ -13,7 +20,12 @@ function flattenProjectSessions(project) {
     { provider: 'opencode', items: project.opencodeSessions || [] }
   ];
 
-  return groups.flatMap(({ provider, items }) => items.map((item) => ({ ...item, provider, __provider: provider })))
+  const acpSessions = await listAcpSessions({ projectPath });
+
+  return [
+    ...groups.flatMap(({ provider, items }) => items.map((item) => ({ ...item, provider, __provider: provider, source: item?.source || 'legacy' }))),
+    ...acpSessions.map((item) => ({ ...item, provider: item.provider, __provider: item.provider, source: 'acp' }))
+  ]
     .sort((a, b) => new Date(b.lastActivity || b.updated_at || b.createdAt || 0) - new Date(a.lastActivity || a.updated_at || a.createdAt || 0));
 }
 
@@ -42,7 +54,15 @@ router.get('/projects/:projectName/history-index', async (req, res) => {
     if (!project) {
       return res.status(404).json({ success: false, error: 'Project not found' });
     }
-    res.json({ success: true, project: { name: project.name, fullPath: project.fullPath || project.path, displayName: project.displayName || project.name }, sessions: flattenProjectSessions(project) });
+    res.json({
+      success: true,
+      project: {
+        name: project.name,
+        fullPath: project.fullPath || project.path,
+        displayName: project.displayName || project.name
+      },
+      sessions: await flattenProjectSessions(project)
+    });
   } catch (error) {
     res.status(500).json({ success: false, error: error.message });
   }
@@ -66,19 +86,26 @@ router.get('/sessions/:sessionId/resolve', async (req, res) => {
       'opencode'
     ].filter((provider, index, all) => provider && all.indexOf(provider) === index);
 
-    const directProjectMatch = projects.find((project) => {
-      const flattened = flattenProjectSessions(project);
-      return flattened.some((session) => session.id === requestedSessionId);
-    });
+    let directProjectMatch = null;
+    let directMatchSessions = [];
+
+    for (const project of projects) {
+      const flattened = await flattenProjectSessions(project);
+      if (flattened.some((session) => session.id === requestedSessionId)) {
+        directProjectMatch = project;
+        directMatchSessions = flattened;
+        break;
+      }
+    }
 
     if (directProjectMatch) {
-      const flattened = flattenProjectSessions(directProjectMatch);
-      const matchedSession = flattened.find((session) => session.id === requestedSessionId);
+      const matchedSession = directMatchSessions.find((session) => session.id === requestedSessionId);
 
       return res.json({
         success: true,
         found: true,
         provider: matchedSession.provider,
+        source: matchedSession.source || 'legacy',
         session: matchedSession,
         project: {
           name: directProjectMatch.name,
@@ -97,7 +124,12 @@ router.get('/sessions/:sessionId/resolve', async (req, res) => {
 
         try {
           if (provider === 'claude') {
-            const result = await adapter.listSessions({ projectName: project.name, limit: 1000, offset: 0 });
+            const result = await adapter.listSessions({
+              projectName: project.name,
+              projectPath: project.fullPath || project.path,
+              limit: 1000,
+              offset: 0
+            });
             sessions = Array.isArray(result) ? result : [];
           } else {
             sessions = await adapter.listSessions({ projectPath: project.fullPath || project.path, limit: 0 });
@@ -115,6 +147,7 @@ router.get('/sessions/:sessionId/resolve', async (req, res) => {
           success: true,
           found: true,
           provider,
+          source: matchedSession.source || 'legacy',
           session: matchedSession,
           project: {
             name: project.name,
@@ -157,6 +190,7 @@ router.get('/sessions/:provider/:sessionId/events', async (req, res) => {
       success: true,
       provider: req.params.provider,
       sessionId: req.params.sessionId,
+      source: result?.source || 'legacy',
       events,
       total,
       hasMore,

package/server/session-core/abortSession.js

@@ -1,7 +1,4 @@
-import { abortClaudeSDKSession } from '../claude-sdk.js';
-import { abortCodexSession } from '../openai-codex.js';
-import { abortGeminiSession } from '../gemini-cli.js';
-import { abortOpencodeSession } from '../opencode-cli.js';
+import { abortAgentSession as abortAcpAgentSession } from '../acp-runtime/index.js';
 
 export const ABORTABLE_AGENT_PROVIDERS = ['claude', 'codex', 'gemini', 'opencode'];
 
@@ -11,20 +8,7 @@ export function isAbortableAgentProvider(provider) {
 
 export async function abortAgentSession(provider, sessionId) {
   const normalizedProvider = String(provider || 'claude').trim().toLowerCase();
-
-  if (normalizedProvider === 'codex') {
-    return abortCodexSession(sessionId);
-  }
-
-  if (normalizedProvider === 'gemini') {
-    return abortGeminiSession(sessionId);
-  }
-
-  if (normalizedProvider === 'opencode') {
-    return abortOpencodeSession(sessionId);
-  }
-
-  return abortClaudeSDKSession(sessionId);
+  return abortAcpAgentSession(normalizedProvider, sessionId);
 }
 
 export async function abortAgentSessionWithWriter({ provider = 'claude', sessionId, writer }) {

package/server/session-core/eventStore.js

@@ -24,7 +24,11 @@ function normalizePersistedEvents(events = []) {
   return events.filter((event) => (
     isConversationEvent(event) &&
     event.sessionId &&
-    PERSISTED_EVENT_KINDS.has(event.kind)
+    (
+      event.extensions?.runtimeSource === 'acp' ||
+      event.rawRef?.runtime === 'acp' ||
+      PERSISTED_EVENT_KINDS.has(event.kind)
+    )
   ));
 }
 

package/server/session-core/providerAdapters.js

@@ -10,6 +10,10 @@ import {
   getOpencodeSessions,
   getGeminiSessions
 } from '../projects.js';
+import {
+  findAcpSessionRecord,
+  listAcpSessions
+} from '../acp-runtime/session-store.js';
 
 async function flattenLegacyMessages(result) {
   if (Array.isArray(result)) return result;
@@ -28,47 +32,131 @@ async function normalizeLegacyLoadResult(result, provider, sessionId) {
 
   return {
     ...result,
-    events
+    events,
+    source: 'legacy'
+  };
+}
+
+function mergeSessionLists(legacySessions = [], acpSessions = []) {
+  const merged = new Map();
+
+  legacySessions.forEach((session) => {
+    if (session?.id) {
+      merged.set(session.id, session);
+    }
+  });
+
+  acpSessions.forEach((session) => {
+    if (session?.id) {
+      merged.set(session.id, session);
+    }
+  });
+
+  return Array.from(merged.values()).sort((left, right) => {
+    const leftTime = new Date(left?.lastActivity || left?.updatedAt || left?.createdAt || 0).getTime();
+    const rightTime = new Date(right?.lastActivity || right?.updatedAt || right?.createdAt || 0).getTime();
+    return rightTime - leftTime;
+  });
+}
+
+async function loadAcpEvents(provider, sessionId) {
+  const record = await findAcpSessionRecord(sessionId, provider);
+  if (!record) {
+    return null;
+  }
+
+  const events = await readMirroredConversationEvents(provider, sessionId);
+  return {
+    events,
+    total: events.length,
+    hasMore: false,
+    offset: 0,
+    limit: null,
+    source: 'acp'
   };
 }
 
 const PROVIDER_ADAPTERS = {
   claude: {
-    async listSessions({ projectName, limit = 50, offset = 0 }) {
-      const result = await getSessions(projectName, limit, offset);
-      return (result?.sessions || []).map((session) => ({ ...session, provider: 'claude' }));
+    async listSessions({ projectName, projectPath, limit = 50, offset = 0 }) {
+      const [result, acpSessions] = await Promise.all([
+        getSessions(projectName, limit, offset),
+        listAcpSessions({ provider: 'claude', projectPath: projectPath || null })
+      ]);
+      return mergeSessionLists(
+        (result?.sessions || []).map((session) => ({ ...session, provider: 'claude', source: 'legacy' })),
+        acpSessions
+      );
     },
     async loadEvents({ projectName, sessionId, limit = null, offset = 0 }) {
+      const acpResult = await loadAcpEvents('claude', sessionId);
+      if (acpResult) {
+        return acpResult;
+      }
+
       const rawMessages = await getSessionMessages(projectName, sessionId, limit, offset);
       return normalizeLegacyLoadResult(rawMessages, 'claude', sessionId);
     }
   },
   codex: {
     async listSessions({ projectPath, limit = 50 }) {
-      const sessions = await getCodexSessions(projectPath, { limit });
-      return sessions.map((session) => ({ ...session, provider: 'codex' }));
+      const [sessions, acpSessions] = await Promise.all([
+        getCodexSessions(projectPath, { limit }),
+        listAcpSessions({ provider: 'codex', projectPath: projectPath || null })
+      ]);
+      return mergeSessionLists(
+        sessions.map((session) => ({ ...session, provider: 'codex', source: 'legacy' })),
+        acpSessions
+      );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
+      const acpResult = await loadAcpEvents('codex', sessionId);
+      if (acpResult) {
+        return acpResult;
+      }
+
       const rawMessages = await getCodexSessionMessages(sessionId, limit, offset);
       return normalizeLegacyLoadResult(rawMessages, 'codex', sessionId);
     }
   },
   gemini: {
     async listSessions({ projectPath, limit = 50 }) {
-      const sessions = await getGeminiSessions(projectPath, { limit });
-      return sessions.map((session) => ({ ...session, provider: 'gemini' }));
+      const [sessions, acpSessions] = await Promise.all([
+        getGeminiSessions(projectPath, { limit }),
+        listAcpSessions({ provider: 'gemini', projectPath: projectPath || null })
+      ]);
+      return mergeSessionLists(
+        sessions.map((session) => ({ ...session, provider: 'gemini', source: 'legacy' })),
+        acpSessions
+      );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
+      const acpResult = await loadAcpEvents('gemini', sessionId);
+      if (acpResult) {
+        return acpResult;
+      }
+
       const rawMessages = await getGeminiSessionMessages(sessionId, limit, offset);
       return normalizeLegacyLoadResult(rawMessages, 'gemini', sessionId);
     }
   },
   opencode: {
     async listSessions({ projectPath, limit = 50 }) {
-      const sessions = await getOpencodeSessions(projectPath, { limit });
-      return sessions.map((session) => ({ ...session, provider: 'opencode' }));
+      const [sessions, acpSessions] = await Promise.all([
+        getOpencodeSessions(projectPath, { limit }),
+        listAcpSessions({ provider: 'opencode', projectPath: projectPath || null })
+      ]);
+      return mergeSessionLists(
+        sessions.map((session) => ({ ...session, provider: 'opencode', source: 'legacy' })),
+        acpSessions
+      );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
+      const acpResult = await loadAcpEvents('opencode', sessionId);
+      if (acpResult) {
+        return acpResult;
+      }
+
       const rawMessages = await getOpencodeSessionMessages(sessionId, limit, offset);
       return normalizeLegacyLoadResult(rawMessages, 'opencode', sessionId);
     }

package/server/session-core/providerDiscovery.js

@@ -151,7 +151,12 @@ async function discoverOpenCodeModels(projectPath) {
 }
 
 async function discoverClaudeModels() {
-  return { models: mapModelOptions(CLAUDE_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: process.env.CLAUDE_MODEL || CLAUDE_MODELS.DEFAULT };
+  return {
+    models: mapModelOptions(CLAUDE_MODELS.OPTIONS, 'runtime-fallback'),
+    source: 'runtime-fallback',
+    error: null,
+    currentModel: null
+  };
 }
 
 async function discoverCodexModels() {
@@ -163,11 +168,11 @@ async function discoverCodexModels() {
     if (match) currentModel = match[1];
   } catch {
   }
-  return { models: mapModelOptions(CODEX_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: currentModel || CODEX_MODELS.DEFAULT };
+  return { models: mapModelOptions(CODEX_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: currentModel || null };
 }
 
 async function discoverGeminiModels() {
-  return { models: mapModelOptions(GEMINI_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: GEMINI_MODELS.DEFAULT };
+  return { models: mapModelOptions(GEMINI_MODELS.OPTIONS, 'runtime-fallback'), source: 'runtime-fallback', error: null, currentModel: null };
 }
 
 const AUTH_CHECKERS = {

package/server/session-core/runtimeState.js

@@ -7,10 +7,8 @@ import {
 } from './eventStore.js';
 import { getProviderAdapter } from './providerAdapters.js';
 import { getProjects } from '../projects.js';
-import { isClaudeSDKSessionActive } from '../claude-sdk.js';
-import { isCodexSessionActive } from '../openai-codex.js';
-import { isGeminiSessionActive } from '../gemini-cli.js';
-import { isOpencodeSessionActive } from '../opencode-cli.js';
+import { findAcpSessionRecord } from '../acp-runtime/session-store.js';
+import { isAgentSessionActive } from '../acp-runtime/index.js';
 
 export const AGENT_RUNTIME_PHASES = {
   IDLE: 'idle',
@@ -86,6 +84,18 @@ async function resolveSessionProjectContext(provider, sessionId) {
     return null;
   }
 
+  const acpRecord = await findAcpSessionRecord(normalizedSessionId, normalizedProvider);
+  if (acpRecord) {
+    return {
+      projectName: null,
+      projectPath: acpRecord.projectPath || null,
+      session: {
+        id: normalizedSessionId,
+        source: 'acp'
+      }
+    };
+  }
+
   const projects = await getProjects();
 
   for (const project of projects) {
@@ -149,19 +159,7 @@ function isSessionActive(provider, sessionId) {
     return false;
   }
 
-  if (normalizedProvider === 'codex') {
-    return Boolean(isCodexSessionActive(normalizedSessionId));
-  }
-
-  if (normalizedProvider === 'gemini') {
-    return Boolean(isGeminiSessionActive(normalizedSessionId));
-  }
-
-  if (normalizedProvider === 'opencode') {
-    return Boolean(isOpencodeSessionActive(normalizedSessionId));
-  }
-
-  return Boolean(isClaudeSDKSessionActive(normalizedSessionId));
+  return Boolean(isAgentSessionActive(normalizedProvider, normalizedSessionId));
 }
 
 function inferPhaseFromEvents(events = []) {
@@ -204,6 +202,7 @@ function inferPhaseFromEvents(events = []) {
       event.kind === CONVERSATION_EVENT_KINDS.TOOL_CALL_INPUT ||
       event.kind === CONVERSATION_EVENT_KINDS.TOOL_CALL_END ||
       event.kind === CONVERSATION_EVENT_KINDS.TOOL_RESULT ||
+      event.kind === CONVERSATION_EVENT_KINDS.PLAN_UPDATE ||
       event.kind === CONVERSATION_EVENT_KINDS.SYSTEM_NOTICE
     ) {
       inferredPhase = AGENT_RUNTIME_PHASES.STREAMING;