factory-factory 0.3.7 → 0.3.9

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

@@ -1,15 +1,12 @@
-import { AcpEventTranslator, AcpPermissionBridge, acpRuntimeManager, } from '../../../../backend/domains/session/acp/index.js';
+import { 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 { interceptorRegistry } from '../../../../backend/interceptors/registry.js';
-import { userSettingsAccessor } from '../../../../backend/resource_accessors/user-settings.accessor.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 { SessionStatus } from '../../../../shared/core/index.js';
-import { isUserQuestionRequest } from '../../../../shared/pending-request-types.js';
 import { createInitialSessionRuntimeState, } from '../../../../shared/session-runtime.js';
+import { AcpEventProcessor } from './acp-event-processor.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');
@@ -23,23 +20,25 @@ function toErrorMessage(error) {
     }
     return String(error);
 }
-class SessionService {
+export class SessionService {
     repository;
     promptBuilder;
-    acpEventTranslator = new AcpEventTranslator(logger);
-    acpPermissionBridges = new Map();
-    acpStreamState = new Map();
-    pendingAcpToolCalls = new Map();
-    suppressAcpReplayForSession = new Set();
+    runtimeManager;
+    sessionDomainService;
+    sessionPermissionService;
+    sessionConfigService;
+    acpEventProcessor;
     workspaceBridge = null;
-    sessionToWorkspace = new Map();
-    sessionToWorkingDir = new Map();
     promptTurnCompleteHandler = null;
+    promptTurnCompleteTimeouts = new Map();
     configure(bridges) {
         this.workspaceBridge = bridges.workspace;
     }
     setPromptTurnCompleteHandler(handler) {
         this.promptTurnCompleteHandler = handler;
+        if (!handler) {
+            this.clearAllScheduledPromptTurnCompletions();
+        }
     }
     isStaleLoadingRuntime(runtime) {
         if (runtime.phase !== 'loading' || runtime.processState === 'alive') {
@@ -52,40 +51,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 runtimeEventHandler = this.acpEventProcessor.createRuntimeEventHandler(sessionId);
         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);
-                    if (deltas.length === 0) {
-                        acpTraceLogger.log(sid, 'translated_delta', {
-                            sessionUpdate: update.sessionUpdate,
-                            deltaCount: 0,
-                        });
-                    }
-                    for (const [index, delta] of deltas.entries()) {
-                        acpTraceLogger.log(sid, 'translated_delta', {
-                            sessionUpdate: update.sessionUpdate,
-                            deltaIndex: index,
-                            delta,
-                        });
-                        this.handleAcpDelta(sid, delta);
-                    }
-                    return;
-                }
-                if (typed.type === 'acp_permission_request') {
-                    this.handleAcpPermissionRequest(sid, event);
-                    return;
-                }
-            },
+            ...runtimeEventHandler,
             onSessionId: async (sid, providerSessionId) => {
                 try {
                     await this.repository.updateSession(sid, { providerSessionId });
@@ -107,24 +75,17 @@ class SessionService {
                 }
             },
             onExit: async (sid, exitCode) => {
-                this.acpStreamState.delete(sid);
-                this.pendingAcpToolCalls.delete(sid);
-                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.clearScheduledPromptTurnCompletion(sid);
+                this.acpEventProcessor.clearSessionState(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,
                     });
                     logger.debug('Updated ACP session status to COMPLETED on exit', { sessionId: sid });
-                    await this.repository.clearRatchetActiveSession(session.workspaceId, sid);
+                    await this.clearRatchetActiveSessionIfMatching(session.workspaceId, sid);
                     if (session.workflow === 'ratchet') {
                         await this.repository.deleteSession(sid);
                         logger.debug('Deleted transient ratchet ACP session', { sessionId: sid });
@@ -145,7 +106,7 @@ class SessionService {
                     message: error.message,
                     stack: error.stack,
                 });
-                sessionDomainService.markError(sid, error.message);
+                this.sessionDomainService.markError(sid, error.message);
                 logger.error('ACP client error', {
                     sessionId: sid,
                     error: error.message,
@@ -153,366 +114,9 @@ class SessionService {
                 });
             },
             onAcpLog: (sid, payload) => {
-                acpTraceLogger.log(sid, 'raw_acp_event', 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;
-        }
-        this.trackPendingAcpToolCalls(sid, delta);
-        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 });
-    }
-    trackPendingAcpToolCalls(sid, delta) {
-        if (delta.type === 'agent_message') {
-            this.trackPendingFromAgentMessage(sid, delta.data);
-            return;
-        }
-        if (delta.type === 'tool_progress') {
-            this.trackPendingFromToolProgress(sid, delta);
-        }
-    }
-    trackPendingFromAgentMessage(sid, data) {
-        if (data.type === 'stream_event') {
-            this.trackPendingFromToolUseStreamEvent(sid, data);
-        }
-        if (data.type !== 'user') {
-            return;
-        }
-        this.clearPendingFromToolResultMessage(sid, data);
-    }
-    trackPendingFromToolUseStreamEvent(sid, data) {
-        const streamEvent = data.event;
-        const contentBlock = streamEvent?.content_block;
-        const isToolUse = streamEvent?.type === 'content_block_start' && contentBlock?.type === 'tool_use';
-        if (!isToolUse) {
-            return;
-        }
-        const toolUseId = typeof contentBlock?.id === 'string' ? contentBlock.id : null;
-        if (!toolUseId) {
-            return;
-        }
-        const toolName = typeof contentBlock?.name === 'string' ? contentBlock.name : 'ACP Tool';
-        const toolInput = this.normalizeToolInput(contentBlock?.input);
-        const existing = this.getPendingToolCall(sid, toolUseId);
-        this.upsertPendingToolCall(sid, toolUseId, { toolName, toolInput });
-        if (!existing) {
-            this.notifyInterceptorToolStart(sid, {
-                toolUseId,
-                toolName,
-                toolInput: toolInput ?? {},
-            });
-        }
-    }
-    clearPendingFromToolResultMessage(sid, data) {
-        if (data.type !== 'user') {
-            return;
-        }
-        const content = data.message?.content;
-        if (!Array.isArray(content)) {
-            return;
-        }
-        for (const item of content) {
-            if (item.type === 'tool_result') {
-                const pending = this.getPendingToolCall(sid, item.tool_use_id);
-                this.notifyInterceptorToolComplete(sid, item.tool_use_id, item.content, item.is_error === true, pending);
-                this.removePendingToolCall(sid, item.tool_use_id);
-            }
-        }
-    }
-    trackPendingFromToolProgress(sid, progress) {
-        if (!progress.tool_use_id) {
-            return;
-        }
-        const existing = this.getPendingToolCall(sid, progress.tool_use_id);
-        this.upsertPendingToolCall(sid, progress.tool_use_id, {
-            toolName: progress.tool_name ?? 'ACP Tool',
-            acpKind: progress.acpKind,
-            acpLocations: progress.acpLocations,
-        });
-        if (!existing) {
-            this.notifyInterceptorToolStart(sid, {
-                toolUseId: progress.tool_use_id,
-                toolName: progress.tool_name ?? 'ACP Tool',
-                toolInput: {},
-            });
-        }
-    }
-    upsertPendingToolCall(sid, toolUseId, update) {
-        const pendingById = this.pendingAcpToolCalls.get(sid) ?? new Map();
-        const existing = pendingById.get(toolUseId);
-        pendingById.set(toolUseId, {
-            toolUseId,
-            toolName: update.toolName || existing?.toolName || 'ACP Tool',
-            toolInput: update.toolInput ?? existing?.toolInput,
-            acpKind: update.acpKind ?? existing?.acpKind,
-            acpLocations: update.acpLocations ?? existing?.acpLocations,
-        });
-        this.pendingAcpToolCalls.set(sid, pendingById);
-    }
-    getPendingToolCall(sid, toolUseId) {
-        return this.pendingAcpToolCalls.get(sid)?.get(toolUseId);
-    }
-    removePendingToolCall(sid, toolUseId) {
-        const pendingById = this.pendingAcpToolCalls.get(sid);
-        if (!pendingById) {
-            return;
-        }
-        pendingById.delete(toolUseId);
-        if (pendingById.size === 0) {
-            this.pendingAcpToolCalls.delete(sid);
-        }
-    }
-    normalizeToolInput(input) {
-        if (typeof input !== 'object' || input === null || Array.isArray(input)) {
-            return undefined;
-        }
-        return input;
-    }
-    extractToolResultText(content) {
-        if (typeof content === 'string') {
-            return content;
-        }
-        if (Array.isArray(content)) {
-            return content
-                .flatMap((item) => {
-                if (typeof item === 'object' &&
-                    item !== null &&
-                    item.type === 'text' &&
-                    typeof item.text === 'string') {
-                    return [item.text];
-                }
-                return [];
-            })
-                .join('\n');
-        }
-        if (content === undefined || content === null) {
-            return '';
-        }
-        try {
-            return JSON.stringify(content);
-        }
-        catch {
-            return String(content);
-        }
-    }
-    getInterceptorContext(sessionId) {
-        const workspaceId = this.sessionToWorkspace.get(sessionId);
-        const workingDir = this.sessionToWorkingDir.get(sessionId);
-        if (!(workspaceId && workingDir)) {
-            return null;
-        }
-        return {
-            sessionId,
-            workspaceId,
-            workingDir,
-            timestamp: new Date(),
-        };
-    }
-    notifyInterceptorToolStart(sessionId, tool) {
-        const context = this.getInterceptorContext(sessionId);
-        if (!context) {
-            return;
-        }
-        const event = {
-            toolUseId: tool.toolUseId,
-            toolName: tool.toolName,
-            input: tool.toolInput,
-        };
-        interceptorRegistry.notifyToolStart(event, context);
-    }
-    notifyInterceptorToolComplete(sessionId, toolUseId, content, isError, pending) {
-        const context = this.getInterceptorContext(sessionId);
-        if (!context) {
-            return;
-        }
-        const event = {
-            toolUseId,
-            toolName: pending?.toolName ?? 'ACP Tool',
-            input: pending?.toolInput ?? {},
-            output: {
-                content: this.extractToolResultText(content),
-                isError,
+                this.acpEventProcessor.handleAcpLog(sid, payload);
             },
         };
-        interceptorRegistry.notifyToolComplete(event, context);
-    }
-    finalizeOrphanedToolCalls(sid, reason) {
-        const pendingById = this.pendingAcpToolCalls.get(sid);
-        if (!pendingById || pendingById.size === 0) {
-            this.pendingAcpToolCalls.delete(sid);
-            return;
-        }
-        const toolUseIds = [...pendingById.keys()];
-        logger.warn('Finalizing orphaned ACP tool calls without terminal status', {
-            sessionId: sid,
-            reason,
-            count: toolUseIds.length,
-            toolUseIds,
-        });
-        for (const pending of pendingById.values()) {
-            const syntheticProgress = {
-                type: 'tool_progress',
-                tool_use_id: pending.toolUseId,
-                tool_name: pending.toolName,
-                acpStatus: 'failed',
-                elapsed_time_seconds: 0,
-                ...(pending.acpKind ? { acpKind: pending.acpKind } : {}),
-                ...(pending.acpLocations ? { acpLocations: pending.acpLocations } : {}),
-            };
-            this.handleAcpDelta(sid, syntheticProgress);
-            const syntheticResult = {
-                type: 'agent_message',
-                data: {
-                    type: 'user',
-                    message: {
-                        role: 'user',
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: pending.toolUseId,
-                                content: `Tool call did not receive a terminal ACP update (${reason}). Marked as failed locally.`,
-                                is_error: true,
-                            },
-                        ],
-                    },
-                },
-            };
-            this.handleAcpDelta(sid, syntheticResult);
-            acpTraceLogger.log(sid, 'translated_delta', {
-                sessionUpdate: 'synthetic_orphan_tool_call',
-                delta: syntheticProgress,
-            });
-            acpTraceLogger.log(sid, 'translated_delta', {
-                sessionUpdate: 'synthetic_orphan_tool_call',
-                delta: syntheticResult,
-            });
-        }
-        this.pendingAcpToolCalls.delete(sid);
-    }
-    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 (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);
@@ -520,16 +124,13 @@ class SessionService {
             throw new Error(`Session context not ready: ${sessionId}`);
         }
         await this.repository.markWorkspaceHasHadSessions(sessionContext.workspaceId);
