factory-factory 0.4.0 → 0.4.2

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

@@ -82,13 +82,13 @@ vi.mock('@/backend/services/session/service/logging/acp-trace-logger.service', (
     },
 }));
 import { acpRuntimeManager } from '../../../../../backend/services/session/service/acp/index.js';
-import { workspaceAccessor } from '../../../../../backend/services/workspace/index.js';
+import { workspaceDataService } from '../../../../../backend/services/workspace/index.js';
 import { closedSessionPersistenceService } from './closed-session-persistence.service.js';
 import { sessionPromptBuilder } from './session.prompt-builder.js';
 import { sessionRepository } from './session.repository.js';
-import { sessionService } from './session.service.js';
+import { acpEventProcessor, sessionLifecycleService, sessionPromptTurnCompletionService, sessionService, } from './session-services.js';
 function getAcpProcessorState() {
-    return sessionService.acpEventProcessor;
+    return acpEventProcessor;
 }
 function mockCreatedAcpClient(acpHandle) {
     vi.mocked(acpRuntimeManager.getOrCreateClient).mockImplementation(() => {
@@ -116,20 +116,25 @@ describe('SessionService', () => {
         acpProcessor.pendingAcpToolCalls.clear();
         acpProcessor.sessionToWorkspace.clear();
         acpProcessor.sessionToWorkingDir.clear();
-        sessionService.setPromptTurnCompleteHandler(null);
+        sessionPromptTurnCompletionService.setHandler(null);
+        const workspaceBridge = {
+            markSessionRunning: vi.fn(),
+            markSessionIdle: vi.fn(),
+            recordRatchetSessionEnd: mockRecordRatchetSessionEnd,
+            resetPRDiscoveryBackoff: vi.fn(async () => true),
+        };
         sessionService.configure({
-            workspace: {
-                markSessionRunning: vi.fn(),
-                markSessionIdle: vi.fn(),
-                recordRatchetSessionEnd: mockRecordRatchetSessionEnd,
-            },
+            workspace: workspaceBridge,
+        });
+        sessionLifecycleService.configure({
+            workspace: workspaceBridge,
         });
         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);
-        vi.mocked(workspaceAccessor.findById).mockResolvedValue(unsafeCoerce({
+        vi.mocked(workspaceDataService.findById).mockResolvedValue(unsafeCoerce({
             id: 'workspace-1',
             worktreePath: '/tmp/work',
         }));
@@ -178,7 +183,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
-        await sessionService.startSession('session-1', { initialPrompt: 'Hello' });
+        await sessionLifecycleService.startSession('session-1', { initialPrompt: 'Hello' });
         expect(sessionPromptBuilder.shouldInjectBranchRename).toHaveBeenCalledWith({
             branchName: 'auto-branch',
             isAutoGeneratedBranch: true,
@@ -237,7 +242,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
-        await sessionService.startSession('session-1', { initialPrompt: '' });
+        await sessionLifecycleService.startSession('session-1', { initialPrompt: '' });
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
             status: SessionStatus.RUNNING,
         });
@@ -278,7 +283,7 @@ describe('SessionService', () => {
             injectedBranchRename: false,
         });
         mockCreatedAcpClient(acpHandle);
-        const result = await sessionService.getOrCreateSessionClient('session-1');
+        const result = await sessionLifecycleService.getOrCreateSessionClient('session-1');
         expect(result).toBe(acpHandle);
         expect(acpRuntimeManager.getOrCreateClient).toHaveBeenCalledWith('session-1', expect.objectContaining({
             workingDir: '/tmp/work',
@@ -327,7 +332,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         const injectUserMessageSpy = vi.spyOn(sessionDomainService, 'injectCommittedUserMessage');
-        await sessionService.getOrCreateSessionClient('session-1');
+        await sessionLifecycleService.getOrCreateSessionClient('session-1');
         const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
         acpHandlers.onAcpEvent('session-1', {
             type: 'acp_session_update',
@@ -374,7 +379,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         const injectUserMessageSpy = vi.spyOn(sessionDomainService, 'injectCommittedUserMessage');
-        await sessionService.getOrCreateSessionClient('session-1');
+        await sessionLifecycleService.getOrCreateSessionClient('session-1');
         const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
         expect(() => acpHandlers.onAcpEvent('session-1', unsafeCoerce({
             type: 'acp_session_update',
@@ -433,7 +438,7 @@ describe('SessionService', () => {
         ]);
         try {
             const injectUserMessageSpy = vi.spyOn(sessionDomainService, 'injectCommittedUserMessage');
-            await sessionService.getOrCreateSessionClient('session-1');
+            await sessionLifecycleService.getOrCreateSessionClient('session-1');
             const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
             acpHandlers.onAcpEvent('session-1', {
                 type: 'acp_session_update',
@@ -485,7 +490,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         const injectUserMessageSpy = vi.spyOn(sessionDomainService, 'injectCommittedUserMessage');
-        await sessionService.getOrCreateSessionClient('session-1');
+        await sessionLifecycleService.getOrCreateSessionClient('session-1');
         vi.mocked(acpRuntimeManager.isSessionWorking).mockReturnValue(true);
         const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
         acpHandlers.onAcpEvent('session-1', {
@@ -601,7 +606,7 @@ describe('SessionService', () => {
             injectedBranchRename: false,
         });
         mockCreatedAcpClient(acpHandle);
-        const result = await sessionService.getOrCreateSessionClientFromRecord(session);
+        const result = await sessionLifecycleService.getOrCreateSessionClientFromRecord(session);
         expect(result).toBe(acpHandle);
         expect(sessionRepository.getSessionById).not.toHaveBeenCalled();
         expect(acpRuntimeManager.getOrCreateClient).toHaveBeenCalledWith('session-1', expect.objectContaining({
@@ -646,14 +651,14 @@ describe('SessionService', () => {
             injectedBranchRename: false,
         });
         mockCreatedAcpClient(acpHandle);
-        await sessionService.getOrCreateSessionClientFromRecord(session);
+        await sessionLifecycleService.getOrCreateSessionClientFromRecord(session);
         const stopLoad = createDeferred();
         vi.mocked(sessionRepository.getSessionById).mockReturnValueOnce(stopLoad.promise);
         vi.mocked(sessionRepository.updateSession).mockClear();
         vi.mocked(sessionRepository.updateSession).mockResolvedValue(session);
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
         vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
-        const stopPromise = sessionService.stopSession('session-race-test');
+        const stopPromise = sessionLifecycleService.stopSession('session-race-test');
         await Promise.resolve();
         const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
         await acpHandlers.onExit('session-race-test', 0);
@@ -672,7 +677,7 @@ describe('SessionService', () => {
     it('still clears lifecycle state when only the runtime is already stopping', async () => {
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(true);
         const clearQueuedWorkSpy = vi.spyOn(sessionDomainService, 'clearQueuedWork');
-        await sessionService.stopSession('session-1');
+        await sessionLifecycleService.stopSession('session-1');
         expect(acpRuntimeManager.stopClient).not.toHaveBeenCalled();
         expect(sessionRepository.updateSessionIfStatus).not.toHaveBeenCalled();
         expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: true });
@@ -717,15 +722,15 @@ describe('SessionService', () => {
         });
         vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
         mockCreatedAcpClient(acpHandle);
-        const stopPromise = sessionService.stopSession('session-1');
+        const stopPromise = sessionLifecycleService.stopSession('session-1');
         await vi.waitFor(() => {
             expect(sessionRepository.getSessionById).toHaveBeenCalledTimes(1);
         });
-        const startError = await sessionService
+        const startError = await sessionLifecycleService
             .startSession('session-1', { initialPrompt: '' })
             .then(() => null)
             .catch((error) => error);
-        const acquisitionError = await sessionService
+        const acquisitionError = await sessionLifecycleService
             .getOrCreateSessionClientFromRecord(session)
             .then(() => null)
             .catch((error) => error);
@@ -740,7 +745,7 @@ describe('SessionService', () => {
         vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
         const clearQueuedWorkSpy = vi.spyOn(sessionDomainService, 'clearQueuedWork');
-        await sessionService.stopSession('session-1');
+        await sessionLifecycleService.stopSession('session-1');
         expect(clearQueuedWorkSpy).toHaveBeenCalledWith('session-1', { emitSnapshot: true });
     });
     it('clears queued work before waiting for the runtime to stop', async () => {
@@ -749,7 +754,7 @@ describe('SessionService', () => {
         vi.mocked(acpRuntimeManager.stopClient).mockReturnValue(runtimeStop.promise);
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
         const clearQueuedWorkSpy = vi.spyOn(sessionDomainService, 'clearQueuedWork');
-        const stopPromise = sessionService.stopSession('session-1');
+        const stopPromise = sessionLifecycleService.stopSession('session-1');
         await vi.waitFor(() => {
             expect(acpRuntimeManager.stopClient).toHaveBeenCalledWith('session-1');
         });
@@ -775,7 +780,7 @@ describe('SessionService', () => {
         const secondRejection = expect(secondSend).rejects.toMatchObject({ name: 'AbortError' });
         await Promise.resolve();
         expect(acpRuntimeManager.sendPrompt).toHaveBeenCalledTimes(1);
-        await sessionService.stopSession('session-queued-stop');
+        await sessionLifecycleService.stopSession('session-queued-stop');
         await secondRejection;
         expect(acpRuntimeManager.sendPrompt).toHaveBeenCalledTimes(1);
         firstPrompt.resolve({ stopReason: 'end_turn' });
@@ -795,7 +800,7 @@ describe('SessionService', () => {
         ]);
         await Promise.resolve();
         expect(acpRuntimeManager.sendPrompt).toHaveBeenCalledTimes(1);
-        await sessionService.stopSession('session-restarted-after-stop');
+        await sessionLifecycleService.stopSession('session-restarted-after-stop');
         const restartedSend = sessionService.sendAcpMessage('session-restarted-after-stop', [
             { type: 'text', text: 'after restart' },
         ]);
@@ -813,6 +818,7 @@ describe('SessionService', () => {
                 markSessionRunning,
                 markSessionIdle,
                 recordRatchetSessionEnd: mockRecordRatchetSessionEnd,
+                resetPRDiscoveryBackoff: vi.fn(async () => true),
             },
         });
         const acpProcessor = getAcpProcessorState();
@@ -866,7 +872,7 @@ describe('SessionService', () => {
             injectedBranchRename: false,
         });
         mockCreatedAcpClient(acpHandle);
-        await sessionService.getOrCreateSessionClient('session-runtime-exit');
+        await sessionLifecycleService.getOrCreateSessionClient('session-runtime-exit');
         const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
         const firstPrompt = createDeferred();
         vi.mocked(acpRuntimeManager.sendPrompt).mockReturnValueOnce(firstPrompt.promise);
@@ -922,7 +928,7 @@ describe('SessionService', () => {
             injectedBranchRename: false,
         });
         mockCreatedAcpClient(acpHandle);
-        await sessionService.getOrCreateSessionClient('session-runtime-exit');
+        await sessionLifecycleService.getOrCreateSessionClient('session-runtime-exit');
         const pendingToolCalls = getAcpProcessorState().pendingAcpToolCalls;
         pendingToolCalls.set('session-runtime-exit', new Map([
             [
@@ -981,7 +987,7 @@ describe('SessionService', () => {
         const secondRejection = expect(secondSend).rejects.toMatchObject({ name: 'AbortError' });
         await Promise.resolve();
         expect(acpRuntimeManager.sendPrompt).toHaveBeenCalledTimes(1);
-        await sessionService.stopSession('session-active-stop');
+        await sessionLifecycleService.stopSession('session-active-stop');
         await secondRejection;
         const thirdSend = sessionService.sendAcpMessage('session-active-stop', [
             { type: 'text', text: 'third' },
@@ -998,7 +1004,7 @@ describe('SessionService', () => {
         vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
         const clearSessionSpy = vi.spyOn(sessionDomainService, 'clearSession');
-        await sessionService.stopSession('session-clear');
+        await sessionLifecycleService.stopSession('session-clear');
         expect(clearSessionSpy).toHaveBeenCalledWith('session-clear');
     });
     it('keeps in-memory session state after manual stop when clients are connected', async () => {
@@ -1008,7 +1014,7 @@ describe('SessionService', () => {
         const clearSessionSpy = vi.spyOn(sessionDomainService, 'clearSession');
         sessionEventBus.registerViewerCountProvider((sessionId) => sessionId === 'session-active' ? 1 : 0);
         try {
-            await sessionService.stopSession('session-active');
+            await sessionLifecycleService.stopSession('session-active');
         }
         finally {
             sessionEventBus.registerViewerCountProvider(null);
@@ -1017,11 +1023,12 @@ describe('SessionService', () => {
     });
     it('marks workspace session idle during manual stop', async () => {
         const markSessionIdle = vi.fn();
-        sessionService.configure({
+        sessionLifecycleService.configure({
             workspace: {
                 markSessionRunning: vi.fn(),
                 markSessionIdle,
                 recordRatchetSessionEnd: mockRecordRatchetSessionEnd,
+                resetPRDiscoveryBackoff: vi.fn(async () => true),
             },
         });
         vi.mocked(acpRuntimeManager.isStopInProgress).mockReturnValue(false);
@@ -1031,7 +1038,7 @@ describe('SessionService', () => {
             workspaceId: 'workspace-1',
         }));
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
-        await sessionService.stopSession('session-1');
+        await sessionLifecycleService.stopSession('session-1');
         expect(markSessionIdle).toHaveBeenCalledWith('workspace-1', 'session-1');
     });
     it('still clears queued work and marks idle when runtime stop fails', async () => {
@@ -1044,7 +1051,7 @@ describe('SessionService', () => {
         }));
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
         const clearQueuedWorkSpy = vi.spyOn(sessionDomainService, 'clearQueuedWork');
-        await sessionService.stopSession('session-1');
+        await sessionLifecycleService.stopSession('session-1');
         expect(sessionRepository.updateSessionIfStatus).toHaveBeenCalledWith('session-1', {
             status: SessionStatus.IDLE,
         }, [SessionStatus.RUNNING]);
@@ -1075,7 +1082,7 @@ describe('SessionService', () => {
         const appendClaudeEventSpy = vi
             .spyOn(sessionDomainService, 'appendClaudeEvent')
             .mockReturnValue(77);
-        await sessionService.stopSession('session-1');
+        await sessionLifecycleService.stopSession('session-1');
         expect(emitDeltaSpy).toHaveBeenCalledWith('session-1', expect.objectContaining({
             type: 'tool_progress',
             tool_use_id: 'call-1',
@@ -1099,11 +1106,12 @@ describe('SessionService', () => {
     });
     it('continues stop cleanup when orphaned tool-call finalization throws', async () => {
         const markSessionIdle = vi.fn();
-        sessionService.configure({
+        sessionLifecycleService.configure({
             workspace: {
                 markSessionRunning: vi.fn(),
                 markSessionIdle,
                 recordRatchetSessionEnd: mockRecordRatchetSessionEnd,
+                resetPRDiscoveryBackoff: vi.fn(async () => true),
             },
         });
         const pendingToolCalls = getAcpProcessorState().pendingAcpToolCalls;
@@ -1127,7 +1135,7 @@ describe('SessionService', () => {
         vi.spyOn(sessionDomainService, 'emitDelta').mockImplementationOnce(() => {
             throw new Error('emit failed');
         });
-        await sessionService.stopSession('session-1');
+        await sessionLifecycleService.stopSession('session-1');
         expect(sessionRepository.updateSessionIfStatus).toHaveBeenCalledWith('session-1', {
             status: SessionStatus.IDLE,
         }, [SessionStatus.RUNNING]);
@@ -1162,7 +1170,7 @@ describe('SessionService', () => {
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
         vi.mocked(sessionRepository.deleteSession).mockResolvedValue({});
         try {
-            await sessionService.stopSession('session-1');
+            await sessionLifecycleService.stopSession('session-1');
             expect(mockRecordRatchetSessionEnd).toHaveBeenCalledWith('workspace-1', 'session-1', 'COMPLETED');
             expect(closedSessionPersistenceService.persistClosedSession).toHaveBeenCalledWith({
                 sessionId: 'session-1',
@@ -1196,7 +1204,7 @@ describe('SessionService', () => {
         }));
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
         vi.mocked(closedSessionPersistenceService.persistClosedSession).mockRejectedValue(new Error('Disk full'));
-        await sessionService.stopSession('session-1');
+        await sessionLifecycleService.stopSession('session-1');
         expect(closedSessionPersistenceService.persistClosedSession).toHaveBeenCalledTimes(1);
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
@@ -1209,7 +1217,7 @@ describe('SessionService', () => {
             workflow: 'default',
         }));
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
-        await sessionService.stopSession('session-2');
+        await sessionLifecycleService.stopSession('session-2');
         expect(sessionRepository.deleteSession).not.toHaveBeenCalled();
     });
     it('clears ratchet pointer but does not delete session when transient cleanup is disabled', async () => {
@@ -1221,7 +1229,7 @@ describe('SessionService', () => {
             workflow: 'ratchet',
         }));
         vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
-        await sessionService.stopSession('session-3', {
+        await sessionLifecycleService.stopSession('session-3', {
             cleanupTransientRatchetSession: false,
         });
         expect(mockRecordRatchetSessionEnd).toHaveBeenCalledWith('workspace-1', 'session-3', 'COMPLETED');
@@ -1259,7 +1267,7 @@ 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');
+        await expect(sessionLifecycleService.getOrCreateSessionClient('session-1')).rejects.toThrow('spawn failed');
         expect(setRuntimeSnapshotSpy).toHaveBeenNthCalledWith(1, 'session-1', expect.objectContaining({
             phase: 'starting',
             processState: 'alive',
@@ -1274,7 +1282,7 @@ describe('SessionService', () => {
     });
     it('throws when session not found during client creation', async () => {
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(null);
-        await expect(sessionService.getOrCreateSessionClient('session-1')).rejects.toThrow('Session not found: session-1');
+        await expect(sessionLifecycleService.getOrCreateSessionClient('session-1')).rejects.toThrow('Session not found: session-1');
     });
     it('returns null session options when workspace is missing', async () => {
         const session = unsafeCoerce({
@@ -1287,7 +1295,7 @@ describe('SessionService', () => {
         });
         vi.mocked(sessionRepository.getSessionById).mockResolvedValue(session);
         vi.mocked(sessionRepository.getWorkspaceById).mockResolvedValue(null);
-        const options = await sessionService.getSessionOptions('session-1');
+        const options = await sessionLifecycleService.getSessionOptions('session-1');
         expect(options).toBeNull();
     });
     it('clears ratchetActiveSessionId and deletes session on ACP ratchet exit', async () => {
@@ -1332,7 +1340,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
-        await sessionService.startSession('session-1');
+        await sessionLifecycleService.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', {
@@ -1384,7 +1392,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
-        await sessionService.startSession('session-1');
+        await sessionLifecycleService.startSession('session-1');
         const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
         await expect(acpHandlers.onExit('session-1', 0)).resolves.toBeUndefined();
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
@@ -1429,7 +1437,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
-        await sessionService.startSession('session-2');
+        await sessionLifecycleService.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', {
@@ -1476,7 +1484,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
-        await sessionService.startSession('session-2');
+        await sessionLifecycleService.startSession('session-2');
         const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
         await acpHandlers.onExit('session-2', exitCode);
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-2', {
@@ -1495,7 +1503,7 @@ describe('SessionService', () => {
         vi.mocked(acpRuntimeManager.isSessionRunning).mockImplementation(() => {
             throw new Error('isSessionRunning failed');
         });
-        await expect(sessionService.stopSession('session-1')).rejects.toThrow('isSessionRunning failed');
+        await expect(sessionLifecycleService.stopSession('session-1')).rejects.toThrow('isSessionRunning failed');
         expect(mockAcpTraceLoggerCloseSession).toHaveBeenCalledWith('session-1');
     });
     it('closes ACP trace session even when runtime-exit cleanup throws', async () => {
@@ -1534,7 +1542,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
-        await sessionService.startSession('session-2');
+        await sessionLifecycleService.startSession('session-2');
         const acpHandlers = vi.mocked(acpRuntimeManager.getOrCreateClient).mock.calls[0][2];
         vi.mocked(acpRuntimeManager.isSessionRunning).mockImplementation(() => {
             throw new Error('isSessionRunning failed');
@@ -1577,7 +1585,7 @@ describe('SessionService', () => {
             injectedBranchRename: false,
         });
         mockCreatedAcpClient(acpHandle);
-        await sessionService.getOrCreateSessionClient('session-1');
+        await sessionLifecycleService.getOrCreateSessionClient('session-1');
         expect(acpRuntimeManager.getOrCreateClient).toHaveBeenCalled();
         expect(sessionRepository.updateSession).toHaveBeenCalledWith('session-1', {
             status: SessionStatus.RUNNING,
@@ -1629,6 +1637,18 @@ describe('SessionService', () => {
         await sessionService.sendAcpMessage('session-1', [{ type: 'text', text: 'hello' }]);
         expect(appendClaudeEventSpy).not.toHaveBeenCalled();
     });
+    it('closes assistant text streaming when an ACP prompt completes', async () => {
+        vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
+        const finishPromptTurnSpy = vi.spyOn(getAcpProcessorState(), 'finishPromptTurn');
+        await sessionService.sendAcpMessage('session-1', [{ type: 'text', text: 'hello' }]);
+        expect(finishPromptTurnSpy).toHaveBeenCalledWith('session-1');
+    });
+    it('closes assistant text streaming when an ACP prompt fails', async () => {
+        vi.mocked(acpRuntimeManager.sendPrompt).mockRejectedValue(new Error('prompt failed'));
+        const finishPromptTurnSpy = vi.spyOn(getAcpProcessorState(), 'finishPromptTurn');
+        await expect(sessionService.sendAcpMessage('session-1', [{ type: 'text', text: 'hello' }])).rejects.toThrow('prompt failed');
+        expect(finishPromptTurnSpy).toHaveBeenCalledWith('session-1');
+    });
     it('requests prompt cancellation instead of hard-stopping on tool timeout', async () => {
         vi.useFakeTimers();
         try {
@@ -1672,7 +1692,7 @@ describe('SessionService', () => {
         vi.useFakeTimers();
         try {
             const onPromptTurnComplete = vi.fn().mockResolvedValue(undefined);
-            sessionService.setPromptTurnCompleteHandler(onPromptTurnComplete);
+            sessionPromptTurnCompletionService.setHandler(onPromptTurnComplete);
             vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({
                 stopReason: 'end_turn',
             });
@@ -1689,7 +1709,7 @@ describe('SessionService', () => {
         vi.useFakeTimers();
         try {
             const onPromptTurnComplete = vi.fn().mockResolvedValue(undefined);
-            sessionService.setPromptTurnCompleteHandler(onPromptTurnComplete);
+            sessionPromptTurnCompletionService.setHandler(onPromptTurnComplete);
             vi.mocked(acpRuntimeManager.sendPrompt).mockRejectedValue({
                 code: -32_600,
                 message: 'Invalid request',
@@ -1709,7 +1729,7 @@ describe('SessionService', () => {
         vi.useFakeTimers();
         try {
             const onPromptTurnComplete = vi.fn().mockResolvedValue(undefined);
-            sessionService.setPromptTurnCompleteHandler(onPromptTurnComplete);
+            sessionPromptTurnCompletionService.setHandler(onPromptTurnComplete);
             vi.mocked(acpRuntimeManager.sendPrompt).mockRejectedValue(new Error('network blip'));
             await expect(sessionService.sendAcpMessage('session-1', [{ type: 'text', text: 'hello' }])).rejects.toThrow('network blip');
             expect(onPromptTurnComplete).not.toHaveBeenCalled();
@@ -1724,14 +1744,14 @@ describe('SessionService', () => {
         vi.useFakeTimers();
         try {
             const onPromptTurnComplete = vi.fn().mockResolvedValue(undefined);
-            sessionService.setPromptTurnCompleteHandler(onPromptTurnComplete);
+            sessionPromptTurnCompletionService.setHandler(onPromptTurnComplete);
             vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({
                 stopReason: 'end_turn',
             });
             vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
             vi.mocked(sessionRepository.updateSession).mockResolvedValue({});
             await sessionService.sendAcpMessage('session-1', [{ type: 'text', text: 'hello' }]);
-            await sessionService.stopSession('session-1');
+            await sessionLifecycleService.stopSession('session-1');
             await vi.runOnlyPendingTimersAsync();
             expect(onPromptTurnComplete).not.toHaveBeenCalled();
         }
@@ -1745,14 +1765,14 @@ describe('SessionService', () => {
             const prompt = createDeferred();
             const runtimeStop = createDeferred();
             const onPromptTurnComplete = vi.fn().mockResolvedValue(undefined);
-            sessionService.setPromptTurnCompleteHandler(onPromptTurnComplete);
+            sessionPromptTurnCompletionService.setHandler(onPromptTurnComplete);
             vi.mocked(acpRuntimeManager.sendPrompt).mockReturnValue(prompt.promise);
             vi.mocked(acpRuntimeManager.stopClient).mockReturnValue(runtimeStop.promise);
             const sendPromise = sessionService.sendAcpMessage('session-1', [
                 { type: 'text', text: 'hello' },
             ]);
             await Promise.resolve();
-            const stopPromise = sessionService.stopSession('session-1');
+            const stopPromise = sessionLifecycleService.stopSession('session-1');
             await vi.waitFor(() => {
                 expect(acpRuntimeManager.stopClient).toHaveBeenCalledWith('session-1');
             });
@@ -1768,11 +1788,100 @@ describe('SessionService', () => {
             vi.useRealTimers();
         }
     });
+    it('preserves stopped runtime when an in-flight prompt times out after stop completes', async () => {
+        vi.useFakeTimers();
+        const sessionId = 'session-prompt-timeout-after-stop';
+        sessionEventBus.registerViewerCountProvider((viewedSessionId) => viewedSessionId === sessionId ? 1 : 0);
+        const publishToSessionSpy = vi.spyOn(sessionEventBus, 'publishToSession');
+        try {
+            const prompt = createDeferred();
+            const onPromptTurnComplete = vi.fn().mockResolvedValue(undefined);
+            sessionPromptTurnCompletionService.setHandler(onPromptTurnComplete);
+            vi.mocked(acpRuntimeManager.sendPrompt).mockReturnValue(prompt.promise);
+            vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
+            const sendPromise = sessionService.sendAcpMessage(sessionId, [
+                { type: 'text', text: 'hello' },
+            ]);
+            const sendRejection = expect(sendPromise).rejects.toThrow('Prompt timed out');
+            await vi.waitFor(() => {
+                expect(acpRuntimeManager.sendPrompt).toHaveBeenCalledWith(sessionId, [{ type: 'text', text: 'hello' }], undefined);
+            });
+            await sessionLifecycleService.stopSession(sessionId);
+            expect(sessionLifecycleService.isSessionStopping(sessionId)).toBe(false);
+            publishToSessionSpy.mockClear();
+            prompt.reject(new Error('Prompt timed out'));
+            await sendRejection;
+            await vi.runOnlyPendingTimersAsync();
+            expect(sessionLifecycleService.getRuntimeSnapshot(sessionId)).toMatchObject({
+                phase: 'idle',
+                processState: 'stopped',
+                activity: 'IDLE',
+            });
+            expect(publishToSessionSpy).not.toHaveBeenCalledWith(sessionId, expect.objectContaining({
+                type: 'session_delta',
+                data: expect.objectContaining({
+                    type: 'session_runtime_updated',
+                    sessionRuntime: expect.objectContaining({ processState: 'alive' }),
+                }),
+            }));
+            expect(onPromptTurnComplete).not.toHaveBeenCalled();
+        }
+        finally {
+            publishToSessionSpy.mockRestore();
+            sessionEventBus.registerViewerCountProvider(null);
+            vi.useRealTimers();
+        }
+    });
+    it('does not finalize a restarted prompt when a stopped prompt later times out', async () => {
+        const sessionId = 'session-restarted-before-old-prompt-timeout';
+        const stoppedPrompt = createDeferred();
+        const restartedPrompt = createDeferred();
+        vi.mocked(acpRuntimeManager.sendPrompt)
+            .mockReturnValueOnce(stoppedPrompt.promise)
+            .mockReturnValueOnce(restartedPrompt.promise);
+        vi.mocked(acpRuntimeManager.stopClient).mockResolvedValue();
+        const stoppedSend = sessionService.sendAcpMessage(sessionId, [
+            { type: 'text', text: 'before stop' },
+        ]);
+        const stoppedSendRejection = expect(stoppedSend).rejects.toThrow('Prompt timed out');
+        await vi.waitFor(() => {
+            expect(acpRuntimeManager.sendPrompt).toHaveBeenCalledTimes(1);
+        });
+        await sessionLifecycleService.stopSession(sessionId);
+        const restartedSend = sessionService.sendAcpMessage(sessionId, [
+            { type: 'text', text: 'after restart' },
+        ]);
+        await vi.waitFor(() => {
+            expect(acpRuntimeManager.sendPrompt).toHaveBeenCalledTimes(2);
+        });
+        const pendingToolCalls = getAcpProcessorState().pendingAcpToolCalls;
+        pendingToolCalls.set(sessionId, new Map([
+            [
+                'restarted-call',
+                {
+                    toolUseId: 'restarted-call',
+                    toolName: 'Run tests',
+                },
+            ],
+        ]));
+        const appendClaudeEventSpy = vi
+            .spyOn(sessionDomainService, 'appendClaudeEvent')
+            .mockReturnValue(88);
+        stoppedPrompt.reject(new Error('Prompt timed out'));
+        await stoppedSendRejection;
+        const restartedToolCallSurvived = pendingToolCalls.get(sessionId)?.has('restarted-call');
+        const stalePromptFinalizedToolCall = appendClaudeEventSpy.mock.calls.length > 0;
+        pendingToolCalls.delete(sessionId);
+        restartedPrompt.resolve({ stopReason: 'end_turn' });
+        await expect(restartedSend).resolves.toBe('end_turn');
+        expect(restartedToolCallSurvived).toBe(true);
+        expect(stalePromptFinalizedToolCall).toBe(false);
+    });
     it('swallows prompt-turn completion callback failures', async () => {
         vi.useFakeTimers();
         try {
             const onPromptTurnComplete = vi.fn().mockRejectedValue(new Error('dispatch failed'));
-            sessionService.setPromptTurnCompleteHandler(onPromptTurnComplete);
+            sessionPromptTurnCompletionService.setHandler(onPromptTurnComplete);
             vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({
                 stopReason: 'end_turn',
             });
@@ -1821,7 +1930,7 @@ describe('SessionService', () => {
         });
         mockCreatedAcpClient(acpHandle);
         vi.mocked(acpRuntimeManager.sendPrompt).mockResolvedValue({ stopReason: 'end_turn' });
-        await sessionService.startSession('session-1', { initialPrompt: 'go' });
+        await sessionLifecycleService.startSession('session-1', { initialPrompt: 'go' });
         expect(sessionRepository.getSessionById).toHaveBeenCalledTimes(1);
     });
     it('normalizes stale loading runtime to idle when no process is active', () => {
@@ -1831,7 +1940,7 @@ describe('SessionService', () => {
             activity: 'IDLE',
             updatedAt: new Date('2026-02-10T01:45:35.844Z').toISOString(),
         });
-        const runtime = sessionService.getRuntimeSnapshot('session-1');
+        const runtime = sessionLifecycleService.getRuntimeSnapshot('session-1');
         expect(runtime).toMatchObject({
             phase: 'idle',
             processState: 'stopped',
@@ -1845,7 +1954,7 @@ describe('SessionService', () => {
             activity: 'IDLE',
             updatedAt: new Date().toISOString(),
         });
-        const runtime = sessionService.getRuntimeSnapshot('session-1');
+        const runtime = sessionLifecycleService.getRuntimeSnapshot('session-1');
         expect(runtime).toMatchObject({
             phase: 'loading',
             processState: 'unknown',
@@ -1865,7 +1974,7 @@ describe('SessionService', () => {
             configOptions: [],
         }));
         vi.mocked(acpRuntimeManager.isSessionWorking).mockReturnValue(false);
-        const runtime = sessionService.getRuntimeSnapshot('session-1');
+        const runtime = sessionLifecycleService.getRuntimeSnapshot('session-1');
         expect(runtime).toEqual({
             phase: 'idle',
             processState: 'alive',
@@ -1875,13 +1984,13 @@ describe('SessionService', () => {
     });
     it('stops all ACP clients during shutdown', async () => {
         vi.mocked(acpRuntimeManager.stopAllClients).mockResolvedValue(undefined);
-        await sessionService.stopAllClients(4321);
+        await sessionLifecycleService.stopAllClients(4321);
         expect(acpRuntimeManager.stopAllClients).toHaveBeenCalledTimes(1);
         expect(acpRuntimeManager.stopAllClients).toHaveBeenCalledWith(4321);
     });
     it('propagates ACP shutdown failure', async () => {
         vi.mocked(acpRuntimeManager.stopAllClients).mockRejectedValueOnce(new Error('acp shutdown failed'));
-        await expect(sessionService.stopAllClients()).rejects.toThrow('acp shutdown failed');
+        await expect(sessionLifecycleService.stopAllClients()).rejects.toThrow('acp shutdown failed');
         expect(acpRuntimeManager.stopAllClients).toHaveBeenCalledWith(5000);
     });
 });