factory-factory 0.3.6 → 0.3.8

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

@@ -202,130 +202,6 @@ 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',
@@ -806,11 +682,17 @@ describe('SessionService', () => {
         vi.mocked(acpRuntimeManager.getOrCreateClient).mockRejectedValue(new Error('spawn failed'));
         const setRuntimeSnapshotSpy = vi.spyOn(sessionDomainService, 'setRuntimeSnapshot');
         await expect(sessionService.getOrCreateSessionClient('session-1')).rejects.toThrow('spawn failed');
-        expect(setRuntimeSnapshotSpy).toHaveBeenCalledWith('session-1', expect.objectContaining({
+        expect(setRuntimeSnapshotSpy).toHaveBeenNthCalledWith(1, 'session-1', expect.objectContaining({
             phase: 'starting',
             processState: 'alive',
             activity: 'IDLE',
         }));
+        expect(setRuntimeSnapshotSpy).toHaveBeenNthCalledWith(2, 'session-1', expect.objectContaining({
+            phase: 'error',
+            processState: 'stopped',
+            activity: 'IDLE',
+            errorMessage: 'Failed to start agent: spawn failed',
+        }));
     });
     it('throws when session not found during client creation', async () => {
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(null);
@@ -968,421 +850,6 @@ 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;
         vi.mocked(acpRuntimeManager.sendPrompt).mockImplementation(() => {