-        this.sessionToWorkspace.set(sessionId, sessionContext.workspaceId);
-        this.sessionToWorkingDir.set(sessionId, sessionContext.workingDir);
+        this.acpEventProcessor.registerSessionContext(sessionId, {
+            workspaceId: sessionContext.workspaceId,
+            workingDir: sessionContext.workingDir,
+        });
         const handlers = this.setupAcpEventHandler(sessionId);
         const shouldSuppressReplay = this.shouldSuppressReplayDuringAcpResume(sessionId, session);
-        if (shouldSuppressReplay) {
-            this.suppressAcpReplayForSession.add(sessionId);
-        }
-        else {
-            this.suppressAcpReplayForSession.delete(sessionId);
-        }
+        this.acpEventProcessor.setReplaySuppression(sessionId, shouldSuppressReplay);
         const clientOptions = {
             provider: session?.provider ?? 'CLAUDE',
             workingDir: sessionContext.workingDir,
@@ -541,15 +142,13 @@ 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,
             });
         }
         catch (error) {
-            this.suppressAcpReplayForSession.delete(sessionId);
-            this.sessionToWorkspace.delete(sessionId);
-            this.sessionToWorkingDir.delete(sessionId);
+            this.acpEventProcessor.clearSessionState(sessionId);
             throw error;
         }
         await this.persistAcpConfigSnapshot(sessionId, {
@@ -559,12 +158,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),
         });
