factory-factory 0.3.3 → 0.3.5

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

@@ -2,6 +2,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { sessionDomainService } from '../../../../backend/domains/session/session-domain.service.js';
 import { SessionStatus } from '../../../../shared/core/index.js';
 import { unsafeCoerce } from '../../../../test-utils/unsafe-coerce.js';
+const mockNotifyToolStart = vi.fn();
+const mockNotifyToolComplete = vi.fn();
 vi.mock('@/backend/services/logger.service', () => ({
     createLogger: () => ({
         debug: vi.fn(),
@@ -38,6 +40,12 @@ vi.mock('@/backend/domains/session/acp', async (importOriginal) => {
         },
     };
 });
+vi.mock('@/backend/interceptors/registry', () => ({
+    interceptorRegistry: {
+        notifyToolStart: (...args) => mockNotifyToolStart(...args),
+        notifyToolComplete: (...args) => mockNotifyToolComplete(...args),
+    },
+}));
 vi.mock('./session.repository', () => ({
     SessionRepository: class {
     },
@@ -67,6 +75,19 @@ import { sessionService } from './session.service.js';
 describe('SessionService', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        mockNotifyToolStart.mockReset();
+        mockNotifyToolComplete.mockReset();
+        const serviceState = sessionService;
+        serviceState.pendingAcpToolCalls.clear();
+        serviceState.sessionToWorkspace.clear();
+        serviceState.sessionToWorkingDir.clear();
+        sessionService.setPromptTurnCompleteHandler(null);
+        sessionService.configure({
+            workspace: {
+                markSessionRunning: vi.fn(),
+                markSessionIdle: vi.fn(),
+            },
+        });
         vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
         vi.mocked(acpRuntimeManager.isSessionRunning).mockReturnValue(false);
         vi.mocked(acpRuntimeManager.isSessionWorking).mockReturnValue(false);
@@ -181,6 +202,130 @@ describe('SessionService', () => {
             status: SessionStatus.RUNNING,
         });
     });
+    it('applies Claude non-interactive startup mode preset when bypassPermissions is available', 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(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('injects replayed user_message_chunk events while session is idle', async () => {
         const session = unsafeCoerce({
             id: 'session-1',
@@ -341,6 +486,76 @@ 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', {
+            type: 'agent_message',
+            data: {
+                type: 'stream_event',
+                event: {
+                    type: 'content_block_start',
+                    index: 0,
+                    content_block: {
+                        type: 'tool_use',
+                        id: 'call-1',
+                        name: 'commandExecution',
+                        input: { command: 'gh pr create --title "Fix bug"' },
+                    },
+                },
+            },
+        });
+        serviceState.handleAcpDelta('session-1', {
+            type: 'tool_progress',
+            tool_use_id: 'call-1',
+            tool_name: 'commandExecution',
+            acpStatus: 'completed',
+            elapsed_time_seconds: 1,
+        });
+        serviceState.handleAcpDelta('session-1', {
+            type: 'agent_message',
+            data: {
+                type: 'user',
+                message: {
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: 'call-1',
+                            content: 'https://github.com/purplefish-ai/factory-factory/pull/1047',
+                        },
+                    ],
+                },
+            },
+        });
+        expect(mockNotifyToolStart).toHaveBeenCalledWith(expect.objectContaining({
+            toolUseId: 'call-1',
+            toolName: 'commandExecution',
+            input: { command: 'gh pr create --title "Fix bug"' },
+        }), expect.objectContaining({
+            sessionId: 'session-1',
+            workspaceId: 'workspace-1',
+            workingDir: '/tmp/workspace',
+            timestamp: expect.any(Date),
+        }));
+        expect(mockNotifyToolStart).toHaveBeenCalledTimes(1);
+        expect(mockNotifyToolComplete).toHaveBeenCalledWith(expect.objectContaining({
+            toolUseId: 'call-1',
+            toolName: 'commandExecution',
+            input: { command: 'gh pr create --title "Fix bug"' },
+            output: {
+                content: 'https://github.com/purplefish-ai/factory-factory/pull/1047',
+                isError: false,
+            },
+        }), expect.objectContaining({
+            sessionId: 'session-1',
+            workspaceId: 'workspace-1',
+            workingDir: '/tmp/workspace',
+            timestamp: expect.any(Date),
+        }));
+        expect(mockNotifyToolComplete).toHaveBeenCalledTimes(1);
+    });
     it('creates client from preloaded session without re-querying session row', async () => {
         const session = unsafeCoerce({
             id: 'session-1',
@@ -398,7 +613,25 @@ describe('SessionService', () => {
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
         const clearQueuedWorkSpy = vi.spyOn(sessionDomainService, 'clearQueuedWork');
         await sessionService.stopSession('session-1');
-        expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: false });
+        expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: true });
+    });
+    it('marks workspace session idle during manual stop', async () => {
+        const markSessionIdle = vi.fn();
+        sessionService.configure({
+            workspace: {
+                markSessionRunning: vi.fn(),
+                markSessionIdle,
+            },
+        });
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
+        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
+            id: 'session-1',
+            workspaceId: 'workspace-1',
+        }));
+        vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
+        await sessionService.stopSession('session-1');
+        expect(markSessionIdle).toHaveBeenCalledWith('workspace-1', 'session-1');
     });
     it('still clears queued work and marks idle when runtime stop fails', async () => {
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
@@ -414,10 +647,91 @@ describe('SessionService', () => {
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
             status: SessionStatus.IDLE,
         });
-        expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: false });
+        expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: true });
         expect(sessionRepository.clearRatchetActiveSession).not.toHaveBeenCalled();
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
+    it('finalizes orphaned ACP tool calls during manual stop', async () => {
+        const pendingToolCalls = sessionService.pendingAcpToolCalls;
+        pendingToolCalls.set('session-1', new Map([
+            [
+                'call-1',
+                {
+                    toolUseId: 'call-1',
+                    toolName: 'Run pwd',
+                    acpKind: 'execute',
+                },
+            ],
+        ]));
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
+        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
+            id: 'session-1',
+            workspaceId: 'workspace-1',
+        }));
+        vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
+        const emitDeltaSpy = vi.spyOn(sessionDomainService, 'emitDelta');
+        const appendClaudeEventSpy = vi
+            .spyOn(sessionDomainService, 'appendClaudeEvent')
+            .mockReturnValue(77);
+        await sessionService.stopSession('session-1');
+        expect(emitDeltaSpy).toHaveBeenCalledWith('session-1', expect.objectContaining({
+            type: 'tool_progress',
+            tool_use_id: 'call-1',
+            tool_name: 'Run pwd',
+            acpStatus: 'failed',
+            elapsed_time_seconds: 0,
+        }));
+        expect(appendClaudeEventSpy).toHaveBeenCalledWith('session-1', expect.objectContaining({
+            type: 'user',
+            message: expect.objectContaining({
+                content: [
+                    expect.objectContaining({
+                        type: 'tool_result',
+                        tool_use_id: 'call-1',
+                        is_error: true,
+                    }),
+                ],
+            }),
+        }));
+        expect(pendingToolCalls.has('session-1')).toBe(false);
+    });
+    it('continues stop cleanup when orphaned tool-call finalization throws', async () => {
+        const markSessionIdle = vi.fn();
+        sessionService.configure({
+            workspace: {
+                markSessionRunning: vi.fn(),
+                markSessionIdle,
+            },
+        });
+        const pendingToolCalls = sessionService.pendingAcpToolCalls;
+        pendingToolCalls.set('session-1', new Map([
+            [
+                'call-1',
+                {
+                    toolUseId: 'call-1',
+                    toolName: 'Run pwd',
+                    acpKind: 'execute',
+                },
+            ],
+        ]));
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
+        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
+            id: 'session-1',
+            workspaceId: 'workspace-1',
+        }));
+        vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
+        vi.spyOn(sessionDomainService, 'emitDelta').mockImplementationOnce(() => {
+            throw new Error('emit failed');
+        });
+        await sessionService.stopSession('session-1');
+        expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
+            status: SessionStatus.IDLE,
+        });
+        expect(markSessionIdle).toHaveBeenCalledWith('workspace-1', 'session-1');
+        expect(pendingToolCalls.has('session-1')).toBe(false);
+    });
     it('deletes ratchet session record during manual stop', async () => {
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
         vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
@@ -752,6 +1066,7 @@ describe('SessionService', () => {
             .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),
@@ -768,6 +1083,95 @@ describe('SessionService', () => {
         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',
@@ -887,6 +1291,98 @@ describe('SessionService', () => {
         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;
         vi.mocked(acpRuntimeManager.sendPrompt).mockImplementation(() => {
@@ -933,6 +1429,39 @@ describe('SessionService', () => {
         await sessionService.sendAcpMessage('session-1', 'hello');
         expect(appendClaudeEventSpy).not.toHaveBeenCalled();
     });
+    it('schedules prompt-turn completion callbacks after ACP prompt settles', async () => {
+        vi.useFakeTimers();
+        try {
+            const onPromptTurnComplete = vi.fn().mockResolvedValue(undefined);
+            sessionService.setPromptTurnCompleteHandler(onPromptTurnComplete);
+            vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({
+                stopReason: 'end_turn',
+            });
+            await sessionService.sendAcpMessage('session-1', 'hello');
+            expect(onPromptTurnComplete).not.toHaveBeenCalled();
+            await vi.runOnlyPendingTimersAsync();
+            expect(onPromptTurnComplete).toHaveBeenCalledWith('session-1');
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it('swallows prompt-turn completion callback failures', async () => {
+        vi.useFakeTimers();
+        try {
+            const onPromptTurnComplete = vi.fn().mockRejectedValue(new Error('dispatch failed'));
+            sessionService.setPromptTurnCompleteHandler(onPromptTurnComplete);
+            vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({
+                stopReason: 'end_turn',
+            });
+            await expect(sessionService.sendAcpMessage('session-1', 'hello')).resolves.toBe('end_turn');
+            await vi.runOnlyPendingTimersAsync();
+            expect(onPromptTurnComplete).toHaveBeenCalledWith('session-1');
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
     it('avoids redundant session DB lookups during startSession', async () => {
         const session = unsafeCoerce({
             id: 'session-1',