factory-factory 0.3.6 → 0.3.8

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

@@ -1,23 +1,34 @@
-import { AcpEventTranslator, AcpPermissionBridge, acpRuntimeManager, } from '../../../../backend/domains/session/acp/index.js';
+import { AcpEventTranslator, acpRuntimeManager, } from '../../../../backend/domains/session/acp/index.js';
 import { acpTraceLogger } from '../../../../backend/domains/session/logging/acp-trace-logger.service.js';
 import { sessionFileLogger } from '../../../../backend/domains/session/logging/session-file-logger.service.js';
-import { sessionDomainService } from '../../../../backend/domains/session/session-domain.service.js';
+import { sessionDomainService, } from '../../../../backend/domains/session/session-domain.service.js';
 import { interceptorRegistry } from '../../../../backend/interceptors/registry.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 { SessionStatus } from '../../../../shared/core/index.js';
-import { isUserQuestionRequest } from '../../../../shared/pending-request-types.js';
 import { createInitialSessionRuntimeState, } from '../../../../shared/session-runtime.js';
+import { SessionConfigService, } from './session.config.service.js';
+import { SessionPermissionService } from './session.permission.service.js';
 import { sessionPromptBuilder } from './session.prompt-builder.js';
 import { sessionRepository } from './session.repository.js';
 const logger = createLogger('session');
 const STALE_LOADING_RUNTIME_MAX_AGE_MS = 30_000;
