factory-factory 0.3.7 → 0.3.9

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

@@ -4,6 +4,7 @@ import { SessionStatus } from '../../../../shared/core/index.js';
 import { unsafeCoerce } from '../../../../test-utils/unsafe-coerce.js';
 const mockNotifyToolStart = vi.fn();
 const mockNotifyToolComplete = vi.fn();
+const mockClearRatchetActiveSessionIfMatching = vi.fn();
 vi.mock('@/backend/services/logger.service', () => ({
     createLogger: () => ({
         debug: vi.fn(),
@@ -56,7 +57,6 @@ vi.mock('./session.repository', () => ({
         getProjectById: vi.fn(),
         markWorkspaceHasHadSessions: vi.fn(),
         updateSession: vi.fn(),
-        clearRatchetActiveSession: vi.fn(),
         deleteSession: vi.fn(),
     },
 }));
@@ -72,20 +72,25 @@ import { acpRuntimeManager } from '../../../../backend/domains/session/acp/index
 import { sessionPromptBuilder } from './session.prompt-builder.js';
 import { sessionRepository } from './session.repository.js';
 import { sessionService } from './session.service.js';
+function getAcpProcessorState() {
+    return sessionService.acpEventProcessor;
+}
 describe('SessionService', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         mockNotifyToolStart.mockReset();
         mockNotifyToolComplete.mockReset();
-        const serviceState = sessionService;
-        serviceState.pendingAcpToolCalls.clear();
-        serviceState.sessionToWorkspace.clear();
-        serviceState.sessionToWorkingDir.clear();
+        mockClearRatchetActiveSessionIfMatching.mockReset();
+        const acpProcessor = getAcpProcessorState();
+        acpProcessor.pendingAcpToolCalls.clear();
+        acpProcessor.sessionToWorkspace.clear();
+        acpProcessor.sessionToWorkingDir.clear();
         sessionService.setPromptTurnCompleteHandler(null);
         sessionService.configure({
             workspace: {
                 markSessionRunning: vi.fn(),
                 markSessionIdle: vi.fn(),
+                clearRatchetActiveSessionIfMatching: mockClearRatchetActiveSessionIfMatching,
             },
         });
         vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
@@ -202,7 +207,7 @@ describe('SessionService', () => {
             status: SessionStatus.RUNNING,
         });
     });
-    it('applies Claude non-interactive startup mode preset when bypassPermissions is available', async () => {
+    it('injects replayed user_message_chunk events while session is idle', async () => {
         const session = unsafeCoerce({
             id: 'session-1',
             workspaceId: 'workspace-1',
@@ -210,176 +215,21 @@ describe('SessionService', () => {
             workflow: 'default',
             model: 'sonnet',
             provider: 'CLAUDE',
-            providerSessionId: null,
-        });
-        const workspace = unsafeCoerce({
-            id: 'workspace-1',
-            worktreePath: '/tmp/work',
-            branchName: 'feature-branch',
-            isAutoGeneratedBranch: false,
-            hasHadSessions: true,
-            name: 'Workspace A',
-            description: null,
-            projectId: 'project-1',
-        });
-        const modeConfig = {
-            id: 'mode',
-            name: 'Mode',
-            type: 'select',
-            category: 'mode',
-            currentValue: 'default',
-            options: [
-                { value: 'default', name: 'Default' },
-                { value: 'bypassPermissions', name: 'Bypass Permissions' },
-            ],
-        };
-        const acpHandle = unsafeCoerce({
-            getPid: vi.fn().mockReturnValue(456),
-            provider: 'CLAUDE',
             providerSessionId: 'provider-session-1',
-            isPromptInFlight: false,
-            configOptions: [modeConfig],
-        });
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
-        vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
-        vi.mocked(sessionRepository.markWorkspaceHasHadSessions).mockResolvedValue();
-        vi.mocked(sessionRepository.updateSession).mockResolvedValue(session);
-        vi.mocked(sessionPromptBuilder.shouldInjectBranchRename).mockReturnValue(false);
-        vi.mocked(sessionPromptBuilder.buildSystemPrompt).mockReturnValue({
-            workflowPrompt: undefined,
-            systemPrompt: undefined,
-            injectedBranchRename: false,
-        });
-        vi.mocked(acpRuntimeManager.getOrCreateClient).mockResolvedValue(acpHandle);
-        vi.mocked(acpRuntimeManager.setSessionMode).mockResolvedValue([
-            {
-                ...modeConfig,
-                currentValue: 'bypassPermissions',
-            },
-        ]);
-        await sessionService.startSession('session-1', {
-            initialPrompt: '',
-            startupModePreset: 'non_interactive',
-        });
-        expect(acpRuntimeManager.setSessionMode).toHaveBeenCalledWith('session-1', 'bypassPermissions');
-        expect(acpRuntimeManager.sendPrompt).not.toHaveBeenCalled();
-    });
-    it('applies Codex non-interactive startup mode preset using code mode', async () => {
-        const session = unsafeCoerce({
-            id: 'session-codex',
-            workspaceId: 'workspace-1',
-            status: SessionStatus.IDLE,
-            workflow: 'default',
-            model: 'gpt-5-codex',
-            provider: 'CODEX',
-            providerSessionId: null,
         });
         const workspace = unsafeCoerce({
             id: 'workspace-1',
             worktreePath: '/tmp/work',
             branchName: 'feature-branch',
             isAutoGeneratedBranch: false,
-            hasHadSessions: true,
             name: 'Workspace A',
             description: null,
             projectId: 'project-1',
         });
-        const modeConfig = {
-            id: 'mode',
-            name: 'Mode',
-            type: 'select',
-            category: 'mode',
-            currentValue: 'ask',
-            options: [
-                { value: 'ask', name: 'Ask' },
-                { value: 'code', name: 'Code' },
-            ],
-        };
         const acpHandle = unsafeCoerce({
-            getPid: vi.fn().mockReturnValue(457),
-            provider: 'CODEX',
-            providerSessionId: 'provider-codex-1',
-            isPromptInFlight: false,
-            configOptions: [modeConfig],
-        });
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
-        vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
-        vi.mocked(sessionRepository.markWorkspaceHasHadSessions).mockResolvedValue();
-        vi.mocked(sessionRepository.updateSession).mockResolvedValue(session);
-        vi.mocked(sessionPromptBuilder.shouldInjectBranchRename).mockReturnValue(false);
-        vi.mocked(sessionPromptBuilder.buildSystemPrompt).mockReturnValue({
-            workflowPrompt: undefined,
-            systemPrompt: undefined,
-            injectedBranchRename: false,
-        });
-        vi.mocked(acpRuntimeManager.getOrCreateClient).mockResolvedValue(acpHandle);
-        vi.mocked(acpRuntimeManager.setSessionMode).mockResolvedValue([
-            {
-                ...modeConfig,
-                currentValue: 'code',
-            },
-        ]);
-        await sessionService.startSession('session-codex', {
-            initialPrompt: '',
-            startupModePreset: 'non_interactive',
-        });
-        expect(acpRuntimeManager.setSessionMode).toHaveBeenCalledWith('session-codex', 'code');
-        expect(acpRuntimeManager.sendPrompt).not.toHaveBeenCalled();
-    });
-    it('applies Codex ratchet non-interactive startup execution mode using YOLO', async () => {
-        const session = unsafeCoerce({
-            id: 'session-codex-ratchet',
-            workspaceId: 'workspace-1',
-            status: SessionStatus.IDLE,
-            workflow: 'ratchet',
-            model: 'gpt-5-codex',
-            provider: 'CODEX',
-            providerSessionId: null,
-        });
-        const workspace = unsafeCoerce({
-            id: 'workspace-1',
-            worktreePath: '/tmp/work',
-            branchName: 'feature-branch',
-            isAutoGeneratedBranch: false,
-            hasHadSessions: true,
-            name: 'Workspace A',
-            description: null,
-            projectId: 'project-1',
-        });
-        const modeConfig = {
-            id: 'mode',
-            name: 'Mode',
-            type: 'select',
-            category: 'mode',
-            currentValue: 'ask',
-            options: [
-                { value: 'ask', name: 'Ask' },
-                { value: 'code', name: 'Code' },
-            ],
-        };
-        const executionModeConfig = {
-            id: 'execution_mode',
-            name: 'Execution Mode',
-            type: 'select',
-            category: 'permission',
-            currentValue: '["on-failure","workspace-write"]',
-            options: [
-                {
-                    value: '["on-failure","workspace-write"]',
-                    name: 'On Failure (Workspace Write)',
-                },
-                {
-                    value: '["never","danger-full-access"]',
-                    name: 'YOLO (Full Access)',
-                },
-            ],
-        };
-        const acpHandle = unsafeCoerce({
-            getPid: vi.fn().mockReturnValue(458),
-            provider: 'CODEX',
-            providerSessionId: 'provider-codex-ratchet-1',
+            getPid: vi.fn().mockReturnValue(456),
             isPromptInFlight: false,
-            configOptions: [modeConfig, executionModeConfig],
+            configOptions: [],
         });
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
         vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
@@ -392,100 +242,19 @@ describe('SessionService', () => {
             injectedBranchRename: false,
         });
         vi.mocked(acpRuntimeManager.getOrCreateClient).mockResolvedValue(acpHandle);
-        vi.mocked(acpRuntimeManager.setSessionMode).mockResolvedValue([
-            {
-                ...modeConfig,
-                currentValue: 'code',
-            },
-            executionModeConfig,
-        ]);
-        vi.mocked(acpRuntimeManager.setConfigOption).mockResolvedValue([
-            {
-                ...modeConfig,
-                currentValue: 'code',
-            },
-            {
-                ...executionModeConfig,
-                currentValue: '["never","danger-full-access"]',
+        const injectUserMessageSpy = vi.spyOn(sessionDomainService, 'injectCommittedUserMessage');
+        await sessionService.getOrCreateSessionClient('session-1');
+        const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
+        acpHandlers.onAcpEvent('session-1', {
+            type: 'acp_session_update',
+            update: {
+                sessionUpdate: 'user_message_chunk',
+                content: { type: 'text', text: 'ping' },
             },
-        ]);
-        await sessionService.startSession('session-codex-ratchet', {
-            initialPrompt: '',
-            startupModePreset: 'non_interactive',
-        });
-        expect(acpRuntimeManager.setSessionMode).toHaveBeenCalledWith('session-codex-ratchet', 'code');
-        expect(acpRuntimeManager.setConfigOption).toHaveBeenCalledWith('session-codex-ratchet', 'execution_mode', '["never","danger-full-access"]');
-        expect(acpRuntimeManager.sendPrompt).not.toHaveBeenCalled();
-    });
-    it('continues startup when persisting startup mode preset config snapshot fails', async () => {
-        const session = unsafeCoerce({
-            id: 'session-1',
-            workspaceId: 'workspace-1',
-            status: SessionStatus.IDLE,
-            workflow: 'default',
-            model: 'sonnet',
-            provider: 'CLAUDE',
-            providerSessionId: null,
         });
-        const workspace = unsafeCoerce({
-            id: 'workspace-1',
-            worktreePath: '/tmp/work',
-            branchName: 'feature-branch',
-            isAutoGeneratedBranch: false,
-            hasHadSessions: true,
-            name: 'Workspace A',
-            description: null,
-            projectId: 'project-1',
-        });
-        const modeConfig = {
-            id: 'mode',
-            name: 'Mode',
-            type: 'select',
-            category: 'mode',
-            currentValue: 'default',
-            options: [
-                { value: 'default', name: 'Default' },
-                { value: 'bypassPermissions', name: 'Bypass Permissions' },
-            ],
-        };
-        const acpHandle = unsafeCoerce({
-            getPid: vi.fn().mockReturnValue(459),
-            provider: 'CLAUDE',
-            providerSessionId: 'provider-session-1',
-            isPromptInFlight: false,
-            configOptions: [modeConfig],
-        });
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
-        vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
-        vi.mocked(sessionRepository.markWorkspaceHasHadSessions).mockResolvedValue();
-        vi.mocked(sessionRepository.updateSession).mockResolvedValue(session);
-        vi.mocked(sessionPromptBuilder.shouldInjectBranchRename).mockReturnValue(false);
-        vi.mocked(sessionPromptBuilder.buildSystemPrompt).mockReturnValue({
-            workflowPrompt: undefined,
-            systemPrompt: undefined,
-            injectedBranchRename: false,
-        });
-        vi.mocked(acpRuntimeManager.getOrCreateClient).mockResolvedValue(acpHandle);
-        vi.mocked(acpRuntimeManager.setSessionMode).mockResolvedValue([
-            {
-                ...modeConfig,
-                currentValue: 'bypassPermissions',
-            },
-        ]);
-        const persistSpy = vi
-            .spyOn(sessionService, 'persistAcpConfigSnapshot')
-            .mockResolvedValueOnce(undefined)
-            .mockRejectedValueOnce(new Error('db unavailable'));
-        await expect(sessionService.startSession('session-1', {
-            initialPrompt: '',
-            startupModePreset: 'non_interactive',
-        })).resolves.toBeUndefined();
-        expect(acpRuntimeManager.setSessionMode).toHaveBeenCalledWith('session-1', 'bypassPermissions');
-        expect(persistSpy).toHaveBeenCalledTimes(2);
-        expect(acpHandle.configOptions[0]?.currentValue).toBe('bypassPermissions');
-        expect(acpRuntimeManager.sendPrompt).not.toHaveBeenCalled();
+        expect(injectUserMessageSpy).toHaveBeenCalledWith('session-1', 'ping');
     });
-    it('injects replayed user_message_chunk events while session is idle', async () => {
+    it('ignores malformed user_message_chunk events without content', async () => {
         const session = unsafeCoerce({
             id: 'session-1',
             workspaceId: 'workspace-1',
@@ -523,14 +292,13 @@ describe('SessionService', () => {
         const injectUserMessageSpy = vi.spyOn(sessionDomainService, 'injectCommittedUserMessage');
         await sessionService.getOrCreateSessionClient('session-1');
         const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
-        acpHandlers.onAcpEvent('session-1', {
+        expect(() => acpHandlers.onAcpEvent('session-1', {
             type: 'acp_session_update',
             update: {
                 sessionUpdate: 'user_message_chunk',
-                content: { type: 'text', text: 'ping' },
             },
-        });
-        expect(injectUserMessageSpy).toHaveBeenCalledWith('session-1', 'ping');
+        })).not.toThrow();
+        expect(injectUserMessageSpy).not.toHaveBeenCalled();
     });
     it('suppresses replayed user_message_chunk when transcript is already hydrated', async () => {
         const session = unsafeCoerce({
@@ -646,10 +414,10 @@ describe('SessionService', () => {
         expect(injectUserMessageSpy).not.toHaveBeenCalled();
     });
     it('notifies interceptors for ACP tool_use start and tool_result completion', () => {
-        const serviceState = sessionService;
-        serviceState.sessionToWorkspace.set('session-1', 'workspace-1');
-        serviceState.sessionToWorkingDir.set('session-1', '/tmp/workspace');
-        serviceState.handleAcpDelta('session-1', {
+        const acpProcessor = getAcpProcessorState();
+        acpProcessor.sessionToWorkspace.set('session-1', 'workspace-1');
+        acpProcessor.sessionToWorkingDir.set('session-1', '/tmp/workspace');
+        acpProcessor.handleAcpDelta('session-1', {
             type: 'agent_message',
             data: {
                 type: 'stream_event',
@@ -665,14 +433,14 @@ describe('SessionService', () => {
                 },
             },
         });
-        serviceState.handleAcpDelta('session-1', {
+        acpProcessor.handleAcpDelta('session-1', {
             type: 'tool_progress',
             tool_use_id: 'call-1',
             tool_name: 'commandExecution',
             acpStatus: 'completed',
             elapsed_time_seconds: 1,
         });
-        serviceState.handleAcpDelta('session-1', {
+        acpProcessor.handleAcpDelta('session-1', {
             type: 'agent_message',
             data: {
                 type: 'user',
@@ -780,6 +548,7 @@ describe('SessionService', () => {
             workspace: {
                 markSessionRunning: vi.fn(),
                 markSessionIdle,
+                clearRatchetActiveSessionIfMatching: mockClearRatchetActiveSessionIfMatching,
             },
         });
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
@@ -807,11 +576,11 @@ describe('SessionService', () => {
             status: SessionStatus.IDLE,
         });
         expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: true });
-        expect(sessionRepository.clearRatchetActiveSession).not.toHaveBeenCalled();
+        expect(mockClearRatchetActiveSessionIfMatching).not.toHaveBeenCalled();
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
     it('finalizes orphaned ACP tool calls during manual stop', async () => {
-        const pendingToolCalls = sessionService.pendingAcpToolCalls;
+        const pendingToolCalls = getAcpProcessorState().pendingAcpToolCalls;
         pendingToolCalls.set('session-1', new Map([
             [
                 'call-1',
@@ -861,9 +630,10 @@ describe('SessionService', () => {
             workspace: {
                 markSessionRunning: vi.fn(),
                 markSessionIdle,
+                clearRatchetActiveSessionIfMatching: mockClearRatchetActiveSessionIfMatching,
             },
         });
-        const pendingToolCalls = sessionService.pendingAcpToolCalls;
+        const pendingToolCalls = getAcpProcessorState().pendingAcpToolCalls;
         pendingToolCalls.set('session-1', new Map([
             [
                 'call-1',
@@ -900,10 +670,9 @@ describe('SessionService', () => {
             workflow: 'ratchet',
         }));
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
-        vi.mocked(sessionRepository.clearRatchetActiveSession).mockResolvedValue();
         vi.mocked(sessionRepository.deleteSession).mockResolvedValue({});
         await sessionService.stopSession('session-1');
-        expect(sessionRepository.clearRatchetActiveSession).toHaveBeenCalledWith('workspace-1', 'session-1');
+        expect(mockClearRatchetActiveSessionIfMatching).toHaveBeenCalledWith('workspace-1', 'session-1');
         expect(sessionRepository.deleteSession).toHaveBeenCalledWith('session-1');
     });
     it('does not delete non-ratchet session during manual stop', async () => {
@@ -930,7 +699,7 @@ describe('SessionService', () => {
         await sessionService.stopSession('session-3', {
             cleanupTransientRatchetSession: false,
         });
-        expect(sessionRepository.clearRatchetActiveSession).toHaveBeenCalledWith('workspace-1', 'session-3');
+        expect(mockClearRatchetActiveSessionIfMatching).toHaveBeenCalledWith('workspace-1', 'session-3');
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
     it('marks process as stopped when ACP client creation fails', async () => {
@@ -1028,7 +797,6 @@ describe('SessionService', () => {
         vi.mocked(sessionRepository.getProjectById).mockResolvedValue(project);
         vi.mocked(sessionRepository.markWorkspaceHasHadSessions).mockResolvedValue();
         vi.mocked(sessionRepository.updateSession).mockResolvedValue(session);
-        vi.mocked(sessionRepository.clearRatchetActiveSession).mockResolvedValue();
         vi.mocked(sessionRepository.deleteSession).mockResolvedValue(session);
         vi.mocked(sessionPromptBuilder.shouldInjectBranchRename).mockReturnValue(false);
         vi.mocked(sessionPromptBuilder.buildSystemPrompt).mockReturnValue({
@@ -1044,7 +812,7 @@ describe('SessionService', () => {
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
             status: SessionStatus.COMPLETED,
         });
-        expect(sessionRepository.clearRatchetActiveSession).toHaveBeenCalledWith('workspace-1', 'session-1');
+        expect(mockClearRatchetActiveSessionIfMatching).toHaveBeenCalledWith('workspace-1', 'session-1');
         expect(sessionRepository.deleteSession).toHaveBeenCalledWith('session-1');
     });
     it('does not delete session on ACP exit for non-ratchet workflows', async () => {
@@ -1075,7 +843,6 @@ describe('SessionService', () => {
         vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
         vi.mocked(sessionRepository.markWorkspaceHasHadSessions).mockResolvedValue();
         vi.mocked(sessionRepository.updateSession).mockResolvedValue(session);
-        vi.mocked(sessionRepository.clearRatchetActiveSession).mockResolvedValue();
         vi.mocked(sessionPromptBuilder.shouldInjectBranchRename).mockReturnValue(false);
         vi.mocked(sessionPromptBuilder.buildSystemPrompt).mockReturnValue({
             workflowPrompt: undefined,
@@ -1133,423 +900,8 @@ describe('SessionService', () => {
             status: SessionStatus.RUNNING,
         });
     });
-    it('returns ACP config options for active session handles', () => {
-        const configOptions = [
-            {
-                id: 'model',
-                name: 'Model',
-                type: 'string',
-                category: 'model',
-                currentValue: 'sonnet',
-                options: [{ value: 'sonnet', name: 'Sonnet' }],
-            },
-        ];
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(unsafeCoerce({
-            configOptions,
-        }));
-        expect(sessionService.getSessionConfigOptions('session-1')).toEqual(configOptions);
-    });
-    it('returns empty config options when no ACP handle is active', () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
-        expect(sessionService.getSessionConfigOptions('session-1')).toEqual([]);
-    });
-    it('returns cached config options when no ACP handle is active', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
-            id: 'session-1',
-            provider: 'CLAUDE',
-            providerMetadata: {
-                acpConfigSnapshot: {
-                    provider: 'CLAUDE',
-                    providerSessionId: 'provider-session-1',
-                    capturedAt: '2026-02-14T00:00:00.000Z',
-                    configOptions: [
-                        {
-                            id: 'model',
-                            name: 'Model',
-                            type: 'select',
-                            category: 'model',
-                            currentValue: 'claude-sonnet-4-5',
-                            options: [{ value: 'claude-sonnet-4-5', name: 'Claude Sonnet 4.5' }],
-                        },
-                    ],
-                },
-            },
-        }));
-        await expect(sessionService.getSessionConfigOptionsWithFallback('session-1')).resolves.toEqual([
-            {
-                id: 'model',
-                name: 'Model',
-                type: 'select',
-                category: 'model',
-                currentValue: 'claude-sonnet-4-5',
-                options: [{ value: 'claude-sonnet-4-5', name: 'Claude Sonnet 4.5' }],
-            },
-        ]);
-    });
-    it('returns empty Claude capabilities when no ACP handle or cached snapshot exists', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
-            id: 'session-claude',
-            provider: 'CLAUDE',
-            model: 'claude-sonnet-4-5',
-            providerMetadata: null,
-        }));
-        const capabilities = await sessionService.getChatBarCapabilities('session-claude');
-        expect(capabilities.provider).toBe('CLAUDE');
-        expect(capabilities.model.enabled).toBe(false);
-        expect(capabilities.model.selected).toBeUndefined();
-        expect(capabilities.model.options).toEqual([]);
-    });
-    it('retries persisting ACP config snapshot metadata once when first write fails', async () => {
-        const configOptions = unsafeCoerce([
-            {
-                id: 'model',
-                name: 'Model',
-                type: 'select',
-                category: 'model',
-                currentValue: 'claude-sonnet-4-5',
-                options: [{ value: 'claude-sonnet-4-5', name: 'Claude Sonnet 4.5' }],
-            },
-        ]);
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(unsafeCoerce({
-            provider: 'CLAUDE',
-            providerSessionId: 'provider-session-1',
-            configOptions,
-        }));
-        vi.mocked(acpRuntimeManager.setSessionModel).mockResolvedValue(configOptions);
-        vi.mocked(sessionRepository.updateSession)
-            .mockRejectedValueOnce(new Error('primary metadata write failed'))
-            .mockResolvedValueOnce(unsafeCoerce({ id: 'session-1' }));
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
-            id: 'session-1',
-            providerMetadata: { existing: 'metadata' },
-        }));
-        await sessionService.setSessionConfigOption('session-1', 'model', 'claude-sonnet-4-5');
-        const metadataUpdates = vi
-            .mocked(sessionRepository.updateSession)
-            .mock.calls.filter(([, update]) => Object.hasOwn(update, 'providerMetadata'));
-        expect(metadataUpdates).toHaveLength(2);
-        expect(metadataUpdates[1]?.[1]).toMatchObject({
-            model: 'claude-sonnet-4-5',
-            providerMetadata: expect.objectContaining({
-                existing: 'metadata',
-                acpConfigSnapshot: expect.any(Object),
-            }),
-        });
-    });
-    it('returns CODEX provider fallback capabilities when no ACP handle is active', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
-            id: 'session-codex',
-            provider: 'CODEX',
-        }));
-        const capabilities = await sessionService.getChatBarCapabilities('session-codex');
-        expect(capabilities.provider).toBe('CODEX');
-        expect(capabilities.model.enabled).toBe(false);
-    });
-    it('derives CODEX model/reasoning/plan-mode capabilities from cached ACP config options', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
-            id: 'session-codex',
-            provider: 'CODEX',
-            providerMetadata: {
-                acpConfigSnapshot: {
-                    provider: 'CODEX',
-                    providerSessionId: 'sess_123',
-                    capturedAt: '2026-02-15T00:00:00.000Z',
-                    configOptions: [
-                        {
-                            id: 'model',
-                            name: 'Model',
-                            type: 'select',
-                            category: 'model',
-                            currentValue: 'gpt-5-codex',
-                            options: [
-                                { value: 'gpt-5-codex', name: 'GPT-5 Codex' },
-                                { value: 'gpt-5-mini', name: 'GPT-5 Mini' },
-                            ],
-                        },
-                        {
-                            id: 'mode',
-                            name: 'Mode',
-                            type: 'select',
-                            category: 'mode',
-                            currentValue: 'plan',
-                            options: [
-                                { value: 'ask', name: 'Ask' },
-                                { value: 'plan', name: 'Plan' },
-                            ],
-                        },
-                        {
-                            id: 'reasoning_effort',
-                            name: 'Reasoning Effort',
-                            type: 'select',
-                            category: 'thought_level',
-                            currentValue: 'high',
-                            options: [
-                                { value: 'medium', name: 'Medium', description: 'Balanced' },
-                                { value: 'high', name: 'High', description: 'Thorough' },
-                            ],
-                        },
-                    ],
-                },
-            },
-        }));
-        const capabilities = await sessionService.getChatBarCapabilities('session-codex');
-        expect(capabilities.provider).toBe('CODEX');
-        expect(capabilities.model.options).toEqual([
-            { value: 'gpt-5-codex', label: 'GPT-5 Codex' },
-            { value: 'gpt-5-mini', label: 'GPT-5 Mini' },
-        ]);
-        expect(capabilities.reasoning.enabled).toBe(true);
-        expect(capabilities.reasoning.options).toEqual([
-            { value: 'medium', label: 'Medium', description: 'Balanced' },
-            { value: 'high', label: 'High', description: 'Thorough' },
-        ]);
-        expect(capabilities.reasoning.selected).toBe('high');
-        expect(capabilities.planMode.enabled).toBe(true);
-        expect(capabilities.thinking.enabled).toBe(false);
-    });
-    it('disables plan mode when ACP config options do not advertise a plan variant', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
-            id: 'session-codex',
-            provider: 'CODEX',
-            providerMetadata: {
-                acpConfigSnapshot: {
-                    provider: 'CODEX',
-                    providerSessionId: 'sess_124',
-                    capturedAt: '2026-02-15T00:00:00.000Z',
-                    configOptions: [
-                        {
-                            id: 'mode',
-                            name: 'Approval Policy',
-                            type: 'select',
-                            category: 'mode',
-                            currentValue: 'on-failure',
-                            options: [{ value: 'on-failure', name: 'On Failure' }],
-                        },
-                    ],
-                },
-            },
-        }));
-        const capabilities = await sessionService.getChatBarCapabilities('session-codex');
-        expect(capabilities.planMode.enabled).toBe(false);
-    });
-    it('skips setSessionModel when requested model is not in ACP model options', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(unsafeCoerce({
-            provider: 'CODEX',
-            configOptions: [
-                {
-                    id: 'model',
-                    name: 'Model',
-                    type: 'select',
-                    category: 'model',
-                    currentValue: 'gpt-5.3-codex',
-                    options: [
-                        { value: 'gpt-5.3-codex', name: 'GPT-5.3 Codex' },
-                        { value: 'gpt-5.2-codex', name: 'GPT-5.2 Codex' },
-                    ],
-                },
-            ],
-        }));
-        await sessionService.setSessionModel('session-codex', 'opus');
-        expect(acpRuntimeManager.setConfigOption).not.toHaveBeenCalled();
-    });
-    it('applies setSessionModel when requested model is supported by ACP options', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(unsafeCoerce({
-            provider: 'CODEX',
-            configOptions: [
-                {
-                    id: 'model',
-                    name: 'Model',
-                    type: 'select',
-                    category: 'model',
-                    currentValue: 'gpt-5.3-codex',
-                    options: [
-                        { value: 'gpt-5.3-codex', name: 'GPT-5.3 Codex' },
-                        { value: 'gpt-5.2-codex', name: 'GPT-5.2 Codex' },
-                    ],
-                },
-            ],
-        }));
-        vi.mocked(acpRuntimeManager.setSessionModel).mockResolvedValue([
-            {
-                id: 'model',
-                name: 'Model',
-                type: 'select',
-                category: 'model',
-                currentValue: 'gpt-5.2-codex',
-                options: [{ value: 'gpt-5.2-codex', name: 'GPT-5.2 Codex' }],
-            },
-        ]);
-        await sessionService.setSessionModel('session-codex', 'gpt-5.2-codex');
-        expect(acpRuntimeManager.setSessionModel).toHaveBeenCalledWith('session-codex', 'gpt-5.2-codex');
-        expect(acpRuntimeManager.setConfigOption).not.toHaveBeenCalled();
-    });
-    it('routes mode config updates through ACP setSessionMode', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(unsafeCoerce({
-            provider: 'CLAUDE',
-            configOptions: [
-                {
-                    id: 'mode',
-                    name: 'Mode',
-                    type: 'select',
-                    category: 'mode',
-                    currentValue: 'default',
-                    options: [
-                        { value: 'default', name: 'Default' },
-                        { value: 'acceptEdits', name: 'Accept Edits' },
-                    ],
-                },
-            ],
-        }));
-        vi.mocked(acpRuntimeManager.setSessionMode).mockResolvedValue([
-            {
-                id: 'mode',
-                name: 'Mode',
-                type: 'select',
-                category: 'mode',
-                currentValue: 'acceptEdits',
-                options: [
-                    { value: 'default', name: 'Default' },
-                    { value: 'acceptEdits', name: 'Accept Edits' },
-                ],
-            },
-        ]);
-        await sessionService.setSessionConfigOption('session-1', 'mode', 'acceptEdits');
-        expect(acpRuntimeManager.setSessionMode).toHaveBeenCalledWith('session-1', 'acceptEdits');
-        expect(acpRuntimeManager.setConfigOption).not.toHaveBeenCalled();
-    });
-    it('routes model config updates through ACP setSessionModel', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(unsafeCoerce({
-            provider: 'CLAUDE',
-            configOptions: [
-                {
-                    id: 'model',
-                    name: 'Model',
-                    type: 'select',
-                    category: 'model',
-                    currentValue: 'default',
-                    options: [
-                        { value: 'default', name: 'Default' },
-                        { value: 'claude-sonnet-4-5', name: 'Sonnet 4.5' },
-                    ],
-                },
-            ],
-        }));
-        vi.mocked(acpRuntimeManager.setSessionModel).mockResolvedValue([
-            {
-                id: 'model',
-                name: 'Model',
-                type: 'select',
-                category: 'model',
-                currentValue: 'claude-sonnet-4-5',
-                options: [
-                    { value: 'default', name: 'Default' },
-                    { value: 'claude-sonnet-4-5', name: 'Sonnet 4.5' },
-                ],
-            },
-        ]);
-        await sessionService.setSessionConfigOption('session-1', 'model', 'claude-sonnet-4-5');
-        expect(acpRuntimeManager.setSessionModel).toHaveBeenCalledWith('session-1', 'claude-sonnet-4-5');
-        expect(acpRuntimeManager.setConfigOption).not.toHaveBeenCalled();
-    });
-    it('updates cached config snapshot when setting config on inactive session', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
-            id: 'session-1',
-            provider: 'CODEX',
-            providerMetadata: {
-                acpConfigSnapshot: {
-                    provider: 'CODEX',
-                    providerSessionId: 'thread_123',
-                    capturedAt: '2026-02-15T00:00:00.000Z',
-                    configOptions: [
-                        {
-                            id: 'execution_mode',
-                            name: 'Execution Mode',
-                            type: 'select',
-                            category: 'permission',
-                            currentValue: '["on-request","workspace-write"]',
-                            options: [
-                                {
-                                    value: '["on-request","workspace-write"]',
-                                    name: 'on-request + workspace-write',
-                                },
-                                {
-                                    value: '["on-failure","workspace-write"]',
-                                    name: 'on-failure + workspace-write',
-                                },
-                            ],
-                        },
-                    ],
-                },
-            },
-        }));
-        vi.mocked(sessionRepository.updateSession).mockResolvedValue(unsafeCoerce({ id: 'session-1' }));
-        const emitDeltaSpy = vi.spyOn(sessionDomainService, 'emitDelta');
-        await sessionService.setSessionConfigOption('session-1', 'execution_mode', '["on-failure","workspace-write"]');
-        expect(acpRuntimeManager.setConfigOption).not.toHaveBeenCalled();
-        expect(acpRuntimeManager.setSessionMode).not.toHaveBeenCalled();
-        expect(acpRuntimeManager.setSessionModel).not.toHaveBeenCalled();
-        expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', expect.objectContaining({
-            providerMetadata: expect.objectContaining({
-                acpConfigSnapshot: expect.objectContaining({
-                    configOptions: expect.arrayContaining([
-                        expect.objectContaining({
-                            id: 'execution_mode',
-                            currentValue: '["on-failure","workspace-write"]',
-                        }),
-                    ]),
-                }),
-            }),
-        }));
-        expect(emitDeltaSpy).toHaveBeenCalledWith('session-1', expect.objectContaining({
-            type: 'config_options_update',
-            configOptions: expect.arrayContaining([
-                expect.objectContaining({
-                    id: 'execution_mode',
-                    currentValue: '["on-failure","workspace-write"]',
-                }),
-            ]),
-        }));
-    });
-    it('rejects unsupported cached config values on inactive session', async () => {
-        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
-            id: 'session-1',
-            provider: 'CODEX',
-            providerMetadata: {
-                acpConfigSnapshot: {
-                    provider: 'CODEX',
-                    providerSessionId: 'thread_123',
-                    capturedAt: '2026-02-15T00:00:00.000Z',
-                    configOptions: [
-                        {
-                            id: 'execution_mode',
-                            name: 'Execution Mode',
-                            type: 'select',
-                            category: 'permission',
-                            currentValue: '["on-request","workspace-write"]',
-                            options: [
-                                {
-                                    value: '["on-request","workspace-write"]',
-                                    name: 'on-request + workspace-write',
-                                },
-                            ],
-                        },
-                    ],
-                },
-            },
-        }));
-        await expect(sessionService.setSessionConfigOption('session-1', 'execution_mode', '["never","danger-full-access"]')).rejects.toThrow('Unsupported value');
-        expect(sessionRepository.updateSession).not.toHaveBeenCalled();
-        expect(acpRuntimeManager.setConfigOption).not.toHaveBeenCalled();
-    });
     it('finalizes orphaned ACP tool calls when prompt ends without terminal updates', async () => {
-        const pendingToolCalls = sessionService.pendingAcpToolCalls;
+        const pendingToolCalls = getAcpProcessorState().pendingAcpToolCalls;
         vi.mocked(acpRuntimeManager.sendPrompt).mockImplementation(() => {
             pendingToolCalls.set('session-1', new Map([
                 [
@@ -1611,6 +963,25 @@ describe('SessionService', () => {
             vi.useRealTimers();
         }
     });
+    it('cancels scheduled prompt-turn completion callback when session stops first', async () => {
+        vi.useFakeTimers();
+        try {
+            const onPromptTurnComplete = vi.fn().mockResolvedValue(undefined);
+            sessionService.setPromptTurnCompleteHandler(onPromptTurnComplete);
+            vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({
+                stopReason: 'end_turn',
+            });
+            vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
+            vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
+            await sessionService.sendAcpMessage('session-1', 'hello');
+            await sessionService.stopSession('session-1');
+            await vi.runOnlyPendingTimersAsync();
+            expect(onPromptTurnComplete).not.toHaveBeenCalled();
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
     it('swallows prompt-turn completion callback failures', async () => {
         vi.useFakeTimers();
         try {
@@ -1720,10 +1091,12 @@ describe('SessionService', () => {
         vi.mocked(acpRuntimeManager.stopAllClients).mockResolvedValue(undefined);
         await sessionService.stopAllClients(4321);
         expect(acpRuntimeManager.stopAllClients).toHaveBeenCalledTimes(1);
+        expect(acpRuntimeManager.stopAllClients).toHaveBeenCalledWith(4321);
     });
     it('propagates ACP shutdown failure', async () => {
         vi.mocked(acpRuntimeManager.stopAllClients).mockRejectedValueOnce(new Error('acp shutdown failed'));
         await expect(sessionService.stopAllClients()).rejects.toThrow('acp shutdown failed');
+        expect(acpRuntimeManager.stopAllClients).toHaveBeenCalledWith(5000);
     });
 });
 //# sourceMappingURL=session.service.test.js.map