factory-factory 0.2.7 → 0.3.0

package/dist/src/backend/domains/session/lifecycle/session.service.js

@@ -1,9 +1,11 @@
-import { SessionStatus } from '../../../../../prisma/generated/client.js';
+import { SessionStatus } from '@factory-factory/core';
+import { AcpEventTranslator, AcpPermissionBridge, acpRuntimeManager, } from '../../../../backend/domains/session/acp/index.js';
+import { sessionFileLogger } from '../../../../backend/domains/session/logging/session-file-logger.service.js';
+import { sessionDomainService } from '../../../../backend/domains/session/session-domain.service.js';
 import { createLogger } from '../../../../backend/services/logger.service.js';
+import { extractPlanText } from '../../../../shared/acp-protocol/plan-content.js';
+import { EMPTY_CHAT_BAR_CAPABILITIES } from '../../../../shared/chat-capabilities.js';
 import { createInitialSessionRuntimeState, } from '../../../../shared/session-runtime.js';
-import { SessionManager } from '../claude/session.js';
-import { sessionDomainService } from '../session-domain.service.js';
-import { sessionProcessManager } from './session.process-manager.js';
 import { sessionPromptBuilder } from './session.prompt-builder.js';
 import { sessionRepository } from './session.repository.js';
 const logger = createLogger('session');