-class SessionService {
+function toErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'object') {
+        return JSON.stringify(error);
+    }
+    return String(error);
+}
+export class SessionService {
     repository;
     promptBuilder;
+    runtimeManager;
+    sessionDomainService;
     acpEventTranslator = new AcpEventTranslator(logger);
-    acpPermissionBridges = new Map();
+    sessionPermissionService;
+    sessionConfigService;
     acpStreamState = new Map();
     pendingAcpToolCalls = new Map();
     suppressAcpReplayForSession = new Set();
@@ -42,10 +53,9 @@ class SessionService {
         return Date.now() - updatedAtMs > STALE_LOADING_RUNTIME_MAX_AGE_MS;
     }
     setupAcpEventHandler(sessionId) {
-        const bridge = new AcpPermissionBridge();
-        this.acpPermissionBridges.set(sessionId, bridge);
+        const permissionBridge = this.sessionPermissionService.createPermissionBridge(sessionId);
         return {
-            permissionBridge: bridge,
+            permissionBridge,
             onAcpEvent: (sid, event) => {
                 const typed = event;
                 if (typed.type === 'acp_session_update') {
@@ -72,7 +82,7 @@ class SessionService {
                     return;
                 }
                 if (typed.type === 'acp_permission_request') {
-                    this.handleAcpPermissionRequest(sid, event);
+                    this.sessionPermissionService.handlePermissionRequest(sid, event);
                     return;
                 }
             },
@@ -102,14 +112,10 @@ class SessionService {
                 this.suppressAcpReplayForSession.delete(sid);
                 this.sessionToWorkspace.delete(sid);
                 this.sessionToWorkingDir.delete(sid);
-                const b = this.acpPermissionBridges.get(sid);
-                if (b) {
-                    b.cancelAll();
-                    this.acpPermissionBridges.delete(sid);
-                }
+                this.sessionPermissionService.cancelPendingRequests(sid);
                 acpTraceLogger.log(sid, 'runtime_exit', { exitCode });
                 try {
-                    sessionDomainService.markProcessExit(sid, exitCode);
+                    this.sessionDomainService.markProcessExit(sid, exitCode);
                     const session = await this.repository.updateSession(sid, {
                         status: SessionStatus.COMPLETED,
                     });
@@ -135,6 +141,7 @@ class SessionService {
                     message: error.message,
                     stack: error.stack,
                 });
+                this.sessionDomainService.markError(sid, error.message);
                 logger.error('ACP client error', {
                     sessionId: sid,
                     error: error.message,
@@ -156,25 +163,15 @@ class SessionService {
         }
         this.trackPendingAcpToolCalls(sid, delta);
         if (delta.type === 'config_options_update') {
-            const acpHandle = acpRuntimeManager.getClient(sid);
+            const acpHandle = this.runtimeManager.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),
-                });
+                this.sessionConfigService.applyConfigOptionsUpdateDelta(sid, acpHandle, configOptions);
                 return;
             }
         }
         if (delta.type !== 'agent_message') {
-            sessionDomainService.emitDelta(sid, delta);
+            this.sessionDomainService.emitDelta(sid, delta);
             return;
         }
         const data = delta.data;
@@ -183,8 +180,8 @@ class SessionService {
             return;
         }
         this.acpStreamState.delete(sid);
-        const order = sessionDomainService.appendClaudeEvent(sid, data);
-        sessionDomainService.emitDelta(sid, { ...delta, order });
+        const order = this.sessionDomainService.appendClaudeEvent(sid, data);
+        this.sessionDomainService.emitDelta(sid, { ...delta, order });
     }
     trackPendingAcpToolCalls(sid, delta) {
         if (delta.type === 'agent_message') {
@@ -418,14 +415,14 @@ class SessionService {
         if (this.suppressAcpReplayForSession.has(sid)) {
             return;
         }
-        if (acpRuntimeManager.isSessionWorking(sid)) {
+        if (this.runtimeManager.isSessionWorking(sid)) {
             return;
         }
         const normalized = text.trim();
         if (normalized.length === 0) {
             return;
         }
-        sessionDomainService.injectCommittedUserMessage(sid, normalized);
+        this.sessionDomainService.injectCommittedUserMessage(sid, normalized);
     }
     accumulateAcpText(sid, data) {
         const content = data.message?.content;
@@ -434,7 +431,7 @@ class SessionService {
             : '';
         let ss = this.acpStreamState.get(sid);
         if (!ss) {
-            ss = { textOrder: sessionDomainService.allocateOrder(sid), accText: '' };
+            ss = { textOrder: this.sessionDomainService.allocateOrder(sid), accText: '' };
             this.acpStreamState.set(sid, ss);
         }
         ss.accText += chunkText;
@@ -442,67 +439,13 @@ class SessionService {
             type: 'assistant',
             message: { role: 'assistant', content: [{ type: 'text', text: ss.accText }] },
         };
-        sessionDomainService.upsertClaudeEvent(sid, accMsg, ss.textOrder);
-        sessionDomainService.emitDelta(sid, {
+        this.sessionDomainService.upsertClaudeEvent(sid, accMsg, ss.textOrder);
+        this.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 (isUserQuestionRequest({ toolName, input: toolInput })) {
-            const questions = this.extractAskUserQuestions(toolInput);
-            sessionDomainService.emitDelta(sid, {
-                type: 'user_question',
-                requestId,
-                toolName,
-                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) {
@@ -530,7 +473,7 @@ class SessionService {
         };
         let handle;
         try {
-            handle = await acpRuntimeManager.getOrCreateClient(sessionId, clientOptions, handlers, {
+            handle = await this.runtimeManager.getOrCreateClient(sessionId, clientOptions, handlers, {
                 workspaceId: sessionContext.workspaceId,
                 workingDir: sessionContext.workingDir,
             });
@@ -548,12 +491,12 @@ class SessionService {
             existingMetadata: session?.providerMetadata ?? undefined,
         });
         if (handle.configOptions.length > 0) {
-            sessionDomainService.emitDelta(sessionId, {
+            this.sessionDomainService.emitDelta(sessionId, {
                 type: 'config_options_update',
                 configOptions: handle.configOptions,
             });
         }
-        sessionDomainService.emitDelta(sessionId, {
+        this.sessionDomainService.emitDelta(sessionId, {
             type: 'chat_capabilities',
             capabilities: this.buildAcpChatBarCapabilities(handle),
         });
@@ -563,16 +506,16 @@ class SessionService {
         if (!session?.providerSessionId) {
             return false;
         }
-        if (!sessionDomainService.isHistoryHydrated(sessionId)) {
+        if (!this.sessionDomainService.isHistoryHydrated(sessionId)) {
             return false;
         }
-        return sessionDomainService.getTranscriptSnapshot(sessionId).length > 0;
+        return this.sessionDomainService.getTranscriptSnapshot(sessionId).length > 0;
     }
     maybeLiftReplaySuppression(sessionId) {
         if (!this.suppressAcpReplayForSession.has(sessionId)) {
             return;
         }
-        if (!acpRuntimeManager.isSessionWorking(sessionId)) {
+        if (!this.runtimeManager.isSessionWorking(sessionId)) {
             return;
         }
         this.suppressAcpReplayForSession.delete(sessionId);
@@ -580,129 +523,59 @@ class SessionService {
     constructor(options) {
         this.repository = options?.repository ?? sessionRepository;
         this.promptBuilder = options?.promptBuilder ?? sessionPromptBuilder;
+        this.runtimeManager = options?.runtimeManager ?? acpRuntimeManager;
+        this.sessionDomainService = options?.sessionDomainService ?? sessionDomainService;
+        this.sessionPermissionService = new SessionPermissionService({
+            sessionDomainService: this.sessionDomainService,
+        });
+        this.sessionConfigService = new SessionConfigService({
+            repository: this.repository,
+            runtimeManager: this.runtimeManager,
+            sessionDomainService: this.sessionDomainService,
+        });
     }
     async startSession(sessionId, options) {
         const session = await this.repository.getSessionById(sessionId);
         if (!session) {
             throw new Error(`Session not found: ${sessionId}`);
         }
-        if (acpRuntimeManager.isStopInProgress(sessionId)) {
+        if (this.runtimeManager.isStopInProgress(sessionId)) {
             throw new Error('Session is currently being stopped');
         }
-        const existingClient = acpRuntimeManager.getClient(sessionId);
+        const existingClient = this.runtimeManager.getClient(sessionId);
         if (existingClient) {
             throw new Error('Session is already running');
         }
         const startupModePreset = options?.startupModePreset;
         const startupPermissionMode = startupModePreset === 'plan' ? 'plan' : 'bypassPermissions';
         const handle = await this.getOrCreateAcpSessionClient(sessionId, { permissionMode: startupPermissionMode }, session);
-        await this.applyStartupModePreset(sessionId, handle, startupModePreset);
+        await this.applyStartupModePreset(sessionId, handle, startupModePreset, session.workflow);
+        if (!session.providerSessionId) {
+            await this.applyConfiguredPermissionPreset(sessionId, session, handle);
+        }
         const initialPrompt = options?.initialPrompt ?? 'Continue with the task.';
         if (initialPrompt) {
             await this.sendSessionMessage(sessionId, initialPrompt);
         }
         logger.info('Session started', { sessionId, provider: session.provider });
     }
-    async applyStartupModePreset(sessionId, handle, startupModePreset) {
-        if (!startupModePreset) {
-            return;
-        }
-        const modeOption = handle.configOptions.find((option) => option.category === 'mode');
-        if (!modeOption) {
-            return;
-        }
-        const availableModeValues = this.getConfigOptionValues(modeOption);
-        const targetMode = this.resolveStartupModeTarget(handle.provider, startupModePreset, availableModeValues);
-        if (!targetMode) {
-            logger.debug('Startup mode preset not available in ACP mode options', {
-                sessionId,
-                provider: handle.provider,
-                startupModePreset,
-                availableModeValues,
-            });
-            return;
-        }
-        const currentMode = modeOption.currentValue ? String(modeOption.currentValue) : null;
-        if (currentMode === targetMode) {
-            return;
-        }
-        try {
-            const configOptions = await acpRuntimeManager.setSessionMode(sessionId, targetMode);
-            handle.configOptions = configOptions;
-            await this.persistAcpConfigSnapshot(sessionId, {
-                provider: handle.provider,
-                providerSessionId: handle.providerSessionId,
-                configOptions,
-            });
-            sessionDomainService.emitDelta(sessionId, {
-                type: 'config_options_update',
-                configOptions,
-            });
-            sessionDomainService.emitDelta(sessionId, {
-                type: 'chat_capabilities',
-                capabilities: this.buildAcpChatBarCapabilities(handle),
-            });
-        }
-        catch (error) {
-            logger.warn('Failed applying startup mode preset', {
-                sessionId,
-                provider: handle.provider,
-                startupModePreset,
-                targetMode,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    resolveStartupModeTarget(provider, startupModePreset, availableModeValues) {
-        if (availableModeValues.length === 0) {
-            return null;
-        }
-        if (startupModePreset === 'plan') {
-            return this.findModeValue(availableModeValues, ['plan']);
-        }
-        if (provider === 'CLAUDE') {
-            return this.findModeValue(availableModeValues, [
-                'bypassPermissions',
-                'dangerouslySkipPermissions',
-                'dangerousSkipPermissions',
-                'acceptEdits',
-            ]);
-        }
-        return this.findModeValue(availableModeValues, [
-            'fullAccess',
-            'full_access',
-            'full-access',
-            'code',
-        ]);
-    }
-    findModeValue(availableModeValues, preferredModeValues) {
-        if (availableModeValues.length === 0 || preferredModeValues.length === 0) {
-            return null;
-        }
-        const availableByNormalized = new Map();
-        for (const value of availableModeValues) {
-            availableByNormalized.set(this.normalizeModeValue(value), value);
-        }
-        for (const preferredValue of preferredModeValues) {
-            const match = availableByNormalized.get(this.normalizeModeValue(preferredValue));
-            if (match) {
-                return match;
-            }
-        }
-        return null;
+    async applyStartupModePreset(sessionId, handle, startupModePreset, workflow) {
+        await this.sessionConfigService.applyStartupModePreset(sessionId, handle, startupModePreset, workflow, {
+            persistSnapshot: this.persistAcpConfigSnapshot.bind(this),
+        });
     }
-    normalizeModeValue(value) {
-        return value.replace(/[^a-z0-9]/gi, '').toLowerCase();
+    async applyConfiguredPermissionPreset(sessionId, session, handle) {
+        await this.sessionConfigService.applyConfiguredPermissionPreset(sessionId, session, handle);
     }
     async stopSession(sessionId, options) {
         const session = await this.loadSessionForStop(sessionId);
         const workspaceId = session?.workspaceId ?? this.sessionToWorkspace.get(sessionId);
-        if (acpRuntimeManager.isStopInProgress(sessionId)) {
+        if (this.runtimeManager.isStopInProgress(sessionId)) {
             logger.debug('Session stop already in progress', { sessionId });
             return;
         }
         const current = this.getRuntimeSnapshot(sessionId);
-        sessionDomainService.setRuntimeSnapshot(sessionId, {
+        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
             ...current,
             phase: 'stopping',
             activity: 'IDLE',
@@ -710,15 +583,11 @@ class SessionService {
         });
         this.acpStreamState.delete(sessionId);
         this.suppressAcpReplayForSession.delete(sessionId);
-        const acpBridge = this.acpPermissionBridges.get(sessionId);
-        if (acpBridge) {
-            acpBridge.cancelAll();
-            this.acpPermissionBridges.delete(sessionId);
-        }
+        this.sessionPermissionService.cancelPendingRequests(sessionId);
         let stopClientFailed = false;
         try {
-            if (!acpRuntimeManager.isStopInProgress(sessionId)) {
-                await acpRuntimeManager.stopClient(sessionId);
+            if (!this.runtimeManager.isStopInProgress(sessionId)) {
+                await this.runtimeManager.stopClient(sessionId);
             }
         }
         catch (error) {
@@ -731,8 +600,8 @@ class SessionService {
         finally {
             this.finalizeOrphanedToolCallsOnStop(sessionId);
             await this.updateStoppedSessionState(sessionId);
-            sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: true });
-            sessionDomainService.setRuntimeSnapshot(sessionId, {
+            this.sessionDomainService.clearQueuedWork(sessionId, { emitSnapshot: true });
+            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'idle',
                 processState: 'stopped',
                 activity: 'IDLE',
@@ -836,7 +705,7 @@ class SessionService {
         const sessions = await this.repository.getSessionsByWorkspaceId(workspaceId);
         for (const session of sessions) {
             if (session.status === SessionStatus.RUNNING ||
-                acpRuntimeManager.isSessionRunning(session.id)) {
+                this.runtimeManager.isSessionRunning(session.id)) {
                 try {
                     await this.stopSession(session.id);
                 }
@@ -856,152 +725,51 @@ class SessionService {
         if (!session) {
             throw new Error(`Session not found: ${sessionId}`);
         }
-        return await this.getOrCreateAcpSessionClient(sessionId, options ?? {}, session);
+        const hadClient = !!this.runtimeManager.getClient(sessionId);
+        const handle = await this.getOrCreateAcpSessionClient(sessionId, options ?? {}, session);
+        if (!(hadClient || session.providerSessionId)) {
+            await this.applyConfiguredPermissionPreset(sessionId, session, handle);
+        }
+        return handle;
     }
     async getOrCreateSessionClientFromRecord(session, options) {
-        return await this.getOrCreateAcpSessionClient(session.id, options ?? {}, session);
+        const hadClient = !!this.runtimeManager.getClient(session.id);
+        const handle = await this.getOrCreateAcpSessionClient(session.id, options ?? {}, session);
+        if (!(hadClient || session.providerSessionId)) {
+            await this.applyConfiguredPermissionPreset(session.id, session, handle);
+        }
+        return handle;
     }
     getSessionClient(sessionId) {
-        return acpRuntimeManager.getClient(sessionId);
+        return this.runtimeManager.getClient(sessionId);
     }
     getSessionConfigOptions(sessionId) {
-        const acpHandle = acpRuntimeManager.getClient(sessionId);
-        return acpHandle ? [...acpHandle.configOptions] : [];
+        return this.sessionConfigService.getSessionConfigOptions(sessionId);
     }
-    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 [];
+    getSessionConfigOptionsWithFallback(sessionId) {
+        return this.sessionConfigService.getSessionConfigOptionsWithFallback(sessionId);
     }
     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 });
+        await this.sessionConfigService.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 });
+        await this.sessionConfigService.setSessionThinkingBudget(sessionId, maxTokens);
     }
     async setSessionConfigOption(sessionId, configId, value) {
-        const acpHandle = acpRuntimeManager.getClient(sessionId);
-        if (!acpHandle) {
-            const configOptions = await this.setCachedSessionConfigOption(sessionId, configId, value);
-            sessionDomainService.emitDelta(sessionId, {
-                type: 'config_options_update',
-                configOptions,
-            });
-            return;
-        }
-        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,
-            });
-        }
-    }
-    async setCachedSessionConfigOption(sessionId, configId, value) {
-        const session = await this.repository.getSessionById(sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${sessionId}`);
-        }
-        const snapshot = this.extractAcpConfigSnapshot(session.providerMetadata);
-        if (!snapshot || snapshot.provider !== session.provider) {
-            throw new Error(`Cannot set config option for inactive session ${sessionId}: no cached ACP config available`);
-        }
-        const configOptions = this.updateCachedConfigOptions(snapshot.configOptions, configId, value);
-        await this.persistAcpConfigSnapshot(sessionId, {
-            provider: snapshot.provider,
-            providerSessionId: snapshot.providerSessionId,
-            configOptions,
-            existingMetadata: session.providerMetadata,
-        });
-        return configOptions;
-    }
-    updateCachedConfigOptions(configOptions, configId, value) {
-        let didUpdate = false;
-        const nextConfigOptions = configOptions.map((option) => {
-            if (option.id !== configId) {
-                return option;
-            }
-            const allowedValues = this.getConfigOptionValues(option);
-            if (allowedValues.length > 0 && !allowedValues.includes(value)) {
-                throw new Error(`Unsupported value "${value}" for config option "${configId}"` +
-                    ` (allowed: ${allowedValues.join(', ')})`);
-            }
-            didUpdate = true;
-            return {
-                ...option,
-                currentValue: value,
-            };
-        });
-        if (!didUpdate) {
-            throw new Error(`Unknown config option: ${configId}`);
-        }
-        return nextConfigOptions;
+        await this.sessionConfigService.setSessionConfigOption(sessionId, configId, value);
     }
     sendSessionMessage(sessionId, content) {
-        const acpClient = acpRuntimeManager.getClient(sessionId);
+        const acpClient = this.runtimeManager.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),
+                    error: toErrorMessage(error),
                 });
             });
         }
@@ -1038,7 +806,7 @@ class SessionService {
     async sendAcpMessage(sessionId, content) {
         const workspaceId = this.sessionToWorkspace.get(sessionId);
         this.pendingAcpToolCalls.set(sessionId, new Map());
-        sessionDomainService.setRuntimeSnapshot(sessionId, {
+        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
             phase: 'running',
             processState: 'alive',
             activity: 'WORKING',
@@ -1048,9 +816,9 @@ class SessionService {
             this.workspaceBridge.markSessionRunning(workspaceId, sessionId);
         }
         try {
-            const result = await acpRuntimeManager.sendPrompt(sessionId, content);
+            const result = await this.runtimeManager.sendPrompt(sessionId, content);
             this.finalizeOrphanedToolCalls(sessionId, `stop_reason:${result.stopReason}`);
-            sessionDomainService.setRuntimeSnapshot(sessionId, {
+            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'idle',
                 processState: 'alive',
                 activity: 'IDLE',
@@ -1060,10 +828,11 @@ class SessionService {
         }
         catch (error) {
             this.finalizeOrphanedToolCalls(sessionId, 'prompt_error');
-            sessionDomainService.setRuntimeSnapshot(sessionId, {
+            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'error',
                 processState: 'alive',
                 activity: 'IDLE',
+                errorMessage: toErrorMessage(error),
                 updatedAt: new Date().toISOString(),
             });
             throw error;
@@ -1098,10 +867,10 @@ class SessionService {
         }
     }
     async cancelAcpPrompt(sessionId) {
-        await acpRuntimeManager.cancelPrompt(sessionId);
+        await this.runtimeManager.cancelPrompt(sessionId);
     }
     getSessionConversationHistory(sessionId, _workingDir) {
-        const transcript = sessionDomainService.getTranscriptSnapshot(sessionId);
+        const transcript = this.sessionDomainService.getTranscriptSnapshot(sessionId);
         return transcript.flatMap((entry) => this.mapTranscriptEntryToHistory(entry));
     }
     mapTranscriptEntryToHistory(entry) {
@@ -1147,19 +916,15 @@ class SessionService {
             .trim();
     }
     respondToAcpPermission(sessionId, requestId, optionId, answers) {
-        const bridge = this.acpPermissionBridges.get(sessionId);
-        if (!bridge) {
-            return false;
-        }
-        return bridge.resolvePermission(requestId, optionId, answers);
+        return this.sessionPermissionService.respondToPermission(sessionId, requestId, optionId, answers);
     }
     getRuntimeSnapshot(sessionId) {
         const fallback = createInitialSessionRuntimeState();
-        const persisted = sessionDomainService.getRuntimeSnapshot(sessionId);
+        const persisted = this.sessionDomainService.getRuntimeSnapshot(sessionId);
         const base = persisted ?? fallback;
-        const acpClient = acpRuntimeManager.getClient(sessionId);
+        const acpClient = this.runtimeManager.getClient(sessionId);
         if (acpClient) {
-            const isWorking = acpRuntimeManager.isSessionWorking(sessionId);
+            const isWorking = this.runtimeManager.isSessionWorking(sessionId);
             return {
                 phase: isWorking ? 'running' : 'idle',
                 processState: 'alive',
@@ -1167,7 +932,7 @@ class SessionService {
                 updatedAt: base.updatedAt,
             };
         }
-        if (acpRuntimeManager.isStopInProgress(sessionId)) {
+        if (this.runtimeManager.isStopInProgress(sessionId)) {
             return {
                 ...base,
                 phase: 'stopping',
@@ -1186,9 +951,9 @@ class SessionService {
         return base;
     }
     async getOrCreateAcpSessionClient(sessionId, options, session) {
-        const existingAcp = acpRuntimeManager.getClient(sessionId);
+        const existingAcp = this.runtimeManager.getClient(sessionId);
         if (existingAcp) {
-            sessionDomainService.setRuntimeSnapshot(sessionId, {
+            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: existingAcp.isPromptInFlight ? 'running' : 'idle',
                 processState: 'alive',
                 activity: existingAcp.isPromptInFlight ? 'WORKING' : 'IDLE',
@@ -1196,17 +961,30 @@ class SessionService {
             });
             return existingAcp;
         }
-        sessionDomainService.setRuntimeSnapshot(sessionId, {
+        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
             phase: 'starting',
             processState: 'alive',
             activity: 'IDLE',
             updatedAt: new Date().toISOString(),
         });
-        const handle = await this.createAcpClient(sessionId, options, session);
+        let handle;
+        try {
+            handle = await this.createAcpClient(sessionId, options, session);
+        }
+        catch (error) {
+            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
+                phase: 'error',
+                processState: 'stopped',
+                activity: 'IDLE',
+                errorMessage: `Failed to start agent: ${toErrorMessage(error)}`,
+                updatedAt: new Date().toISOString(),
+            });
+            throw error;
+        }
         await this.repository.updateSession(sessionId, {
             status: SessionStatus.RUNNING,
         });
-        sessionDomainService.setRuntimeSnapshot(sessionId, {
+        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
             phase: handle.isPromptInFlight ? 'running' : 'idle',
             processState: 'alive',
             activity: handle.isPromptInFlight ? 'WORKING' : 'IDLE',
@@ -1215,13 +993,13 @@ class SessionService {
         return handle;
     }
     isSessionRunning(sessionId) {
-        return acpRuntimeManager.isSessionRunning(sessionId);
+        return this.runtimeManager.isSessionRunning(sessionId);
     }
     isSessionWorking(sessionId) {
-        return acpRuntimeManager.isSessionWorking(sessionId);
+        return this.runtimeManager.isSessionWorking(sessionId);
     }
     isAnySessionWorking(sessionIds) {
-        return acpRuntimeManager.isAnySessionWorking(sessionIds);
+        return this.runtimeManager.isAnySessionWorking(sessionIds);
     }
     async getSessionOptions(sessionId) {
         const sessionContext = await this.loadSessionContext(sessionId);
@@ -1235,121 +1013,15 @@ class SessionService {
             model: sessionContext.model,
         };
     }
-    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;
+    getChatBarCapabilities(sessionId) {
+        return this.sessionConfigService.getChatBarCapabilities(sessionId);
     }
     buildAcpChatBarCapabilities(handle) {
-        return this.buildCapabilitiesFromConfigOptions(handle.provider, handle.configOptions);
-    }
-    buildCapabilitiesFromConfigOptions(provider, configOptions, fallbackModel) {
-        const modelOption = configOptions.find((o) => o.category === 'model');
-        const modeOption = configOptions.find((o) => o.category === 'mode');
-        const thoughtOption = configOptions.find((o) => o.category === 'thought_level' || o.id === 'reasoning_effort' || o.category === 'reasoning');
-        const selectedModel = modelOption?.currentValue
-            ? String(modelOption.currentValue)
-            : (fallbackModel ?? undefined);
-        const modelOptions = this.buildModelOptions(modelOption, selectedModel);
-        const isCodexProvider = provider === 'CODEX';
-        const reasoningOptions = isCodexProvider && thoughtOption
-            ? this.getSelectOptions(thoughtOption).map((option) => ({
-                value: option.value,
-                label: option.name ?? option.value,
-                ...(option.description ? { description: option.description } : {}),
-            }))
-            : [];
-        const reasoningValues = new Set(reasoningOptions.map((option) => option.value));
-        const selectedReasoning = isCodexProvider &&
-            thoughtOption?.currentValue &&
-            typeof thoughtOption.currentValue === 'string' &&
-            reasoningValues.has(thoughtOption.currentValue)
-            ? thoughtOption.currentValue
-            : undefined;
-        const modeDescriptors = modeOption
-            ? [
-                ...this.getConfigOptionValues(modeOption),
-                ...this.getSelectOptions(modeOption)
-                    .map((entry) => entry.name ?? '')
-                    .filter((value) => value.trim().length > 0),
-            ]
-            : [];
-        const planModeEnabled = modeDescriptors.some((entry) => /plan/i.test(entry));
-        return {
-            provider,
-            model: {
-                enabled: modelOptions.length > 0,
-                options: modelOptions,
-                ...(selectedModel ? { selected: selectedModel } : {}),
-            },
-            reasoning: {
-                enabled: reasoningOptions.length > 0,
-                options: reasoningOptions,
-                ...(selectedReasoning ? { selected: selectedReasoning } : {}),
-            },
-            thinking: {
-                enabled: !isCodexProvider && !!thoughtOption,
-            },
-            planMode: { enabled: planModeEnabled },
-            attachments: isCodexProvider
-                ? { enabled: false, kinds: [] }
-                : { enabled: true, kinds: ['image', 'text'] },
-            slashCommands: { enabled: false },
-            usageStats: { enabled: false, contextWindow: false },
-            rewind: { enabled: false },
-        };
-    }
-    buildModelOptions(modelOption, selectedModel) {
-        if (!modelOption) {
-            return selectedModel ? [{ value: selectedModel, label: selectedModel }] : [];
-        }
-        const byValue = new Map();
-        for (const option of this.getSelectOptions(modelOption)) {
-            if (!byValue.has(option.value)) {
-                byValue.set(option.value, option.name ?? option.value);
-            }
-        }
-        if (selectedModel && !byValue.has(selectedModel)) {
-            byValue.set(selectedModel, selectedModel);
-        }
-        return Array.from(byValue.entries()).map(([value, label]) => ({ value, label }));
-    }
-    getSelectOptions(option) {
-        return option.options.flatMap((entry) => {
-            if (typeof entry !== 'object' || entry === null) {
-                return [];
-            }
-            if ('value' in entry && typeof entry.value === 'string') {
-                return [entry];
-            }
-            if ('options' in entry && Array.isArray(entry.options)) {
-                return entry.options.filter((grouped) => typeof grouped === 'object' && grouped !== null && typeof grouped.value === 'string');
-            }
-            return [];
-        });
-    }
-    getConfigOptionValues(option) {
-        return this.getSelectOptions(option).map((entry) => entry.value);
+        return this.sessionConfigService.buildAcpChatBarCapabilities(handle);
     }
     async stopAllClients(_timeoutMs = 5000) {
         try {
-            await acpRuntimeManager.stopAllClients();
+            await this.runtimeManager.stopAllClients();
         }
         catch (error) {
             logger.error('Failed to stop ACP clients during shutdown', {
@@ -1359,105 +1031,7 @@ class SessionService {
         }
     }
     async persistAcpConfigSnapshot(sessionId, params) {
-        if (params.configOptions.length === 0) {
-            return;
-        }
-        const configOptionsForStorage = this.cloneConfigOptionsForStorage(params.configOptions);
-        const observedModelId = this.resolveObservedModel(configOptionsForStorage);
-        const metadataSource = params.existingMetadata ??
-            (await this.repository.getSessionById(sessionId))?.providerMetadata ??
-            null;
-        const snapshot = {
-            provider: params.provider,
-            providerSessionId: params.providerSessionId,
-            capturedAt: new Date().toISOString(),
-            configOptions: configOptionsForStorage,
-            ...(observedModelId ? { observedModelId } : {}),
-        };
-        const persistedUpdate = this.buildSnapshotPersistUpdate(metadataSource, snapshot, observedModelId);
-        try {
-            await this.repository.updateSession(sessionId, persistedUpdate);
-        }
-        catch (error) {
-            logger.warn('Failed persisting ACP config snapshot to session metadata; retrying once', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            await this.retryPersistAcpConfigSnapshot(sessionId, snapshot, observedModelId);
-        }
-    }
-    buildSnapshotPersistUpdate(metadataSource, snapshot, observedModelId) {
-        const nextMetadata = {
-            ...this.toMetadataRecord(metadataSource),
-            acpConfigSnapshot: snapshot,
-        };
-        if (observedModelId) {
-            nextMetadata.observedModelId = observedModelId;
-        }
-        return {
-            providerMetadata: nextMetadata,
-            ...(observedModelId ? { model: observedModelId } : {}),
-        };
-    }
-    async retryPersistAcpConfigSnapshot(sessionId, snapshot, observedModelId) {
-        try {
-            const latestMetadataSource = (await this.repository.getSessionById(sessionId))
-                ?.providerMetadata;
-            await this.repository.updateSession(sessionId, this.buildSnapshotPersistUpdate(latestMetadataSource, snapshot, observedModelId));
-        }
-        catch (retryError) {
-            logger.warn('Retry failed persisting ACP config snapshot to session metadata', {
-                sessionId,
-                error: retryError instanceof Error ? retryError.message : String(retryError),
-            });
-        }
-    }
-    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;
-        }
-        return {
-            provider,
-            providerSessionId,
-            capturedAt: typeof candidate.capturedAt === 'string' ? candidate.capturedAt : new Date(0).toISOString(),
-            configOptions: configOptions,
-            ...(typeof observedModelId === 'string' ? { observedModelId } : {}),
-        };
-    }
-    resolveObservedModel(configOptions) {
-        const modelOption = configOptions.find((option) => option.category === 'model');
-        const currentValue = modelOption?.currentValue;
-        return currentValue ? String(currentValue) : undefined;
+        await this.sessionConfigService.persistAcpConfigSnapshot(sessionId, params);
     }
     async loadSessionContext(sessionId, preloadedSession) {
         const session = preloadedSession ?? (await this.repository.getSessionById(sessionId));
@@ -1520,5 +1094,8 @@ class SessionService {
         };
     }
 }
-export const sessionService = new SessionService();
+export function createSessionService(options) {
+    return new SessionService(options);
+}
+export const sessionService = createSessionService();
 //# sourceMappingURL=session.service.js.map