@@ -574,33 +173,40 @@ class SessionService {
         if (!session?.providerSessionId) {
             return false;
         }
-        if (!sessionDomainService.isHistoryHydrated(sessionId)) {
+        if (!this.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);
+        return this.sessionDomainService.getTranscriptSnapshot(sessionId).length > 0;
     }
     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,
+        });
+        this.acpEventProcessor = new AcpEventProcessor({
+            runtimeManager: this.runtimeManager,
+            sessionDomainService: this.sessionDomainService,
+            sessionPermissionService: this.sessionPermissionService,
+            sessionConfigService: this.sessionConfigService,
+        });
     }
     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');
         }
@@ -618,295 +224,35 @@ class SessionService {
         logger.info('Session started', { sessionId, provider: session.provider });
     }
     async applyStartupModePreset(sessionId, handle, startupModePreset, workflow) {
-        if (!startupModePreset) {
-            return;
-        }
-        const modeResult = await this.applyStartupCollaborationModePreset({
-            sessionId,
-            handle,
-            startupModePreset,
-            workflow,
-            configOptions: handle.configOptions,
+        await this.sessionConfigService.applyStartupModePreset(sessionId, handle, startupModePreset, workflow, {
+            persistSnapshot: this.persistAcpConfigSnapshot.bind(this),
         });
-        const executionResult = await this.applyStartupExecutionModePreset({
-            sessionId,
-            handle,
-            startupModePreset,
-            workflow,
-            configOptions: modeResult.configOptions,
-        });
-        const didUpdate = modeResult.didUpdate || executionResult.didUpdate;
-        if (!didUpdate) {
-            return;
-        }
-        handle.configOptions = executionResult.configOptions;
-        try {
-            await this.persistAcpConfigSnapshot(sessionId, {
-                provider: handle.provider,
-                providerSessionId: handle.providerSessionId,
-                configOptions: executionResult.configOptions,
-            });
-            sessionDomainService.emitDelta(sessionId, {
-                type: 'config_options_update',
-                configOptions: executionResult.configOptions,
-            });
-            sessionDomainService.emitDelta(sessionId, {
-                type: 'chat_capabilities',
-                capabilities: this.buildAcpChatBarCapabilities(handle),
-            });
-        }
-        catch (error) {
-            logger.warn('Failed persisting startup mode preset configuration snapshot', {
-                sessionId,
-                provider: handle.provider,
-                workflow,
-                startupModePreset,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async applyStartupCollaborationModePreset(params) {
-        const modeOption = params.configOptions.find((option) => option.category === 'mode');
-        if (!modeOption) {
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-        const availableModeValues = this.getConfigOptionValues(modeOption);
-        const targetMode = this.resolveStartupModeTarget(params.handle.provider, params.startupModePreset, availableModeValues);
-        if (!targetMode) {
-            logger.debug('Startup mode preset not available in ACP mode options', {
-                sessionId: params.sessionId,
-                provider: params.handle.provider,
-                workflow: params.workflow,
-                startupModePreset: params.startupModePreset,
-                availableModeValues,
-            });
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-        const currentMode = modeOption.currentValue ? String(modeOption.currentValue) : null;
-        if (currentMode === targetMode) {
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-        try {
-            const configOptions = await acpRuntimeManager.setSessionMode(params.sessionId, targetMode);
-            return { configOptions, didUpdate: true };
-        }
-        catch (error) {
-            logger.warn('Failed applying startup mode preset', {
-                sessionId: params.sessionId,
-                provider: params.handle.provider,
-                workflow: params.workflow,
-                startupModePreset: params.startupModePreset,
-                targetMode,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-    }
-    async applyStartupExecutionModePreset(params) {
-        const executionModeOption = params.configOptions.find((option) => option.id === 'execution_mode' || option.category === 'permission');
-        const targetExecutionMode = this.resolveStartupExecutionModeTarget(params.handle.provider, params.workflow, params.startupModePreset, executionModeOption);
-        if (!(executionModeOption && targetExecutionMode)) {
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-        const currentExecutionMode = executionModeOption.currentValue
-            ? String(executionModeOption.currentValue)
-            : null;
-        if (currentExecutionMode === targetExecutionMode) {
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-        try {
-            const configOptions = await acpRuntimeManager.setConfigOption(params.sessionId, executionModeOption.id, targetExecutionMode);
-            return { configOptions, didUpdate: true };
-        }
-        catch (error) {
-            logger.warn('Failed applying startup execution-mode preset', {
-                sessionId: params.sessionId,
-                provider: params.handle.provider,
-                workflow: params.workflow,
-                startupModePreset: params.startupModePreset,
-                targetExecutionMode,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return { configOptions: params.configOptions, didUpdate: false };
-        }
-    }
-    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',
-        ]);
-    }
-    resolveStartupExecutionModeTarget(provider, workflow, startupModePreset, executionModeOption) {
-        if (provider !== 'CODEX' ||
-            workflow !== 'ratchet' ||
-            startupModePreset !== 'non_interactive' ||
-            !executionModeOption) {
-            return null;
-        }
-        const availableValues = this.getConfigOptionValues(executionModeOption);
-        const yoloByValue = this.findModeValue(availableValues, ['["never","danger-full-access"]']);
-        if (yoloByValue) {
-            return yoloByValue;
-        }
-        const yoloByName = this.getSelectOptions(executionModeOption).find((option) => /yolo/i.test(option.name ?? ''));
-        return yoloByName?.value ?? null;
     }
     async applyConfiguredPermissionPreset(sessionId, session, handle) {
-        if (handle.provider !== 'CODEX') {
-            return;
-        }
-        const executionModeOption = handle.configOptions.find((option) => option.id === 'execution_mode' || option.category === 'permission');
-        if (!executionModeOption) {
-            return;
-        }
-        let permissionPreset = session.workflow === 'ratchet' ? 'YOLO' : 'STRICT';
-        try {
-            const settings = await userSettingsAccessor.get();
-            permissionPreset =
-                session.workflow === 'ratchet'
-                    ? settings.ratchetPermissions
-                    : settings.defaultWorkspacePermissions;
-        }
-        catch (error) {
-            logger.warn('Failed loading user permission presets; using defaults', {
-                sessionId,
-                workflow: session.workflow,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        const targetExecutionMode = this.resolveConfiguredExecutionModeTarget(executionModeOption, permissionPreset);
-        if (!targetExecutionMode) {
-            return;
-        }
-        const currentExecutionMode = executionModeOption.currentValue
-            ? String(executionModeOption.currentValue)
-            : null;
-        if (currentExecutionMode === targetExecutionMode) {
-            return;
-        }
-        try {
-            const configOptions = await acpRuntimeManager.setConfigOption(sessionId, executionModeOption.id, targetExecutionMode);
-            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 configured session permission preset', {
-                sessionId,
-                workflow: session.workflow,
-                permissionPreset,
-                targetExecutionMode,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    resolveConfiguredExecutionModeTarget(executionModeOption, permissionPreset) {
-        const availableValues = this.getConfigOptionValues(executionModeOption);
-        const preferredValuesByPreset = {
-            STRICT: [
-                '["on-request","workspace-write"]',
-                '["on-request","read-only"]',
-                '["on-request","danger-full-access"]',
-            ],
-            RELAXED: [
-                '["on-failure","workspace-write"]',
-                '["on-failure","read-only"]',
-                '["on-failure","danger-full-access"]',
-            ],
-            YOLO: [
-                '["never","danger-full-access"]',
-                '["never","workspace-write"]',
-                '["never","read-only"]',
-            ],
-        };
-        const preferredValues = preferredValuesByPreset[permissionPreset];
-        const byValue = this.findModeValue(availableValues, preferredValues);
-        if (byValue) {
-            return byValue;
-        }
-        const byName = this.getSelectOptions(executionModeOption).find((option) => {
-            const name = option.name ?? '';
-            if (permissionPreset === 'STRICT') {
-                return /on request/i.test(name);
-            }
-            if (permissionPreset === 'RELAXED') {
-                return /on failure/i.test(name);
-            }
-            return /yolo|never ask/i.test(name);
-        });
-        return byName?.value ?? null;
-    }
-    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;
-    }
-    normalizeModeValue(value) {
-        return value.replace(/[^a-z0-9]/gi, '').toLowerCase();
+        await this.sessionConfigService.applyConfiguredPermissionPreset(sessionId, session, handle);
     }
     async stopSession(sessionId, options) {
+        this.clearScheduledPromptTurnCompletion(sessionId);
         const session = await this.loadSessionForStop(sessionId);
-        const workspaceId = session?.workspaceId ?? this.sessionToWorkspace.get(sessionId);
-        if (acpRuntimeManager.isStopInProgress(sessionId)) {
+        const workspaceId = session?.workspaceId ?? this.acpEventProcessor.getWorkspaceId(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',
             updatedAt: new Date().toISOString(),
         });
-        this.acpStreamState.delete(sessionId);
-        this.suppressAcpReplayForSession.delete(sessionId);
-        const acpBridge = this.acpPermissionBridges.get(sessionId);
-        if (acpBridge) {
-            acpBridge.cancelAll();
-            this.acpPermissionBridges.delete(sessionId);
-        }
+        this.acpEventProcessor.clearStreamingState(sessionId);
+        this.acpEventProcessor.clearReplaySuppression(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) {
@@ -919,16 +265,15 @@ 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',
                 updatedAt: new Date().toISOString(),
             });
             this.markWorkspaceSessionIdleOnStop(workspaceId, sessionId);
-            this.sessionToWorkspace.delete(sessionId);
-            this.sessionToWorkingDir.delete(sessionId);
+            this.acpEventProcessor.clearSessionContext(sessionId);
             if (!stopClientFailed) {
                 const shouldCleanupTransientRatchetSession = options?.cleanupTransientRatchetSession ?? true;
                 await this.cleanupTransientRatchetOnStop(session, sessionId, shouldCleanupTransientRatchetSession);
@@ -942,14 +287,14 @@ class SessionService {
     }
     finalizeOrphanedToolCallsOnStop(sessionId) {
         try {
-            this.finalizeOrphanedToolCalls(sessionId, 'session_stop');
+            this.acpEventProcessor.finalizeOrphanedToolCalls(sessionId, 'session_stop');
         }
         catch (error) {
             logger.warn('Failed finalizing orphaned ACP tool calls during stop', {
                 sessionId,
                 error: error instanceof Error ? error.message : String(error),
             });
-            this.pendingAcpToolCalls.delete(sessionId);
+            this.acpEventProcessor.clearPendingToolCalls(sessionId);
         }
     }
     markWorkspaceSessionIdleOnStop(workspaceId, sessionId) {
@@ -997,7 +342,7 @@ class SessionService {
             return;
         }
         try {
-            await this.repository.clearRatchetActiveSession(session.workspaceId, sessionId);
+            await this.clearRatchetActiveSessionIfMatching(session.workspaceId, sessionId);
         }
         catch (error) {
             logger.warn('Failed clearing ratchet active session pointer during stop', {
@@ -1020,11 +365,17 @@ class SessionService {
             });
         }
     }
+    async clearRatchetActiveSessionIfMatching(workspaceId, sessionId) {
+        if (!this.workspaceBridge) {
+            return;
+        }
+        await this.workspaceBridge.clearRatchetActiveSessionIfMatching(workspaceId, sessionId);
+    }
     async stopWorkspaceSessions(workspaceId) {
         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);
                 }
@@ -1044,7 +395,7 @@ class SessionService {
         if (!session) {
             throw new Error(`Session not found: ${sessionId}`);
         }
-        const hadClient = !!acpRuntimeManager.getClient(sessionId);
+        const hadClient = !!this.runtimeManager.getClient(sessionId);
         const handle = await this.getOrCreateAcpSessionClient(sessionId, options ?? {}, session);
         if (!(hadClient || session.providerSessionId)) {
             await this.applyConfiguredPermissionPreset(sessionId, session, handle);
@@ -1052,7 +403,7 @@ class SessionService {
         return handle;
     }
     async getOrCreateSessionClientFromRecord(session, options) {
-        const hadClient = !!acpRuntimeManager.getClient(session.id);
+        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);
@@ -1060,135 +411,28 @@ class SessionService {
         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(() => {
@@ -1230,9 +474,9 @@ class SessionService {
         return chunks.join('\n\n');
     }
     async sendAcpMessage(sessionId, content) {
-        const workspaceId = this.sessionToWorkspace.get(sessionId);
-        this.pendingAcpToolCalls.set(sessionId, new Map());
-        sessionDomainService.setRuntimeSnapshot(sessionId, {
+        const workspaceId = this.acpEventProcessor.getWorkspaceId(sessionId);
+        this.acpEventProcessor.beginPromptTurn(sessionId);
+        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
             phase: 'running',
             processState: 'alive',
             activity: 'WORKING',
@@ -1242,9 +486,9 @@ class SessionService {
             this.workspaceBridge.markSessionRunning(workspaceId, sessionId);
         }
         try {
-            const result = await acpRuntimeManager.sendPrompt(sessionId, content);
-            this.finalizeOrphanedToolCalls(sessionId, `stop_reason:${result.stopReason}`);
-            sessionDomainService.setRuntimeSnapshot(sessionId, {
+            const result = await this.runtimeManager.sendPrompt(sessionId, content);
+            this.acpEventProcessor.finalizeOrphanedToolCalls(sessionId, `stop_reason:${result.stopReason}`);
+            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'idle',
                 processState: 'alive',
                 activity: 'IDLE',
@@ -1253,8 +497,8 @@ class SessionService {
             return result.stopReason;
         }
         catch (error) {
-            this.finalizeOrphanedToolCalls(sessionId, 'prompt_error');
-            sessionDomainService.setRuntimeSnapshot(sessionId, {
+            this.acpEventProcessor.finalizeOrphanedToolCalls(sessionId, 'prompt_error');
+            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'error',
                 processState: 'alive',
                 activity: 'IDLE',
@@ -1274,9 +518,12 @@ class SessionService {
         if (!this.promptTurnCompleteHandler) {
             return;
         }
-        setTimeout(() => {
+        this.clearScheduledPromptTurnCompletion(sessionId);
+        const timeout = setTimeout(() => {
+            this.promptTurnCompleteTimeouts.delete(sessionId);
             void this.notifyPromptTurnComplete(sessionId);
         }, 0);
+        this.promptTurnCompleteTimeouts.set(sessionId, timeout);
     }
     async notifyPromptTurnComplete(sessionId) {
         if (!this.promptTurnCompleteHandler) {
@@ -1292,11 +539,25 @@ class SessionService {
             });
         }
     }
+    clearScheduledPromptTurnCompletion(sessionId) {
+        const timeout = this.promptTurnCompleteTimeouts.get(sessionId);
+        if (!timeout) {
+            return;
+        }
+        clearTimeout(timeout);
+        this.promptTurnCompleteTimeouts.delete(sessionId);
+    }
+    clearAllScheduledPromptTurnCompletions() {
+        for (const timeout of this.promptTurnCompleteTimeouts.values()) {
+            clearTimeout(timeout);
+        }
+        this.promptTurnCompleteTimeouts.clear();
+    }
     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) {
@@ -1342,19 +603,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',
@@ -1362,7 +619,7 @@ class SessionService {
                 updatedAt: base.updatedAt,
             };
         }
-        if (acpRuntimeManager.isStopInProgress(sessionId)) {
+        if (this.runtimeManager.isStopInProgress(sessionId)) {
             return {
                 ...base,
                 phase: 'stopping',
@@ -1381,9 +638,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',
@@ -1391,7 +648,7 @@ class SessionService {
             });
             return existingAcp;
         }
-        sessionDomainService.setRuntimeSnapshot(sessionId, {
+        this.sessionDomainService.setRuntimeSnapshot(sessionId, {
             phase: 'starting',
             processState: 'alive',
             activity: 'IDLE',
@@ -1402,7 +659,7 @@ class SessionService {
             handle = await this.createAcpClient(sessionId, options, session);
         }
         catch (error) {
-            sessionDomainService.setRuntimeSnapshot(sessionId, {
+            this.sessionDomainService.setRuntimeSnapshot(sessionId, {
                 phase: 'error',
                 processState: 'stopped',
                 activity: 'IDLE',
@@ -1414,7 +671,7 @@ class SessionService {
         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',
@@ -1423,13 +680,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);
@@ -1443,121 +700,16 @@ 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) {
+    async stopAllClients(timeoutMs = 5000) {
+        this.clearAllScheduledPromptTurnCompletions();
         try {
-            await acpRuntimeManager.stopAllClients();
+            await this.runtimeManager.stopAllClients(timeoutMs);
         }
         catch (error) {
             logger.error('Failed to stop ACP clients during shutdown', {
@@ -1567,105 +719,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));
@@ -1728,5 +782,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