@@ -11,9 +13,14 @@ const STALE_LOADING_RUNTIME_MAX_AGE_MS = 30_000;
 class SessionService {
     repository;
     promptBuilder;
-    processManager;
-    getClientWorkingState(client) {
-        return typeof client.isWorking === 'function' ? client.isWorking() : false;
+    acpEventTranslator = new AcpEventTranslator(logger);
+    acpPermissionBridges = new Map();
+    acpStreamState = new Map();
+    suppressAcpReplayForSession = new Set();
+    workspaceBridge = null;
+    sessionToWorkspace = new Map();
+    configure(bridges) {
+        this.workspaceBridge = bridges.workspace;
     }
     isStaleLoadingRuntime(runtime) {
         if (runtime.phase !== 'loading' || runtime.processState === 'alive') {
@@ -25,41 +32,313 @@ class SessionService {
         }
         return Date.now() - updatedAtMs > STALE_LOADING_RUNTIME_MAX_AGE_MS;
     }
-    setOnClientCreated(callback) {
-        this.processManager.setOnClientCreated(callback);
+    setupAcpEventHandler(sessionId) {
+        const bridge = new AcpPermissionBridge();
+        this.acpPermissionBridges.set(sessionId, bridge);
+        return {
+            permissionBridge: bridge,
+            onAcpEvent: (sid, event) => {
+                const typed = event;
+                if (typed.type === 'acp_session_update') {
+                    const { update } = event;
+                    if (update.sessionUpdate === 'user_message_chunk' && update.content.type === 'text') {
+                        this.handleAcpUserMessageChunk(sid, update.content.text);
+                        return;
+                    }
+                    const deltas = this.acpEventTranslator.translateSessionUpdate(update);
+                    for (const delta of deltas) {
+                        this.handleAcpDelta(sid, delta);
+                    }
+                    return;
+                }
+                if (typed.type === 'acp_permission_request') {
+                    this.handleAcpPermissionRequest(sid, event);
+                    return;
+                }
+            },
+            onSessionId: async (sid, providerSessionId) => {
+                try {
+                    await this.repository.updateSession(sid, { providerSessionId });
+                    logger.debug('Updated session with ACP providerSessionId', {
+                        sessionId: sid,
+                        providerSessionId,
+                    });
+                }
+                catch (error) {
+                    logger.warn('Failed to update session with ACP providerSessionId', {
+                        sessionId: sid,
+                        providerSessionId,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            },
+            onExit: async (sid, exitCode) => {
+                this.acpStreamState.delete(sid);
+                this.suppressAcpReplayForSession.delete(sid);
+                this.sessionToWorkspace.delete(sid);
+                const b = this.acpPermissionBridges.get(sid);
+                if (b) {
+                    b.cancelAll();
+                    this.acpPermissionBridges.delete(sid);
+                }
+                try {
+                    sessionDomainService.markProcessExit(sid, exitCode);
+                    const session = await this.repository.updateSession(sid, {
+                        status: SessionStatus.COMPLETED,
+                    });
+                    logger.debug('Updated ACP session status to COMPLETED on exit', { sessionId: sid });
+                    await this.repository.clearRatchetActiveSession(session.workspaceId, sid);
+                    if (session.workflow === 'ratchet') {
+                        await this.repository.deleteSession(sid);
+                        logger.debug('Deleted transient ratchet ACP session', { sessionId: sid });
+                    }
+                }
+                catch (error) {
+                    logger.warn('Failed to update ACP session status on exit', {
+                        sessionId: sid,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            },
+            onError: (sid, error) => {
+                logger.error('ACP client error', {
+                    sessionId: sid,
+                    error: error.message,
+                    stack: error.stack,
+                });
+            },
+            onAcpLog: (sid, payload) => {
+                sessionFileLogger.log(sid, 'FROM_CLAUDE_CLI', payload);
+            },
+        };
+    }
+    handleAcpDelta(sid, delta) {
+        this.maybeLiftReplaySuppression(sid);
+        if (this.suppressAcpReplayForSession.has(sid) &&
+            delta.type !== 'config_options_update' &&
+            delta.type !== 'slash_commands') {
+            return;
+        }
+        if (delta.type === 'config_options_update') {
+            const acpHandle = acpRuntimeManager.getClient(sid);
+            if (acpHandle) {
+                const { configOptions } = delta;
+                acpHandle.configOptions = configOptions;
+                void this.persistAcpConfigSnapshot(sid, {
+                    provider: acpHandle.provider,
+                    providerSessionId: acpHandle.providerSessionId,
+                    configOptions: acpHandle.configOptions,
+                });
+                sessionDomainService.emitDelta(sid, delta);
+                sessionDomainService.emitDelta(sid, {
+                    type: 'chat_capabilities',
+                    capabilities: this.buildAcpChatBarCapabilities(acpHandle),
+                });
+                return;
+            }
+        }
+        if (delta.type !== 'agent_message') {
+            sessionDomainService.emitDelta(sid, delta);
+            return;
+        }
+        const data = delta.data;
+        if (data.type === 'assistant') {
+            this.accumulateAcpText(sid, data);
+            return;
+        }
+        this.acpStreamState.delete(sid);
+        const order = sessionDomainService.appendClaudeEvent(sid, data);
+        sessionDomainService.emitDelta(sid, { ...delta, order });
+    }
+    handleAcpUserMessageChunk(sid, text) {
+        this.maybeLiftReplaySuppression(sid);
+        if (this.suppressAcpReplayForSession.has(sid)) {
+            return;
+        }
+        if (acpRuntimeManager.isSessionWorking(sid)) {
+            return;
+        }
+        const normalized = text.trim();
+        if (normalized.length === 0) {
+            return;
+        }
+        sessionDomainService.injectCommittedUserMessage(sid, normalized);
+    }
+    accumulateAcpText(sid, data) {
+        const content = data.message?.content;
+        const chunkText = Array.isArray(content) && content[0]?.type === 'text'
+            ? content[0].text
+            : '';
+        let ss = this.acpStreamState.get(sid);
+        if (!ss) {
+            ss = { textOrder: sessionDomainService.allocateOrder(sid), accText: '' };
+            this.acpStreamState.set(sid, ss);
+        }
+        ss.accText += chunkText;
+        const accMsg = {
+            type: 'assistant',
+            message: { role: 'assistant', content: [{ type: 'text', text: ss.accText }] },
+        };
+        sessionDomainService.upsertClaudeEvent(sid, accMsg, ss.textOrder);
+        sessionDomainService.emitDelta(sid, {
+            type: 'agent_message',
+            data: accMsg,
+            order: ss.textOrder,
+        });
+    }
+    handleAcpPermissionRequest(sid, event) {
+        const { requestId, params } = event;
+        const toolName = params.toolCall.title ?? 'ACP Tool';
+        const toolInput = params.toolCall.rawInput ?? {};
+        const acpOptions = params.options.map((o) => ({
+            optionId: o.optionId,
+            name: o.name,
+            kind: o.kind,
+        }));
+        const planContent = this.extractPlanContent(toolName, toolInput);
+        if (toolName === 'AskUserQuestion') {
+            const questions = this.extractAskUserQuestions(toolInput);
+            sessionDomainService.emitDelta(sid, {
+                type: 'user_question',
+                requestId,
+                questions,
+                acpOptions,
+            });
+        }
+        else {
+            sessionDomainService.emitDelta(sid, {
+                type: 'permission_request',
+                requestId,
+                toolName,
+                toolUseId: params.toolCall.toolCallId,
+                toolInput,
+                planContent,
+                acpOptions,
+            });
+        }
+        sessionDomainService.setPendingInteractiveRequest(sid, {
+            requestId,
+            toolName,
+            toolUseId: params.toolCall.toolCallId,
+            input: toolInput,
+            planContent,
+            acpOptions,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    extractAskUserQuestions(input) {
+        const questions = input.questions;
+        if (!Array.isArray(questions)) {
+            return [];
+        }
+        return questions;
+    }
+    extractPlanContent(toolName, input) {
+        if (toolName !== 'ExitPlanMode') {
+            return null;
+        }
+        return extractPlanText(input.plan);
+    }
+    async createAcpClient(sessionId, options, session) {
+        const sessionContext = await this.loadSessionContext(sessionId, session);
+        if (!sessionContext) {
+            throw new Error(`Session context not ready: ${sessionId}`);
+        }
+        await this.repository.markWorkspaceHasHadSessions(sessionContext.workspaceId);
+        this.sessionToWorkspace.set(sessionId, sessionContext.workspaceId);
+        const handlers = this.setupAcpEventHandler(sessionId);
+        const shouldSuppressReplay = this.shouldSuppressReplayDuringAcpResume(sessionId, session);
+        if (shouldSuppressReplay) {
+            this.suppressAcpReplayForSession.add(sessionId);
+        }
+        else {
+            this.suppressAcpReplayForSession.delete(sessionId);
+        }
+        const clientOptions = {
+            provider: session?.provider ?? 'CLAUDE',
+            workingDir: sessionContext.workingDir,
+            model: options?.model ?? sessionContext.model,
+            systemPrompt: sessionContext.systemPrompt,
+            permissionMode: options?.permissionMode ?? 'bypassPermissions',
+            sessionId,
+            resumeProviderSessionId: session?.providerSessionId ?? undefined,
+        };
+        let handle;
+        try {
+            handle = await acpRuntimeManager.getOrCreateClient(sessionId, clientOptions, handlers, {
+                workspaceId: sessionContext.workspaceId,
+                workingDir: sessionContext.workingDir,
+            });
+        }
+        catch (error) {
+            this.suppressAcpReplayForSession.delete(sessionId);
+            throw error;
+        }
+        await this.persistAcpConfigSnapshot(sessionId, {
+            provider: handle.provider,
+            providerSessionId: handle.providerSessionId,
+            configOptions: handle.configOptions,
+            existingMetadata: session?.providerMetadata ?? undefined,
+        });
+        if (handle.configOptions.length > 0) {
+            sessionDomainService.emitDelta(sessionId, {
+                type: 'config_options_update',
+                configOptions: handle.configOptions,
+            });
+        }
+        sessionDomainService.emitDelta(sessionId, {
+            type: 'chat_capabilities',
+            capabilities: this.buildAcpChatBarCapabilities(handle),
+        });
+        return handle;
+    }
+    shouldSuppressReplayDuringAcpResume(sessionId, session) {
+        if (!session?.providerSessionId) {
+            return false;
+        }
+        if (!sessionDomainService.isHistoryHydrated(sessionId)) {
+            return false;
+        }
+        return sessionDomainService.getTranscriptSnapshot(sessionId).length > 0;
+    }
+    maybeLiftReplaySuppression(sessionId) {
+        if (!this.suppressAcpReplayForSession.has(sessionId)) {
+            return;
+        }
+        if (!acpRuntimeManager.isSessionWorking(sessionId)) {
+            return;
+        }
+        this.suppressAcpReplayForSession.delete(sessionId);
     }
     constructor(options) {
         this.repository = options?.repository ?? sessionRepository;
         this.promptBuilder = options?.promptBuilder ?? sessionPromptBuilder;
-        this.processManager = options?.processManager ?? sessionProcessManager;
     }
-    async startClaudeSession(sessionId, options) {
+    async startSession(sessionId, options) {
         const session = await this.repository.getSessionById(sessionId);
         if (!session) {
             throw new Error(`Session not found: ${sessionId}`);
         }
-        if (this.processManager.isStopInProgress(sessionId)) {
+        if (acpRuntimeManager.isStopInProgress(sessionId)) {
             throw new Error('Session is currently being stopped');
         }
-        const existingClient = this.processManager.getClient(sessionId);
+        const existingClient = acpRuntimeManager.getClient(sessionId);
         if (existingClient) {
             throw new Error('Session is already running');
         }
-        const client = await this.getOrCreateClient(sessionId, {
-            permissionMode: 'bypassPermissions',
-        });
+        await this.getOrCreateAcpSessionClient(sessionId, { permissionMode: 'bypassPermissions' }, session);
         const initialPrompt = options?.initialPrompt ?? 'Continue with the task.';
         if (initialPrompt) {
-            await client.sendMessage(initialPrompt);
+            await this.sendSessionMessage(sessionId, initialPrompt);
         }
-        logger.info('Claude session started', { sessionId });
+        logger.info('Session started', { sessionId, provider: session.provider });
     }
-    async stopClaudeSession(sessionId, options) {
-        if (this.processManager.isStopInProgress(sessionId)) {
+    async stopSession(sessionId, options) {
+        const session = await this.loadSessionForStop(sessionId);
+        if (acpRuntimeManager.isStopInProgress(sessionId)) {
             logger.debug('Session stop already in progress', { sessionId });
             return;
         }
-        const session = await this.loadSessionForStop(sessionId);
         const current = this.getRuntimeSnapshot(sessionId);
         sessionDomainService.setRuntimeSnapshot(sessionId, {
             ...current,
@@ -67,18 +346,44 @@ class SessionService {
             activity: 'IDLE',
             updatedAt: new Date().toISOString(),
         });
-        await this.processManager.stopClient(sessionId);
-        await this.updateStoppedSessionState(sessionId);
-        sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: false });
-        sessionDomainService.setRuntimeSnapshot(sessionId, {
-            phase: 'idle',
-            processState: 'stopped',
-            activity: 'IDLE',
-            updatedAt: new Date().toISOString(),
-        });
-        const shouldCleanupTransientRatchetSession = options?.cleanupTransientRatchetSession ?? true;
-        await this.cleanupTransientRatchetOnStop(session, sessionId, shouldCleanupTransientRatchetSession);
-        logger.info('Claude session stopped', { sessionId });
+        this.acpStreamState.delete(sessionId);
+        this.suppressAcpReplayForSession.delete(sessionId);
+        const acpBridge = this.acpPermissionBridges.get(sessionId);
+        if (acpBridge) {
+            acpBridge.cancelAll();
+            this.acpPermissionBridges.delete(sessionId);
+        }
+        let stopClientFailed = false;
+        try {
+            if (!acpRuntimeManager.isStopInProgress(sessionId)) {
+                await acpRuntimeManager.stopClient(sessionId);
+            }
+        }
+        catch (error) {
+            stopClientFailed = true;
+            logger.warn('Error stopping ACP session runtime; continuing cleanup', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            await this.updateStoppedSessionState(sessionId);
+            sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: false });
+            sessionDomainService.setRuntimeSnapshot(sessionId, {
+                phase: 'idle',
+                processState: 'stopped',
+                activity: 'IDLE',
+                updatedAt: new Date().toISOString(),
+            });
+            if (!stopClientFailed) {
+                const shouldCleanupTransientRatchetSession = options?.cleanupTransientRatchetSession ?? true;
+                await this.cleanupTransientRatchetOnStop(session, sessionId, shouldCleanupTransientRatchetSession);
+            }
+            logger.info('ACP session stopped', {
+                sessionId,
+                ...(stopClientFailed ? { runtimeStopFailed: true } : {}),
+            });
+        }
     }
     async loadSessionForStop(sessionId) {
         try {
@@ -96,7 +401,6 @@ class SessionService {
         try {
             await this.repository.updateSession(sessionId, {
                 status: SessionStatus.IDLE,
-                claudeProcessPid: null,
             });
         }
         catch (error) {
@@ -137,88 +441,269 @@ class SessionService {
     async stopWorkspaceSessions(workspaceId) {
         const sessions = await this.repository.getSessionsByWorkspaceId(workspaceId);
         for (const session of sessions) {
-            await this.stopWorkspaceSession(session, workspaceId);
+            if (session.status === SessionStatus.RUNNING ||
+                acpRuntimeManager.isSessionRunning(session.id)) {
+                try {
+                    await this.stopSession(session.id);
+                }
+                catch (error) {
+                    logger.error('Failed to stop workspace session', {
+                        sessionId: session.id,
+                        workspaceId,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
         }
         logger.info('Stopped all workspace sessions', { workspaceId, count: sessions.length });
     }
-    async getOrCreateClient(sessionId, options) {
-        const existing = this.processManager.getClient(sessionId);
-        if (existing) {
-            const isWorking = this.getClientWorkingState(existing);
-            sessionDomainService.setRuntimeSnapshot(sessionId, {
-                phase: isWorking ? 'running' : 'idle',
-                processState: 'alive',
-                activity: isWorking ? 'WORKING' : 'IDLE',
-                updatedAt: new Date().toISOString(),
+    async getOrCreateSessionClient(sessionId, options) {
+        const session = await this.repository.getSessionById(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        return await this.getOrCreateAcpSessionClient(sessionId, options ?? {}, session);
+    }
+    async getOrCreateSessionClientFromRecord(session, options) {
+        return await this.getOrCreateAcpSessionClient(session.id, options ?? {}, session);
+    }
+    getSessionClient(sessionId) {
+        return acpRuntimeManager.getClient(sessionId);
+    }
+    getSessionConfigOptions(sessionId) {
+        const acpHandle = acpRuntimeManager.getClient(sessionId);
+        return acpHandle ? [...acpHandle.configOptions] : [];
+    }
+    async getSessionConfigOptionsWithFallback(sessionId) {
+        const liveConfigOptions = this.getSessionConfigOptions(sessionId);
+        if (liveConfigOptions.length > 0) {
+            return liveConfigOptions;
+        }
+        const session = await this.repository.getSessionById(sessionId);
+        if (!session) {
+            return [];
+        }
+        const cachedSnapshot = this.extractAcpConfigSnapshot(session.providerMetadata);
+        if (cachedSnapshot && cachedSnapshot.provider === session.provider) {
+            return [...cachedSnapshot.configOptions];
+        }
+        return [];
+    }
+    async setSessionModel(sessionId, model) {
+        const acpHandle = acpRuntimeManager.getClient(sessionId);
+        if (acpHandle) {
+            const modelOption = acpHandle.configOptions.find((o) => o.category === 'model');
+            if (modelOption && model) {
+                const availableValues = this.getConfigOptionValues(modelOption);
+                if (availableValues.length > 0 && !availableValues.includes(model)) {
+                    logger.debug('Skipping unsupported model for ACP session', {
+                        sessionId,
+                        provider: acpHandle.provider,
+                        model,
+                        availableValues,
+                    });
+                    return;
+                }
+                await this.setSessionConfigOption(sessionId, modelOption.id, model);
+            }
+            return;
+        }
+        logger.debug('No ACP handle for setSessionModel', { sessionId, model });
+    }
+    setSessionReasoningEffort(sessionId, _effort) {
+        logger.debug('setSessionReasoningEffort is a no-op for ACP sessions', { sessionId });
+    }
+    async setSessionThinkingBudget(sessionId, maxTokens) {
+        const acpHandle = acpRuntimeManager.getClient(sessionId);
+        if (acpHandle) {
+            const thoughtOption = acpHandle.configOptions.find((o) => o.category === 'thought_level');
+            if (thoughtOption && maxTokens != null) {
+                await this.setSessionConfigOption(sessionId, thoughtOption.id, String(maxTokens));
+            }
+            return;
+        }
+        logger.debug('No ACP handle for setSessionThinkingBudget', { sessionId, maxTokens });
+    }
+    async setSessionConfigOption(sessionId, configId, value) {
+        const acpHandle = acpRuntimeManager.getClient(sessionId);
+        const selectedOption = acpHandle?.configOptions.find((option) => option.id === configId);
+        const isModeOption = configId === 'mode' || selectedOption?.category === 'mode';
+        const isModelOption = configId === 'model' || selectedOption?.category === 'model';
+        const configOptions = isModeOption
+            ? await acpRuntimeManager.setSessionMode(sessionId, value)
+            : isModelOption
+                ? await acpRuntimeManager.setSessionModel(sessionId, value)
+                : await acpRuntimeManager.setConfigOption(sessionId, configId, value);
+        sessionDomainService.emitDelta(sessionId, {
+            type: 'config_options_update',
+            configOptions,
+        });
+        const acpHandleAfterUpdate = acpRuntimeManager.getClient(sessionId);
+        if (acpHandleAfterUpdate) {
+            await this.persistAcpConfigSnapshot(sessionId, {
+                provider: acpHandleAfterUpdate.provider,
+                providerSessionId: acpHandleAfterUpdate.providerSessionId,
+                configOptions: configOptions,
             });
-            return existing;
         }
+    }
+    sendSessionMessage(sessionId, content) {
+        const acpClient = acpRuntimeManager.getClient(sessionId);
+        if (acpClient) {
+            const normalizedText = typeof content === 'string' ? content : this.normalizeContentToText(content);
+            return this.sendAcpMessage(sessionId, normalizedText).then(() => {
+            }, (error) => {
+                logger.error('ACP prompt failed', {
+                    sessionId,
+                    error: error instanceof Error
+                        ? error.message
+                        : typeof error === 'object'
+                            ? JSON.stringify(error)
+                            : String(error),
+                });
+            });
+        }
+        logger.warn('No ACP client found for sendSessionMessage', { sessionId });
+        return Promise.resolve();
+    }
+    normalizeContentToText(content) {
+        const chunks = [];
+        for (const item of content) {
+            switch (item.type) {
+                case 'text':
+                    chunks.push(item.text);
+                    break;
+                case 'thinking':
+                    chunks.push(item.thinking);
+                    break;
+                case 'image':
+                    chunks.push('[Image attachment omitted for this provider]');
+                    break;
+                case 'tool_result':
+                    if (typeof item.content === 'string') {
+                        chunks.push(item.content);
+                    }
+                    else {
+                        chunks.push(JSON.stringify(item.content));
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        return chunks.join('\n\n');
+    }
+    async sendAcpMessage(sessionId, content) {
+        const workspaceId = this.sessionToWorkspace.get(sessionId);
         sessionDomainService.setRuntimeSnapshot(sessionId, {
-            phase: 'starting',
+            phase: 'running',
             processState: 'alive',
-            activity: 'IDLE',
+            activity: 'WORKING',
             updatedAt: new Date().toISOString(),
         });
+        if (workspaceId && this.workspaceBridge) {
+            this.workspaceBridge.markSessionRunning(workspaceId, sessionId);
+        }
         try {
-            const { clientOptions, context, handlers } = await this.buildClientOptions(sessionId, {
-                thinkingEnabled: options?.thinkingEnabled,
-                permissionMode: options?.permissionMode,
-                model: options?.model,
-            });
-            const client = await this.processManager.getOrCreateClient(sessionId, clientOptions, handlers, context);
-            await this.repository.updateSession(sessionId, {
-                status: SessionStatus.RUNNING,
-                claudeProcessPid: client.getPid() ?? null,
-            });
-            const isWorking = this.getClientWorkingState(client);
+            const result = await acpRuntimeManager.sendPrompt(sessionId, content);
             sessionDomainService.setRuntimeSnapshot(sessionId, {
-                phase: isWorking ? 'running' : 'idle',
+                phase: 'idle',
                 processState: 'alive',
-                activity: isWorking ? 'WORKING' : 'IDLE',
+                activity: 'IDLE',
                 updatedAt: new Date().toISOString(),
             });
-            return client;
+            return result.stopReason;
         }
         catch (error) {
             sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'error',
-                processState: 'stopped',
+                processState: 'alive',
                 activity: 'IDLE',
                 updatedAt: new Date().toISOString(),
             });
             throw error;
         }
+        finally {
+            if (workspaceId && this.workspaceBridge) {
+                this.workspaceBridge.markSessionIdle(workspaceId, sessionId);
+            }
+        }
+    }
+    async cancelAcpPrompt(sessionId) {
+        await acpRuntimeManager.cancelPrompt(sessionId);
+    }
+    getSessionConversationHistory(sessionId, _workingDir) {
+        const transcript = sessionDomainService.getTranscriptSnapshot(sessionId);
+        return transcript.flatMap((entry) => this.mapTranscriptEntryToHistory(entry));
+    }
+    mapTranscriptEntryToHistory(entry) {
+        if (entry.source === 'user') {
+            return entry.text
+                ? [
+                    {
+                        type: 'user',
+                        content: entry.text,
+                        timestamp: entry.timestamp,
+                    },
+                ]
+                : [];
+        }
+        const message = entry.message;
+        if (!message || (message.type !== 'assistant' && message.type !== 'user')) {
+            return [];
+        }
+        const content = this.extractMessageText(message);
+        if (!content) {
+            return [];
+        }
+        return [
+            {
+                type: message.type,
+                content,
+                timestamp: entry.timestamp,
+            },
+        ];
+    }
+    extractMessageText(message) {
+        const content = message.message?.content;
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (!Array.isArray(content)) {
+            return '';
+        }
+        return content
+            .filter((item) => item.type === 'text')
+            .map((item) => item.text)
+            .join('\n')
+            .trim();
     }
-    getClient(sessionId) {
-        return this.processManager.getClient(sessionId);
+    respondToAcpPermission(sessionId, requestId, optionId) {
+        const bridge = this.acpPermissionBridges.get(sessionId);
+        if (!bridge) {
+            return false;
+        }
+        return bridge.resolvePermission(requestId, optionId);
     }
     getRuntimeSnapshot(sessionId) {
         const fallback = createInitialSessionRuntimeState();
         const persisted = sessionDomainService.getRuntimeSnapshot(sessionId);
         const base = persisted ?? fallback;
-        const client = this.processManager.getClient(sessionId);
-        if (client) {
-            const isWorking = this.getClientWorkingState(client);
+        const acpClient = acpRuntimeManager.getClient(sessionId);
+        if (acpClient) {
+            const isWorking = acpRuntimeManager.isSessionWorking(sessionId);
             return {
                 phase: isWorking ? 'running' : 'idle',
                 processState: 'alive',
                 activity: isWorking ? 'WORKING' : 'IDLE',
-                updatedAt: new Date().toISOString(),
-            };
-        }
-        if (this.processManager.getPendingClient(sessionId)) {
-            return {
-                phase: 'starting',
-                processState: 'alive',
-                activity: 'IDLE',
-                updatedAt: new Date().toISOString(),
+                updatedAt: base.updatedAt,
             };
         }
-        if (this.processManager.isStopInProgress(sessionId)) {
+        if (acpRuntimeManager.isStopInProgress(sessionId)) {
             return {
                 ...base,
                 phase: 'stopping',
-                updatedAt: new Date().toISOString(),
+                updatedAt: base.updatedAt,
             };
         }
         if (this.isStaleLoadingRuntime(base)) {
@@ -227,67 +712,48 @@ class SessionService {
                 phase: 'idle',
                 processState: 'stopped',
                 activity: 'IDLE',
-                updatedAt: new Date().toISOString(),
+                updatedAt: base.updatedAt,
             };
         }
         return base;
     }
-    buildClientEventHandlers() {
-        return {
-            onSessionId: async (sessionId, claudeSessionId) => {
-                try {
-                    await this.repository.updateSession(sessionId, { claudeSessionId });
-                    logger.debug('Updated session with claudeSessionId', { sessionId, claudeSessionId });
-                }
-                catch (error) {
-                    logger.warn('Failed to update session with claudeSessionId', {
-                        sessionId,
-                        claudeSessionId,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            },
-            onExit: async (sessionId, exitCode) => {
-                try {
-                    sessionDomainService.markProcessExit(sessionId, exitCode);
-                    const session = await this.repository.updateSession(sessionId, {
-                        status: SessionStatus.COMPLETED,
-                        claudeProcessPid: null,
-                    });
-                    logger.debug('Updated session status to COMPLETED on exit', { sessionId });
-                    await this.repository.clearRatchetActiveSession(session.workspaceId, sessionId);
-                    if (session.workflow === 'ratchet') {
-                        await this.repository.deleteSession(sessionId);
-                        logger.debug('Deleted transient ratchet session', { sessionId });
-                    }
-                }
-                catch (error) {
-                    logger.warn('Failed to update session status on exit', {
-                        sessionId,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            },
-            onError: (sessionId, error) => {
-                logger.error('Claude client error', {
-                    sessionId,
-                    error: error.message,
-                    stack: error.stack,
-                });
-            },
-        };
-    }
-    getClaudeProcess(sessionId) {
-        return this.processManager.getClaudeProcess(sessionId);
+    async getOrCreateAcpSessionClient(sessionId, options, session) {
+        const existingAcp = acpRuntimeManager.getClient(sessionId);
+        if (existingAcp) {
+            sessionDomainService.setRuntimeSnapshot(sessionId, {
+                phase: existingAcp.isPromptInFlight ? 'running' : 'idle',
+                processState: 'alive',
+                activity: existingAcp.isPromptInFlight ? 'WORKING' : 'IDLE',
+                updatedAt: new Date().toISOString(),
+            });
+            return existingAcp;
+        }
+        sessionDomainService.setRuntimeSnapshot(sessionId, {
+            phase: 'starting',
+            processState: 'alive',
+            activity: 'IDLE',
+            updatedAt: new Date().toISOString(),
+        });
+        const handle = await this.createAcpClient(sessionId, options, session);
+        await this.repository.updateSession(sessionId, {
+            status: SessionStatus.RUNNING,
+        });
+        sessionDomainService.setRuntimeSnapshot(sessionId, {
+            phase: handle.isPromptInFlight ? 'running' : 'idle',
+            processState: 'alive',
+            activity: handle.isPromptInFlight ? 'WORKING' : 'IDLE',
+            updatedAt: new Date().toISOString(),
+        });
+        return handle;
     }
     isSessionRunning(sessionId) {
-        return this.processManager.isSessionRunning(sessionId);
+        return acpRuntimeManager.isSessionRunning(sessionId);
     }
     isSessionWorking(sessionId) {
-        return this.processManager.isSessionWorking(sessionId);
+        return acpRuntimeManager.isSessionWorking(sessionId);
     }
     isAnySessionWorking(sessionIds) {
-        return this.processManager.isAnySessionWorking(sessionIds);
+        return acpRuntimeManager.isAnySessionWorking(sessionIds);
     }
     async getSessionOptions(sessionId) {
         const sessionContext = await this.loadSessionContext(sessionId);
@@ -296,86 +762,209 @@ class SessionService {
         }
         return {
             workingDir: sessionContext.workingDir,
-            resumeClaudeSessionId: sessionContext.resumeClaudeSessionId,
+            resumeProviderSessionId: sessionContext.resumeProviderSessionId,
             systemPrompt: sessionContext.systemPrompt,
             model: sessionContext.model,
         };
     }
-    getAllActiveProcesses() {
-        return this.processManager.getAllActiveProcesses();
-    }
-    getAllClients() {
-        return this.processManager.getAllClients();
+    async getChatBarCapabilities(sessionId) {
+        const acpHandle = acpRuntimeManager.getClient(sessionId);
+        if (acpHandle) {
+            return this.buildAcpChatBarCapabilities(acpHandle);
+        }
+        const session = await this.repository.getSessionById(sessionId);
+        if (!session) {
+            return EMPTY_CHAT_BAR_CAPABILITIES;
+        }
+        const cachedSnapshot = this.extractAcpConfigSnapshot(session.providerMetadata);
+        if (cachedSnapshot && cachedSnapshot.provider === session.provider) {
+            return this.buildCapabilitiesFromConfigOptions(session.provider, cachedSnapshot.configOptions, cachedSnapshot.observedModelId);
+        }
+        if (session.provider === 'CODEX') {
+            return {
+                ...EMPTY_CHAT_BAR_CAPABILITIES,
+                provider: 'CODEX',
+            };
+        }
+        return EMPTY_CHAT_BAR_CAPABILITIES;
     }
-    async stopAllClients(timeoutMs = 5000) {
-        await this.processManager.stopAllClients(timeoutMs);
+    buildAcpChatBarCapabilities(handle) {
+        return this.buildCapabilitiesFromConfigOptions(handle.provider, handle.configOptions);
     }
-    shouldStopWorkspaceSession(session) {
-        const pendingClient = this.processManager.getPendingClient(session.id);
-        const shouldStop = Boolean(session.status === SessionStatus.RUNNING ||
-            this.processManager.getClaudeProcess(session.id) ||
-            pendingClient);
-        return { shouldStop, pendingClient };
+    buildCapabilitiesFromConfigOptions(provider, configOptions, fallbackModel) {
+        const modelOption = configOptions.find((o) => o.category === 'model');
+        const thoughtOption = configOptions.find((o) => o.category === 'thought_level');
+        const selectedModel = modelOption?.currentValue
+            ? String(modelOption.currentValue)
+            : (fallbackModel ?? undefined);
+        const modelOptions = this.buildModelOptions(modelOption, selectedModel);
+        const isCodexProvider = provider === 'CODEX';
+        return {
+            provider,
+            model: {
+                enabled: modelOptions.length > 0,
+                options: modelOptions,
+                ...(selectedModel ? { selected: selectedModel } : {}),
+            },
+            reasoning: {
+                enabled: false,
+                options: [],
+            },
+            thinking: {
+                enabled: !!thoughtOption,
+            },
+            planMode: { enabled: true },
+            attachments: isCodexProvider
+                ? { enabled: false, kinds: [] }
+                : { enabled: true, kinds: ['image', 'text'] },
+            slashCommands: { enabled: false },
+            usageStats: { enabled: false, contextWindow: false },
+            rewind: { enabled: false },
+        };
     }
-    async waitForPendingClient(workspaceId, sessionId, pendingClient) {
-        if (!pendingClient) {
-            return;
+    buildModelOptions(modelOption, selectedModel) {
+        if (!modelOption) {
+            return selectedModel ? [{ value: selectedModel, label: selectedModel }] : [];
+        }
+        const uniqueValues = new Set(this.getConfigOptionValues(modelOption));
+        if (selectedModel) {
+            uniqueValues.add(selectedModel);
         }
+        return Array.from(uniqueValues).map((value) => ({ value, label: value }));
+    }
+    getConfigOptionValues(option) {
+        return option.options.flatMap((entry) => {
+            if (typeof entry !== 'object' || entry === null) {
+                return [];
+            }
+            if ('value' in entry && typeof entry.value === 'string') {
+                return [entry.value];
+            }
+            if ('options' in entry && Array.isArray(entry.options)) {
+                return entry.options
+                    .map((grouped) => grouped?.value)
+                    .filter((value) => typeof value === 'string');
+            }
+            return [];
+        });
+    }
+    async stopAllClients(_timeoutMs = 5000) {
         try {
-            await pendingClient;
+            await acpRuntimeManager.stopAllClients();
         }
         catch (error) {
-            logger.warn('Pending Claude session failed to start before stop', {
-                sessionId,
-                workspaceId,
+            logger.error('Failed to stop ACP clients during shutdown', {
                 error: error instanceof Error ? error.message : String(error),
             });
+            throw error;
         }
     }
-    async stopWorkspaceSession(session, workspaceId) {
-        const { shouldStop, pendingClient } = this.shouldStopWorkspaceSession(session);
-        if (!shouldStop) {
+    async persistAcpConfigSnapshot(sessionId, params) {
+        if (params.configOptions.length === 0) {
             return;
         }
-        await this.waitForPendingClient(workspaceId, session.id, pendingClient);
+        const configOptionsForStorage = this.cloneConfigOptionsForStorage(params.configOptions);
+        const observedModelId = this.resolveObservedModel(configOptionsForStorage);
+        const metadataSource = params.existingMetadata ??
+            (await this.repository.getSessionById(sessionId))?.providerMetadata ??
+            null;
+        const metadataRecord = this.toMetadataRecord(metadataSource);
+        const snapshot = {
+            provider: params.provider,
+            providerSessionId: params.providerSessionId,
+            capturedAt: new Date().toISOString(),
+            configOptions: configOptionsForStorage,
+            ...(observedModelId ? { observedModelId } : {}),
+        };
+        const nextMetadata = {
+            ...metadataRecord,
+            acpConfigSnapshot: snapshot,
+        };
+        if (observedModelId) {
+            nextMetadata.observedModelId = observedModelId;
+        }
         try {
-            await this.stopClaudeSession(session.id);
+            await this.repository.updateSession(sessionId, {
+                providerMetadata: nextMetadata,
+            });
         }
         catch (error) {
-            logger.error('Failed to stop workspace session', {
-                sessionId: session.id,
-                workspaceId,
+            logger.warn('Failed persisting ACP config snapshot to session metadata; retrying once', {
+                sessionId,
                 error: error instanceof Error ? error.message : String(error),
             });
+            try {
+                const latestMetadataSource = (await this.repository.getSessionById(sessionId))
+                    ?.providerMetadata;
+                const latestMetadata = this.toMetadataRecord(latestMetadataSource);
+                const retryMetadata = {
+                    ...latestMetadata,
+                    acpConfigSnapshot: snapshot,
+                };
+                if (observedModelId) {
+                    retryMetadata.observedModelId = observedModelId;
+                }
+                await this.repository.updateSession(sessionId, {
+                    providerMetadata: retryMetadata,
+                });
+            }
+            catch (retryError) {
+                logger.warn('Retry failed persisting ACP config snapshot to session metadata', {
+                    sessionId,
+                    error: retryError instanceof Error ? retryError.message : String(retryError),
+                });
+            }
         }
     }
-    async buildClientOptions(sessionId, options) {
-        const sessionContext = await this.loadSessionContext(sessionId);
-        if (!sessionContext) {
-            throw new Error(`Session not found: ${sessionId}`);
+    cloneConfigOptionsForStorage(configOptions) {
+        try {
+            return structuredClone(configOptions);
+        }
+        catch {
+            return configOptions;
+        }
+    }
+    toMetadataRecord(metadata) {
+        if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) {
+            return {};
+        }
+        return { ...metadata };
+    }
+    extractAcpConfigSnapshot(metadata) {
+        const record = this.toMetadataRecord(metadata);
+        const snapshot = record.acpConfigSnapshot;
+        if (typeof snapshot !== 'object' || snapshot === null || Array.isArray(snapshot)) {
+            return null;
+        }
+        const candidate = snapshot;
+        const provider = candidate.provider;
+        const providerSessionId = candidate.providerSessionId;
+        const configOptions = candidate.configOptions;
+        const observedModelId = candidate.observedModelId;
+        if (provider !== 'CLAUDE' && provider !== 'CODEX') {
+            return null;
+        }
+        if (typeof providerSessionId !== 'string' || providerSessionId.length === 0) {
+            return null;
+        }
+        if (!Array.isArray(configOptions)) {
+            return null;
         }
-        await this.repository.markWorkspaceHasHadSessions(sessionContext.workspaceId);
-        const claudeProjectPath = SessionManager.getProjectPath(sessionContext.workingDir);
-        await this.repository.updateSession(sessionId, { claudeProjectPath });
-        const clientOptions = {
-            workingDir: sessionContext.workingDir,
-            resumeClaudeSessionId: sessionContext.resumeClaudeSessionId,
-            systemPrompt: sessionContext.systemPrompt,
-            model: options?.model ?? sessionContext.model,
-            permissionMode: options?.permissionMode ?? 'bypassPermissions',
-            includePartialMessages: false,
-            thinkingEnabled: options?.thinkingEnabled,
-            initialPrompt: options?.initialPrompt,
-            sessionId,
-        };
         return {
-            clientOptions,
-            context: { workspaceId: sessionContext.workspaceId, workingDir: sessionContext.workingDir },
-            handlers: this.buildClientEventHandlers(),
+            provider,
+            providerSessionId,
+            capturedAt: typeof candidate.capturedAt === 'string' ? candidate.capturedAt : new Date(0).toISOString(),
+            configOptions: configOptions,
+            ...(typeof observedModelId === 'string' ? { observedModelId } : {}),
         };
     }
-    async loadSessionContext(sessionId) {
-        const session = await this.repository.getSessionById(sessionId);
+    resolveObservedModel(configOptions) {
+        const modelOption = configOptions.find((option) => option.category === 'model');
+        const currentValue = modelOption?.currentValue;
+        return currentValue ? String(currentValue) : undefined;
+    }
+    async loadSessionContext(sessionId, preloadedSession) {
+        const session = preloadedSession ?? (await this.repository.getSessionById(sessionId));
         if (!session) {
             logger.warn('Session not found when getting options', { sessionId });
             return null;
@@ -428,7 +1017,7 @@ class SessionService {
         }
         return {
             workingDir: workspace.worktreePath,
-            resumeClaudeSessionId: session.claudeSessionId ?? undefined,
+            resumeProviderSessionId: session.providerSessionId ?? undefined,
             systemPrompt,
             model: session.model,
             workspaceId: workspace.id,