factory-factory 0.2.7 → 0.3.0

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

@@ -1,7 +1,7 @@
-import { SessionStatus } from '../../../../../prisma/generated/client.js';
+import { SessionStatus } from '@factory-factory/core';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { sessionDomainService } from '../../../../backend/domains/session/session-domain.service.js';
 import { unsafeCoerce } from '../../../../test-utils/unsafe-coerce.js';
-import { sessionDomainService } from '../session-domain.service.js';
 vi.mock('@/backend/services/logger.service', () => ({
     createLogger: () => ({
         debug: vi.fn(),
@@ -10,6 +10,34 @@ vi.mock('@/backend/services/logger.service', () => ({
         error: vi.fn(),
     }),
 }));
+vi.mock('@/backend/domains/session/acp', async (importOriginal) => {
+    const actual = (await importOriginal());
+    return {
+        ...actual,
+        AcpEventTranslator: class MockAcpEventTranslator {
+            translateSessionUpdate = vi.fn().mockReturnValue([]);
+        },
+        AcpPermissionBridge: class MockAcpPermissionBridge {
+            cancelAll = vi.fn();
+            resolvePermission = vi.fn();
+        },
+        acpRuntimeManager: {
+            getClient: vi.fn().mockReturnValue(undefined),
+            getOrCreateClient: vi.fn(),
+            stopClient: vi.fn(),
+            stopAllClients: vi.fn(),
+            sendPrompt: vi.fn(),
+            cancelPrompt: vi.fn(),
+            isSessionRunning: vi.fn().mockReturnValue(false),
+            isSessionWorking: vi.fn().mockReturnValue(false),
+            isAnySessionWorking: vi.fn().mockReturnValue(false),
+            isStopInProgress: vi.fn().mockReturnValue(false),
+            setConfigOption: vi.fn(),
+            setSessionMode: vi.fn(),
+            setSessionModel: vi.fn(),
+        },
+    };
+});
 vi.mock('./session.repository', () => ({
     SessionRepository: class {
     },
@@ -32,42 +60,28 @@ vi.mock('./session.prompt-builder', () => ({
         buildSystemPrompt: vi.fn(),
     },
 }));
-vi.mock('./session.process-manager', () => ({
-    SessionProcessManager: class {
-    },
-    sessionProcessManager: {
-        setOnClientCreated: vi.fn(),
-        isStopInProgress: vi.fn(),
-        createClient: vi.fn(),
-        getOrCreateClient: vi.fn(),
-        getClient: vi.fn(),
-        getPendingClient: vi.fn(),
-        stopClient: vi.fn(),
-        getClaudeProcess: vi.fn(),
-        isSessionRunning: vi.fn(),
-        isSessionWorking: vi.fn(),
-        isAnySessionWorking: vi.fn(),
-        getAllActiveProcesses: vi.fn(),
-        getAllClients: vi.fn(),
-        stopAllClients: vi.fn(),
-    },
-}));
-import { sessionProcessManager } from './session.process-manager.js';
+import { acpRuntimeManager } from '../../../../backend/domains/session/acp/index.js';
 import { sessionPromptBuilder } from './session.prompt-builder.js';
 import { sessionRepository } from './session.repository.js';
 import { sessionService } from './session.service.js';
 describe('SessionService', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        vi.mocked(acpRuntimeManager.getClient).mockReturnValue(undefined);
+        vi.mocked(acpRuntimeManager.isSessionRunning).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.isSessionWorking).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.isAnySessionWorking).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
     });
-    it('starts a session via process manager and updates DB state', async () => {
+    it('starts a session via ACP runtime and updates DB state', async () => {
         const session = unsafeCoerce({
             id: 'session-1',
             workspaceId: 'workspace-1',
             status: SessionStatus.IDLE,
             workflow: 'default',
             model: 'sonnet',
-            claudeSessionId: null,
+            provider: 'CLAUDE',
+            providerSessionId: null,
         });
         const workspace = unsafeCoerce({
             id: 'workspace-1',
@@ -83,9 +97,10 @@ describe('SessionService', () => {
             id: 'project-1',
             githubOwner: 'owner',
         });
-        const client = unsafeCoerce({
+        const acpHandle = unsafeCoerce({
             getPid: vi.fn().mockReturnValue(123),
-            sendMessage: vi.fn().mockResolvedValue(undefined),
+            isPromptInFlight: false,
+            configOptions: [],
         });
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
         vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
@@ -98,47 +113,35 @@ describe('SessionService', () => {
             systemPrompt: 'system',
             injectedBranchRename: true,
         });
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
-        vi.mocked(sessionProcessManager.getOrCreateClient).mockResolvedValue(client);
-        await sessionService.startClaudeSession('session-1', { initialPrompt: 'Hello' });
+        vi.mocked(acpRuntimeManager.getOrCreateClient).mockResolvedValue(acpHandle);
+        vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
+        await sessionService.startSession('session-1', { initialPrompt: 'Hello' });
         expect(sessionPromptBuilder.shouldInjectBranchRename).toHaveBeenCalledWith({
             branchName: 'auto-branch',
             isAutoGeneratedBranch: true,
             hasHadSessions: false,
         });
         expect(sessionRepository.markWorkspaceHasHadSessions).toHaveBeenCalledWith('workspace-1');
-        expect(sessionProcessManager.getOrCreateClient).toHaveBeenCalledWith('session-1', expect.objectContaining({
+        expect(acpRuntimeManager.getOrCreateClient).toHaveBeenCalledWith('session-1', expect.objectContaining({
             workingDir: '/tmp/work',
             systemPrompt: 'system',
             model: 'sonnet',
             permissionMode: 'bypassPermissions',
-            includePartialMessages: false,
             sessionId: 'session-1',
         }), expect.any(Object), { workspaceId: 'workspace-1', workingDir: '/tmp/work' });
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
             status: SessionStatus.RUNNING,
-            claudeProcessPid: 123,
         });
-        expect(client.sendMessage).toHaveBeenCalledWith('Hello');
     });
-    it('returns existing client without loading options', async () => {
-        const client = unsafeCoerce({
-            isRunning: vi.fn().mockReturnValue(true),
-        });
-        vi.mocked(sessionProcessManager.getClient).mockReturnValue(client);
-        const result = await sessionService.getOrCreateClient('session-1');
-        expect(result).toBe(client);
-        expect(sessionProcessManager.getOrCreateClient).not.toHaveBeenCalled();
-        expect(sessionRepository.getSessionById).not.toHaveBeenCalled();
-    });
-    it('delegates to processManager.getOrCreateClient for race protection', async () => {
+    it('delegates to ACP runtime for new session creation', async () => {
         const session = unsafeCoerce({
             id: 'session-1',
             workspaceId: 'workspace-1',
             status: SessionStatus.IDLE,
             workflow: 'default',
             model: 'sonnet',
-            claudeSessionId: null,
+            provider: 'CLAUDE',
+            providerSessionId: null,
         });
         const workspace = unsafeCoerce({
             id: 'workspace-1',
@@ -149,10 +152,11 @@ describe('SessionService', () => {
             description: null,
             projectId: 'project-1',
         });
-        const client = unsafeCoerce({
+        const acpHandle = unsafeCoerce({
             getPid: vi.fn().mockReturnValue(456),
+            isPromptInFlight: false,
+            configOptions: [],
         });
-        vi.mocked(sessionProcessManager.getClient).mockReturnValue(undefined);
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
         vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
         vi.mocked(sessionRepository.markWorkspaceHasHadSessions).mockResolvedValue();
@@ -163,10 +167,10 @@ describe('SessionService', () => {
             systemPrompt: undefined,
             injectedBranchRename: false,
         });
-        vi.mocked(sessionProcessManager.getOrCreateClient).mockResolvedValue(client);
-        const result = await sessionService.getOrCreateClient('session-1');
-        expect(result).toBe(client);
-        expect(sessionProcessManager.getOrCreateClient).toHaveBeenCalledWith('session-1', expect.objectContaining({
+        vi.mocked(acpRuntimeManager.getOrCreateClient).mockResolvedValue(acpHandle);
+        const result = await sessionService.getOrCreateSessionClient('session-1');
+        expect(result).toBe(acpHandle);
+        expect(acpRuntimeManager.getOrCreateClient).toHaveBeenCalledWith('session-1', expect.objectContaining({
             workingDir: '/tmp/work',
             sessionId: 'session-1',
         }), expect.any(Object), expect.objectContaining({
@@ -175,26 +179,248 @@ describe('SessionService', () => {
         }));
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
             status: SessionStatus.RUNNING,
-            claudeProcessPid: 456,
         });
     });
+    it('injects replayed user_message_chunk events while session is idle', async () => {
+        const session = unsafeCoerce({
+            id: 'session-1',
+            workspaceId: 'workspace-1',
+            status: SessionStatus.IDLE,
+            workflow: 'default',
+            model: 'sonnet',
+            provider: 'CLAUDE',
+            providerSessionId: 'provider-session-1',
+        });
+        const workspace = unsafeCoerce({
+            id: 'workspace-1',
+            worktreePath: '/tmp/work',
+            branchName: 'feature-branch',
+            isAutoGeneratedBranch: false,
+            name: 'Workspace A',
+            description: null,
+            projectId: 'project-1',
+        });
+        const acpHandle = unsafeCoerce({
+            getPid: vi.fn().mockReturnValue(456),
+            isPromptInFlight: false,
+            configOptions: [],
+        });
+        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);
+        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' },
+            },
+        });
+        expect(injectUserMessageSpy).toHaveBeenCalledWith('session-1', 'ping');
+    });
+    it('suppresses replayed user_message_chunk when transcript is already hydrated', async () => {
+        const session = unsafeCoerce({
+            id: 'session-1',
+            workspaceId: 'workspace-1',
+            status: SessionStatus.IDLE,
+            workflow: 'default',
+            model: 'sonnet',
+            provider: 'CLAUDE',
+            providerSessionId: 'provider-session-1',
+        });
+        const workspace = unsafeCoerce({
+            id: 'workspace-1',
+            worktreePath: '/tmp/work',
+            branchName: 'feature-branch',
+            isAutoGeneratedBranch: false,
+            name: 'Workspace A',
+            description: null,
+            projectId: 'project-1',
+        });
+        const acpHandle = unsafeCoerce({
+            getPid: vi.fn().mockReturnValue(456),
+            isPromptInFlight: false,
+            configOptions: [],
+        });
+        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);
+        const historyHydratedSpy = vi
+            .spyOn(sessionDomainService, 'isHistoryHydrated')
+            .mockReturnValue(true);
+        const transcriptSpy = vi.spyOn(sessionDomainService, 'getTranscriptSnapshot').mockReturnValue([
+            unsafeCoerce({
+                id: 'hist-1',
+                source: 'user',
+                text: 'already loaded',
+                timestamp: '2026-02-14T00:00:00.000Z',
+                order: 0,
+            }),
+        ]);
+        try {
+            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' },
+                },
+            });
+            expect(injectUserMessageSpy).not.toHaveBeenCalled();
+        }
+        finally {
+            historyHydratedSpy.mockRestore();
+            transcriptSpy.mockRestore();
+        }
+    });
+    it('ignores live user_message_chunk events while session is working', async () => {
+        const session = unsafeCoerce({
+            id: 'session-1',
+            workspaceId: 'workspace-1',
+            status: SessionStatus.IDLE,
+            workflow: 'default',
+            model: 'sonnet',
+            provider: 'CLAUDE',
+            providerSessionId: 'provider-session-1',
+        });
+        const workspace = unsafeCoerce({
+            id: 'workspace-1',
+            worktreePath: '/tmp/work',
+            branchName: 'feature-branch',
+            isAutoGeneratedBranch: false,
+            name: 'Workspace A',
+            description: null,
+            projectId: 'project-1',
+        });
+        const acpHandle = unsafeCoerce({
+            getPid: vi.fn().mockReturnValue(456),
+            isPromptInFlight: false,
+            configOptions: [],
+        });
+        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);
+        const injectUserMessageSpy = vi.spyOn(sessionDomainService, 'injectCommittedUserMessage');
+        await sessionService.getOrCreateSessionClient('session-1');
+        vi.mocked(acpRuntimeManager.isSessionWorking).mockReturnValue(true);
+        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' },
+            },
+        });
+        expect(injectUserMessageSpy).not.toHaveBeenCalled();
+    });
+    it('creates client from preloaded session without re-querying session row', 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 acpHandle = unsafeCoerce({
+            getPid: vi.fn().mockReturnValue(777),
+            isPromptInFlight: false,
+            configOptions: [],
+        });
+        vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
+        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);
+        const result = await sessionService.getOrCreateSessionClientFromRecord(session);
+        expect(result).toBe(acpHandle);
+        expect(sessionRepository.getSessionById).not.toHaveBeenCalled();
+        expect(acpRuntimeManager.getOrCreateClient).toHaveBeenCalledWith('session-1', expect.objectContaining({
+            workingDir: '/tmp/work',
+            sessionId: 'session-1',
+        }), expect.any(Object), expect.objectContaining({
+            workspaceId: 'workspace-1',
+            workingDir: '/tmp/work',
+        }));
+    });
     it('skips stop when already stopping', async () => {
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(true);
-        await sessionService.stopClaudeSession('session-1');
-        expect(sessionProcessManager.stopClient).not.toHaveBeenCalled();
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(true);
+        await sessionService.stopSession('session-1');
+        expect(acpRuntimeManager.stopClient).not.toHaveBeenCalled();
         expect(sessionRepository.updateSession).not.toHaveBeenCalled();
     });
     it('clears queued work during manual stop', async () => {
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
-        vi.mocked(sessionProcessManager.stopClient).mockResolvedValue();
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
         const clearQueuedWorkSpy = vi.spyOn(sessionDomainService, 'clearQueuedWork');
-        await sessionService.stopClaudeSession('session-1');
+        await sessionService.stopSession('session-1');
         expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: false });
     });
+    it('still clears queued work and marks idle when runtime stop fails', async () => {
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.stopClient).mockRejectedValue(new Error('stop failed'));
+        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
+            id: 'session-1',
+            workspaceId: 'workspace-1',
+            workflow: 'ratchet',
+        }));
+        vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
+        const clearQueuedWorkSpy = vi.spyOn(sessionDomainService, 'clearQueuedWork');
+        await sessionService.stopSession('session-1');
+        expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
+            status: SessionStatus.IDLE,
+        });
+        expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: false });
+        expect(sessionRepository.clearRatchetActiveSession).not.toHaveBeenCalled();
+        expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
+    });
     it('deletes ratchet session record during manual stop', async () => {
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
-        vi.mocked(sessionProcessManager.stopClient).mockResolvedValue();
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
             id: 'session-1',
             workspaceId: 'workspace-1',
@@ -203,55 +429,46 @@ describe('SessionService', () => {
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
         vi.mocked(sessionRepository.clearRatchetActiveSession).mockResolvedValue();
         vi.mocked(sessionRepository.deleteSession).mockResolvedValue({});
-        await sessionService.stopClaudeSession('session-1');
+        await sessionService.stopSession('session-1');
         expect(sessionRepository.clearRatchetActiveSession).toHaveBeenCalledWith('workspace-1', 'session-1');
         expect(sessionRepository.deleteSession).toHaveBeenCalledWith('session-1');
     });
     it('does not delete non-ratchet session during manual stop', async () => {
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
-        vi.mocked(sessionProcessManager.stopClient).mockResolvedValue();
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
             id: 'session-2',
             workspaceId: 'workspace-1',
             workflow: 'default',
         }));
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
-        await sessionService.stopClaudeSession('session-2');
+        await sessionService.stopSession('session-2');
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
     it('clears ratchet pointer but does not delete session when transient cleanup is disabled', async () => {
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
-        vi.mocked(sessionProcessManager.stopClient).mockResolvedValue();
+        vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
+        vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(unsafeCoerce({
             id: 'session-3',
             workspaceId: 'workspace-1',
             workflow: 'ratchet',
         }));
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
-        await sessionService.stopClaudeSession('session-3', {
+        await sessionService.stopSession('session-3', {
             cleanupTransientRatchetSession: false,
         });
         expect(sessionRepository.clearRatchetActiveSession).toHaveBeenCalledWith('workspace-1', 'session-3');
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
-    it('still stops process and clears queued work when session lookup fails', async () => {
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
-        vi.mocked(sessionRepository.getSessionById).mockRejectedValueOnce(new Error('db unavailable'));
-        vi.mocked(sessionProcessManager.stopClient).mockResolvedValue();
-        vi.mocked(sessionRepository.updateSession).mockRejectedValueOnce(new Error('missing row'));
-        const clearQueuedWorkSpy = vi.spyOn(sessionDomainService, 'clearQueuedWork');
-        await expect(sessionService.stopClaudeSession('session-err')).resolves.toBeUndefined();
-        expect(sessionProcessManager.stopClient).toHaveBeenCalledWith('session-err');
-        expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-err', { emitSnapshot: false });
-    });
-    it('marks process as stopped when client creation fails', async () => {
+    it('marks process as stopped when ACP client creation fails', async () => {
         const session = {
             id: 'session-1',
             workspaceId: 'workspace-1',
             status: SessionStatus.IDLE,
             workflow: 'default',
             model: 'sonnet',
-            claudeSessionId: null,
+            provider: 'CLAUDE',
+            providerSessionId: null,
         };
         const workspace = {
             id: 'workspace-1',
@@ -262,35 +479,28 @@ describe('SessionService', () => {
             description: null,
             projectId: 'project-1',
         };
-        vi.mocked(sessionProcessManager.getClient).mockReturnValue(undefined);
         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(sessionProcessManager.getOrCreateClient).mockRejectedValue(new Error('spawn failed'));
+        vi.mocked(acpRuntimeManager.getOrCreateClient).mockRejectedValue(new Error('spawn failed'));
         const setRuntimeSnapshotSpy = vi.spyOn(sessionDomainService, 'setRuntimeSnapshot');
-        await expect(sessionService.getOrCreateClient('session-1')).rejects.toThrow('spawn failed');
+        await expect(sessionService.getOrCreateSessionClient('session-1')).rejects.toThrow('spawn failed');
         expect(setRuntimeSnapshotSpy).toHaveBeenCalledWith('session-1', expect.objectContaining({
-            phase: 'error',
-            processState: 'stopped',
+            phase: 'starting',
+            processState: 'alive',
             activity: 'IDLE',
         }));
     });
-    it('marks process as stopped when building client options fails', async () => {
-        vi.mocked(sessionProcessManager.getClient).mockReturnValue(undefined);
+    it('throws when session not found during client creation', async () => {
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(null);
-        const setRuntimeSnapshotSpy = vi.spyOn(sessionDomainService, 'setRuntimeSnapshot');
-        await expect(sessionService.getOrCreateClient('session-1')).rejects.toThrow('Session not found: session-1');
-        expect(setRuntimeSnapshotSpy).toHaveBeenCalledWith('session-1', expect.objectContaining({
-            phase: 'error',
-            processState: 'stopped',
-            activity: 'IDLE',
-        }));
+        await expect(sessionService.getOrCreateSessionClient('session-1')).rejects.toThrow('Session not found: session-1');
     });
     it('returns null session options when workspace is missing', async () => {
         const session = unsafeCoerce({
@@ -299,21 +509,22 @@ describe('SessionService', () => {
             status: SessionStatus.IDLE,
             workflow: 'default',
             model: 'sonnet',
-            claudeSessionId: null,
+            providerSessionId: null,
         });
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
         vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(null);
         const options = await sessionService.getSessionOptions('session-1');
         expect(options).toBeNull();
     });
-    it('clears ratchetActiveSessionId and deletes session on ratchet exit', async () => {
+    it('clears ratchetActiveSessionId and deletes session on ACP ratchet exit', async () => {
         const session = unsafeCoerce({
             id: 'session-1',
             workspaceId: 'workspace-1',
             status: SessionStatus.IDLE,
             workflow: 'ratchet',
             model: 'sonnet',
-            claudeSessionId: null,
+            provider: 'CLAUDE',
+            providerSessionId: null,
         });
         const workspace = unsafeCoerce({
             id: 'workspace-1',
@@ -328,9 +539,10 @@ describe('SessionService', () => {
             id: 'project-1',
             githubOwner: 'owner',
         });
-        const client = unsafeCoerce({
+        const acpHandle = unsafeCoerce({
             getPid: vi.fn().mockReturnValue(456),
-            sendMessage: vi.fn().mockResolvedValue(undefined),
+            isPromptInFlight: false,
+            configOptions: [],
         });
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
         vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
@@ -345,26 +557,26 @@ describe('SessionService', () => {
             systemPrompt: 'system',
             injectedBranchRename: false,
         });
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
-        vi.mocked(sessionProcessManager.getOrCreateClient).mockResolvedValue(client);
-        await sessionService.startClaudeSession('session-1');
-        const handlers = vi.mocked(sessionProcessManager.getOrCreateClient).mock.calls[0][2];
-        await handlers.onExit('session-1');
+        vi.mocked(acpRuntimeManager.getOrCreateClient).mockResolvedValue(acpHandle);
+        vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
+        await sessionService.startSession('session-1');
+        const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
+        await acpHandlers.onExit('session-1', 0);
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
             status: SessionStatus.COMPLETED,
-            claudeProcessPid: null,
         });
         expect(sessionRepository.clearRatchetActiveSession).toHaveBeenCalledWith('workspace-1', 'session-1');
         expect(sessionRepository.deleteSession).toHaveBeenCalledWith('session-1');
     });
-    it('does not delete session on exit for non-ratchet workflows', async () => {
+    it('does not delete session on ACP exit for non-ratchet workflows', async () => {
         const session = unsafeCoerce({
             id: 'session-2',
             workspaceId: 'workspace-1',
             status: SessionStatus.IDLE,
             workflow: 'default',
             model: 'sonnet',
-            claudeSessionId: null,
+            provider: 'CLAUDE',
+            providerSessionId: null,
         });
         const workspace = unsafeCoerce({
             id: 'workspace-1',
@@ -375,9 +587,10 @@ describe('SessionService', () => {
             description: null,
             projectId: 'project-1',
         });
-        const client = unsafeCoerce({
+        const acpHandle = unsafeCoerce({
             getPid: vi.fn().mockReturnValue(789),
-            sendMessage: vi.fn().mockResolvedValue(undefined),
+            isPromptInFlight: false,
+            configOptions: [],
         });
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
         vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
@@ -390,62 +603,315 @@ describe('SessionService', () => {
             systemPrompt: undefined,
             injectedBranchRename: false,
         });
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
-        vi.mocked(sessionProcessManager.getOrCreateClient).mockResolvedValue(client);
-        await sessionService.startClaudeSession('session-2');
-        const handlers = vi.mocked(sessionProcessManager.getOrCreateClient).mock.calls[0][2];
-        await handlers.onExit('session-2');
+        vi.mocked(acpRuntimeManager.getOrCreateClient).mockResolvedValue(acpHandle);
+        vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
+        await sessionService.startSession('session-2');
+        const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
+        await acpHandlers.onExit('session-2', 0);
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-2', {
             status: SessionStatus.COMPLETED,
-            claudeProcessPid: null,
         });
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
-    it('stops sessions that are still starting when stopping a workspace', async () => {
+    it('updates DB status when ACP client is created', 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,
+            name: 'Workspace A',
+            description: null,
+            projectId: 'project-1',
         });
-        const client = { isRunning: vi.fn().mockReturnValue(true) };
-        const pendingClient = Promise.resolve(unsafeCoerce(client));
-        vi.mocked(sessionRepository.getSessionsByWorkspaceId).mockResolvedValue([session]);
-        vi.mocked(sessionProcessManager.getPendingClient).mockReturnValue(pendingClient);
-        vi.mocked(sessionProcessManager.getClaudeProcess).mockReturnValue(undefined);
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
-        vi.mocked(sessionProcessManager.stopClient).mockResolvedValue();
+        const acpHandle = unsafeCoerce({
+            getPid: vi.fn().mockReturnValue(999),
+            isPromptInFlight: false,
+            configOptions: [],
+        });
+        vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
+        vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
+        vi.mocked(sessionRepository.markWorkspaceHasHadSessions).mockResolvedValue();
         vi.mocked(sessionRepository.updateSession).mockResolvedValue(session);
-        await sessionService.stopWorkspaceSessions('workspace-1');
-        expect(sessionProcessManager.getPendingClient).toHaveBeenCalledWith('session-1');
-        expect(sessionProcessManager.stopClient).toHaveBeenCalledWith('session-1');
+        vi.mocked(sessionPromptBuilder.shouldInjectBranchRename).mockReturnValue(false);
+        vi.mocked(sessionPromptBuilder.buildSystemPrompt).mockReturnValue({
+            workflowPrompt: undefined,
+            systemPrompt: undefined,
+            injectedBranchRename: false,
+        });
+        vi.mocked(acpRuntimeManager.getOrCreateClient).mockResolvedValue(acpHandle);
+        await sessionService.getOrCreateSessionClient('session-1');
+        expect(acpRuntimeManager.getOrCreateClient).toHaveBeenCalled();
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
-            status: SessionStatus.IDLE,
-            claudeProcessPid: null,
+            status: SessionStatus.RUNNING,
         });
     });
-    it('updates DB status when getOrCreateClient creates new client', async () => {
+    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({
+            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('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('avoids redundant session DB lookups during startSession', async () => {
         const session = unsafeCoerce({
             id: 'session-1',
             workspaceId: 'workspace-1',
             status: SessionStatus.IDLE,
             workflow: 'default',
             model: 'sonnet',
-            claudeSessionId: null,
+            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 client = unsafeCoerce({
-            getPid: vi.fn().mockReturnValue(999),
+        const acpHandle = unsafeCoerce({
+            getPid: vi.fn().mockReturnValue(111),
+            isPromptInFlight: false,
+            configOptions: [],
         });
-        vi.mocked(sessionProcessManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionProcessManager.getPendingClient).mockReturnValue(undefined);
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
         vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(workspace);
         vi.mocked(sessionRepository.markWorkspaceHasHadSessions).mockResolvedValue();
@@ -456,13 +922,10 @@ describe('SessionService', () => {
             systemPrompt: undefined,
             injectedBranchRename: false,
         });
-        vi.mocked(sessionProcessManager.getOrCreateClient).mockResolvedValue(client);
-        await sessionService.getOrCreateClient('session-1');
-        expect(sessionProcessManager.getOrCreateClient).toHaveBeenCalled();
-        expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
-            status: SessionStatus.RUNNING,
-            claudeProcessPid: 999,
-        });
+        vi.mocked(acpRuntimeManager.getOrCreateClient).mockResolvedValue(acpHandle);
+        vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
+        await sessionService.startSession('session-1', { initialPrompt: 'go' });
+        expect(sessionRepository.getSessionById).toHaveBeenCalledTimes(1);
     });
     it('normalizes stale loading runtime to idle when no process is active', () => {
         vi.spyOn(sessionDomainService, 'getRuntimeSnapshot').mockReturnValue({
@@ -471,9 +934,6 @@ describe('SessionService', () => {
             activity: 'IDLE',
             updatedAt: new Date('2026-02-10T01:45:35.844Z').toISOString(),
         });
-        vi.mocked(sessionProcessManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionProcessManager.getPendingClient).mockReturnValue(undefined);
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
         const runtime = sessionService.getRuntimeSnapshot('session-1');
         expect(runtime).toMatchObject({
             phase: 'idle',
@@ -488,9 +948,6 @@ describe('SessionService', () => {
             activity: 'IDLE',
             updatedAt: new Date().toISOString(),
         });
-        vi.mocked(sessionProcessManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionProcessManager.getPendingClient).mockReturnValue(undefined);
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
         const runtime = sessionService.getRuntimeSnapshot('session-1');
         expect(runtime).toMatchObject({
             phase: 'loading',
@@ -498,76 +955,35 @@ describe('SessionService', () => {
             activity: 'IDLE',
         });
     });
-    it('getOrCreateClient and startClaudeSession produce identical DB state', async () => {
-        const session = unsafeCoerce({
-            id: 'session-1',
-            workspaceId: 'workspace-1',
-            status: SessionStatus.IDLE,
-            workflow: 'default',
-            model: 'sonnet',
-            claudeSessionId: null,
-        });
-        const workspace = unsafeCoerce({
-            id: 'workspace-1',
-            worktreePath: '/tmp/work',
-            branchName: 'feature-branch',
-            isAutoGeneratedBranch: false,
-            name: 'Workspace A',
-            description: null,
-            projectId: 'project-1',
-        });
-        const client = unsafeCoerce({
-            getPid: vi.fn().mockReturnValue(888),
-            sendMessage: vi.fn().mockResolvedValue(undefined),
-        });
-        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,
+    it('keeps updatedAt stable while ACP client remains in same runtime state', () => {
+        const updatedAt = '2026-02-10T01:45:35.844Z';
+        vi.spyOn(sessionDomainService, 'getRuntimeSnapshot').mockReturnValue({
+            phase: 'idle',
+            processState: 'alive',
+            activity: 'IDLE',
+            updatedAt,
         });
-        vi.mocked(sessionProcessManager.getOrCreateClient).mockResolvedValue(client);
-        vi.mocked(sessionProcessManager.getClient).mockReturnValue(undefined);
-        vi.mocked(sessionProcessManager.getPendingClient).mockReturnValue(undefined);
-        await sessionService.getOrCreateClient('session-1');
-        const getOrCreateCalls = vi.mocked(sessionRepository.updateSession).mock.calls;
-        vi.clearAllMocks();
-        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.getClient).mockReturnValue(unsafeCoerce({
+            isPromptInFlight: false,
+            configOptions: [],
+        }));
+        vi.mocked(acpRuntimeManager.isSessionWorking).mockReturnValue(false);
+        const runtime = sessionService.getRuntimeSnapshot('session-1');
+        expect(runtime).toEqual({
+            phase: 'idle',
+            processState: 'alive',
+            activity: 'IDLE',
+            updatedAt,
         });
-        vi.mocked(sessionProcessManager.isStopInProgress).mockReturnValue(false);
-        vi.mocked(sessionProcessManager.getOrCreateClient).mockResolvedValue(client);
-        await sessionService.startClaudeSession('session-1');
-        const startSessionCalls = vi.mocked(sessionRepository.updateSession).mock.calls;
-        expect(getOrCreateCalls).toEqual(expect.arrayContaining([
-            expect.arrayContaining([
-                'session-1',
-                {
-                    status: SessionStatus.RUNNING,
-                    claudeProcessPid: 888,
-                },
-            ]),
-        ]));
-        expect(startSessionCalls).toEqual(expect.arrayContaining([
-            expect.arrayContaining([
-                'session-1',
-                {
-                    status: SessionStatus.RUNNING,
-                    claudeProcessPid: 888,
-                },
-            ]),
-        ]));
+    });
+    it('stops all ACP clients during shutdown', async () => {
+        vi.mocked(acpRuntimeManager.stopAllClients).mockResolvedValue(undefined);
+        await sessionService.stopAllClients(4321);
+        expect(acpRuntimeManager.stopAllClients).toHaveBeenCalledTimes(1);
+    });
+    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');
     });
 });
 //# sourceMappingURL=session.service.test.js.map