factory-factory 0.4.1 → 0.4.2

package/dist/src/backend/orchestration/domain-bridges.orchestrator.test.js

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { autoIterationService, logbookService, } from '../../backend/services/auto-iteration/index.js';
+import { AutoIterationStatus, SessionStatus } from '../../shared/core/index.js';
 const mockLogger = vi.hoisted(() => ({
     info: vi.fn(),
     debug: vi.fn(),
@@ -22,7 +23,6 @@ vi.mock('./reconciliation.service', () => ({
     reconciliationService: { configure: vi.fn() },
 }));
 vi.mock('@/backend/services/workspace', () => ({
-    kanbanStateService: { configure: vi.fn(), updateCachedKanbanColumn: vi.fn() },
     WorkspaceCreationService: class {
         create = mockWorkspaceCreationService.create;
     },
@@ -65,25 +65,35 @@ vi.mock('@/backend/services/workspace', () => ({
     getWorkspaceInitPolicy: vi.fn(),
 }));
 vi.mock('@/backend/services/session', () => ({
+    acpRuntimeManager: {
+        isSessionRunning: vi.fn(),
+        isSessionWorking: vi.fn(),
+        isAnySessionWorking: vi.fn(),
+    },
     sessionDataService: {
         findAgentSessionById: vi.fn(),
         createAgentSession: vi.fn(),
+        deleteAgentSession: vi.fn(),
+        updateAgentSession: vi.fn(),
         findAgentSessionsByWorkspaceId: vi.fn(),
         acquireFixerSession: vi.fn(),
     },
     sessionService: {
         configure: vi.fn(),
-        setPromptTurnCompleteHandler: vi.fn(),
-        isSessionRunning: vi.fn(),
-        isSessionWorking: vi.fn(),
-        isAnySessionWorking: vi.fn(),
+        sendSessionMessage: vi.fn(),
+        sendAcpMessage: vi.fn(),
+    },
+    sessionLifecycleService: {
+        configure: vi.fn(),
         getRuntimeSnapshot: vi.fn(),
         stopSession: vi.fn(),
         startSession: vi.fn(),
-        sendSessionMessage: vi.fn(),
-        sendAcpMessage: vi.fn(),
+    },
+    sessionPromptTurnCompletionService: {
+        setHandler: vi.fn(),
     },
     sessionDomainService: {
+        clearSession: vi.fn(),
         injectCommittedUserMessage: vi.fn(),
         getTranscriptSnapshot: vi.fn(),
         getQueueLength: vi.fn(),
@@ -103,12 +113,8 @@ vi.mock('@/backend/services/github', () => ({
         checkHealth: vi.fn(),
         listReviewRequests: vi.fn(),
     },
-    prFetchRegistry: {
-        isRecentlyFetched: vi.fn(),
-        isFetchInFlight: vi.fn(),
-        register: vi.fn(),
-        startFetch: vi.fn(),
-        cancelFetch: vi.fn(),
+    prFetchCoordinator: {
+        coordinate: vi.fn(),
     },
     prSnapshotService: { configure: vi.fn(), refreshWorkspace: vi.fn() },
 }));
@@ -124,14 +130,14 @@ vi.mock('@/backend/services/terminal', () => ({
 vi.mock('./workspace-init.orchestrator', () => ({
     initializeWorkspaceWorktree: vi.fn(),
 }));
-import { githubCLIService, prFetchRegistry, prSnapshotService } from '../../backend/services/github/index.js';
+import { githubCLIService, prFetchCoordinator, prSnapshotService } from '../../backend/services/github/index.js';
 import { createLogger } from '../../backend/services/logger.service.js';
 import { periodicTaskService } from '../../backend/services/periodic-task/index.js';
 import { fixerSessionService, ratchetService } from '../../backend/services/ratchet/index.js';
 import { startupScriptService } from '../../backend/services/run-script/index.js';
-import { chatEventForwarderService, chatMessageHandlerService, sessionDataService, sessionDomainService, sessionService, } from '../../backend/services/session/index.js';
+import { acpRuntimeManager, chatEventForwarderService, chatMessageHandlerService, sessionDataService, sessionDomainService, sessionLifecycleService, sessionPromptTurnCompletionService, sessionService, } from '../../backend/services/session/index.js';
 import { terminalSessionService } from '../../backend/services/terminal/index.js';
-import { getWorkspaceInitPolicy, kanbanStateService, workspaceActivityService, workspaceAutoIterationService, workspaceDataService, workspaceMaintenanceService, workspacePrSnapshotService, workspaceQueryService, workspaceRatchetService, workspaceRunScriptService, workspaceSnapshotStore, workspaceStateMachine, } from '../../backend/services/workspace/index.js';
+import { getWorkspaceInitPolicy, workspaceActivityService, workspaceAutoIterationService, workspaceDataService, workspaceMaintenanceService, workspacePrSnapshotService, workspaceQueryService, workspaceRatchetService, workspaceRunScriptService, workspaceSnapshotStore, workspaceStateMachine, } from '../../backend/services/workspace/index.js';
 import { configureDomainBridges } from './domain-bridges.orchestrator.js';
 import { reconciliationService } from './reconciliation.service.js';
 import { initializeWorkspaceWorktree } from './workspace-init.orchestrator.js';
@@ -146,6 +152,7 @@ function createAutoIterationServiceMock() {
 }
 function createBridgeServices(overrides = {}) {
     return {
+        acpRuntimeManager,
         autoIterationService,
         chatEventForwarderService,
         chatMessageHandlerService,
@@ -153,15 +160,16 @@ function createBridgeServices(overrides = {}) {
         fixerSessionService,
         getWorkspaceInitPolicy,
         githubCLIService,
-        kanbanStateService,
         logbookService,
         periodicTaskService,
-        prFetchRegistry,
+        prFetchCoordinator,
         prSnapshotService,
         ratchetService,
         reconciliationService,
         sessionDataService,
         sessionDomainService,
+        sessionLifecycleService,
+        sessionPromptTurnCompletionService,
         sessionService,
         startupScriptService,
         terminalSessionService,
@@ -202,7 +210,6 @@ describe('configureDomainBridges', () => {
     });
     it('configures workspace domain services', () => {
         configureDomainBridges(createBridgeServices());
-        expect(kanbanStateService.configure).toHaveBeenCalledTimes(1);
         expect(workspaceQueryService.configure).toHaveBeenCalledTimes(1);
     });
     it('configures GitHub domain services', () => {
@@ -214,7 +221,8 @@ describe('configureDomainBridges', () => {
         expect(chatEventForwarderService.configure).toHaveBeenCalledTimes(1);
         expect(chatMessageHandlerService.configure).toHaveBeenCalledTimes(1);
         expect(sessionService.configure).toHaveBeenCalledTimes(1);
-        expect(sessionService.setPromptTurnCompleteHandler).toHaveBeenCalledTimes(1);
+        expect(sessionLifecycleService.configure).toHaveBeenCalledTimes(1);
+        expect(sessionPromptTurnCompletionService.setHandler).toHaveBeenCalledTimes(1);
     });
     it('configures run-script domain services', () => {
         configureDomainBridges(createBridgeServices());
@@ -236,23 +244,23 @@ describe('configureDomainBridges', () => {
         expect(periodicTaskService.configure).not.toHaveBeenCalled();
     });
     describe('ratchet bridge delegation', () => {
-        it('session bridge delegates isSessionRunning to sessionService', () => {
+        it('session bridge delegates isSessionRunning to acpRuntimeManager', () => {
             configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             bridge.session.isSessionRunning('s1');
-            expect(sessionService.isSessionRunning).toHaveBeenCalledWith('s1');
+            expect(acpRuntimeManager.isSessionRunning).toHaveBeenCalledWith('s1');
         });
-        it('session bridge delegates stopSession to sessionService', () => {
+        it('session bridge delegates stopSession to sessionLifecycleService', () => {
             configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             bridge.session.stopSession('s1');
-            expect(sessionService.stopSession).toHaveBeenCalledWith('s1');
+            expect(sessionLifecycleService.stopSession).toHaveBeenCalledWith('s1');
         });
-        it('session bridge delegates startSession to sessionService', () => {
+        it('session bridge delegates startSession to sessionLifecycleService', () => {
             configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             bridge.session.startSession('s1', { initialPrompt: 'hello' });
-            expect(sessionService.startSession).toHaveBeenCalledWith('s1', {
+            expect(sessionLifecycleService.startSession).toHaveBeenCalledWith('s1', {
                 initialPrompt: 'hello',
             });
         });
@@ -302,37 +310,16 @@ describe('configureDomainBridges', () => {
                 { name: 'build', status: 'completed', conclusion: undefined },
             ]);
         });
-        it('github bridge delegates startFetch to prFetchRegistry', () => {
+        it('github bridge delegates coordinatePrFetch to prFetchCoordinator', async () => {
+            const value = { prNumber: 1 };
+            vi.mocked(prFetchCoordinator.coordinate).mockResolvedValue({ status: 'fetched', value });
             configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
-            bridge.github.startFetch('ws1');
-            expect(prFetchRegistry.startFetch).toHaveBeenCalledWith('ws1');
-        });
-        it('github bridge delegates isRecentlyFetched to prFetchRegistry', () => {
-            vi.mocked(prFetchRegistry.isRecentlyFetched).mockReturnValue(true);
-            configureDomainBridges(createBridgeServices());
-            const bridge = getBridge(ratchetService.configure);
-            expect(bridge.github.isRecentlyFetched('ws1')).toBe(true);
-            expect(prFetchRegistry.isRecentlyFetched).toHaveBeenCalledWith('ws1');
-        });
-        it('github bridge delegates isFetchInFlight to prFetchRegistry', () => {
-            vi.mocked(prFetchRegistry.isFetchInFlight).mockReturnValue(true);
-            configureDomainBridges(createBridgeServices());
-            const bridge = getBridge(ratchetService.configure);
-            expect(bridge.github.isFetchInFlight('ws1')).toBe(true);
-            expect(prFetchRegistry.isFetchInFlight).toHaveBeenCalledWith('ws1');
-        });
-        it('github bridge delegates registerFetch to prFetchRegistry', () => {
-            configureDomainBridges(createBridgeServices());
-            const bridge = getBridge(ratchetService.configure);
-            bridge.github.registerFetch('ws1', 1);
-            expect(prFetchRegistry.register).toHaveBeenCalledWith('ws1', 1);
-        });
-        it('github bridge delegates cancelFetch to prFetchRegistry', () => {
-            configureDomainBridges(createBridgeServices());
-            const bridge = getBridge(ratchetService.configure);
-            bridge.github.cancelFetch('ws1', 1);
-            expect(prFetchRegistry.cancelFetch).toHaveBeenCalledWith('ws1', 1);
+            const fetch = vi.fn();
+            await expect(bridge.github.coordinatePrFetch('ws1', fetch, { ignoreCooldown: true })).resolves.toEqual({ status: 'fetched', value });
+            expect(prFetchCoordinator.coordinate).toHaveBeenCalledWith('ws1', fetch, {
+                ignoreCooldown: true,
+            });
         });
     });
     describe('reconciliation bridge delegation', () => {
@@ -352,24 +339,6 @@ describe('configureDomainBridges', () => {
         });
     });
     describe('workspace bridge delegation', () => {
-        it('kanban session bridge delegates isAnySessionWorking', () => {
-            configureDomainBridges(createBridgeServices());
-            const bridge = getBridge(kanbanStateService.configure);
-            bridge.session.isAnySessionWorking(['s1', 's2']);
-            expect(sessionService.isAnySessionWorking).toHaveBeenCalledWith(['s1', 's2']);
-        });
-        it('kanban session bridge delegates getAllPendingRequests', () => {
-            configureDomainBridges(createBridgeServices());
-            const bridge = getBridge(kanbanStateService.configure);
-            bridge.session.getAllPendingRequests();
-            expect(chatEventForwarderService.getAllPendingRequests).toHaveBeenCalled();
-        });
-        it('kanban session bridge delegates getRuntimeSnapshot', () => {
-            configureDomainBridges(createBridgeServices());
-            const bridge = getBridge(kanbanStateService.configure);
-            bridge.session.getRuntimeSnapshot('s1');
-            expect(sessionService.getRuntimeSnapshot).toHaveBeenCalledWith('s1');
-        });
         it('workspaceQueryService gets github bridge with checkHealth', () => {
             configureDomainBridges(createBridgeServices());
             const bridge = getBridge(workspaceQueryService.configure);
@@ -380,7 +349,7 @@ describe('configureDomainBridges', () => {
             configureDomainBridges(createBridgeServices());
             const bridge = getBridge(workspaceQueryService.configure);
             bridge.session.getRuntimeSnapshot('s1');
-            expect(sessionService.getRuntimeSnapshot).toHaveBeenCalledWith('s1');
+            expect(sessionLifecycleService.getRuntimeSnapshot).toHaveBeenCalledWith('s1');
         });
         it('workspaceQueryService gets prSnapshot bridge with refreshWorkspace', () => {
             configureDomainBridges(createBridgeServices());
@@ -434,7 +403,7 @@ describe('configureDomainBridges', () => {
                 { id: 'session-1' },
                 { id: 'session-2' },
             ]);
-            vi.mocked(sessionService.isAnySessionWorking).mockReturnValue(true);
+            vi.mocked(acpRuntimeManager.isAnySessionWorking).mockReturnValue(true);
             configureDomainBridges(createBridgeServices());
             const bridge = getBridge(periodicTaskService.configure);
             await expect(bridge.status.getWorkspaceStatus('ws-periodic')).resolves.toEqual({
@@ -444,7 +413,10 @@ describe('configureDomainBridges', () => {
                 isAgentWorking: true,
                 initCompletedAt: new Date('2026-05-20T12:00:00Z'),
             });
-            expect(sessionService.isAnySessionWorking).toHaveBeenCalledWith(['session-1', 'session-2']);
+            expect(acpRuntimeManager.isAnySessionWorking).toHaveBeenCalledWith([
+                'session-1',
+                'session-2',
+            ]);
         });
         it('treats queued periodic task session messages as active agent work', async () => {
             vi.mocked(workspaceDataService.findStatusSnapshot).mockResolvedValue({
@@ -457,8 +429,8 @@ describe('configureDomainBridges', () => {
                 { id: 'session-1' },
                 { id: 'session-2' },
             ]);
-            vi.mocked(sessionService.isAnySessionWorking).mockReturnValue(false);
-            vi.mocked(sessionService.isSessionRunning).mockReturnValue(true);
+            vi.mocked(acpRuntimeManager.isAnySessionWorking).mockReturnValue(false);
+            vi.mocked(acpRuntimeManager.isSessionRunning).mockReturnValue(true);
             vi.mocked(sessionDomainService.getQueueLength).mockReturnValueOnce(0).mockReturnValueOnce(1);
             configureDomainBridges(createBridgeServices());
             const bridge = getBridge(periodicTaskService.configure);
@@ -482,25 +454,161 @@ describe('configureDomainBridges', () => {
             vi.mocked(sessionDataService.findAgentSessionsByWorkspaceId).mockResolvedValue([
                 { id: 'session-1' },
             ]);
-            vi.mocked(sessionService.isAnySessionWorking).mockReturnValue(false);
-            vi.mocked(sessionService.isSessionRunning).mockReturnValue(false);
+            vi.mocked(acpRuntimeManager.isAnySessionWorking).mockReturnValue(false);
+            vi.mocked(acpRuntimeManager.isSessionRunning).mockReturnValue(false);
             configureDomainBridges(createBridgeServices());
             const bridge = getBridge(periodicTaskService.configure);
             await expect(bridge.status.getWorkspaceStatus('ws-periodic')).resolves.toMatchObject({
                 isAgentWorking: false,
             });
-            expect(sessionService.isSessionRunning).toHaveBeenCalledWith('session-1');
+            expect(acpRuntimeManager.isSessionRunning).toHaveBeenCalledWith('session-1');
             expect(sessionDomainService.getQueueLength).not.toHaveBeenCalled();
         });
     });
     describe('auto-iteration session bridge', () => {
+        it('rolls back a created session when initial runtime startup fails', async () => {
+            const autoIterationServiceMock = createAutoIterationServiceMock();
+            const startupError = new Error('runtime failed to start');
+            vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
+                id: 'new-session',
+            });
+            vi.mocked(sessionLifecycleService.startSession).mockRejectedValueOnce(startupError);
+            configureDomainBridges(createBridgeServices({ autoIterationService: autoIterationServiceMock }));
+            const sessionBridge = vi.mocked(autoIterationServiceMock.configure).mock
+                .calls[0][0];
+            await expect(sessionBridge.startSession('ws-1', {
+                initialPrompt: 'start prompt',
+                startupModePreset: 'non_interactive',
+            })).rejects.toThrow(startupError);
+            expect(sessionLifecycleService.stopSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDomainService.clearSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDataService.deleteAgentSession).toHaveBeenCalledWith('new-session');
+        });
+        it('retires the stopped predecessor after a successful recycle', async () => {
+            const autoIterationServiceMock = createAutoIterationServiceMock();
+            vi.mocked(workspaceAutoIterationService.getExecutionContext).mockResolvedValue({
+                autoIterationSessionId: 'old-session',
+            });
+            vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
+                id: 'new-session',
+            });
+            configureDomainBridges(createBridgeServices({ autoIterationService: autoIterationServiceMock }));
+            const sessionBridge = vi.mocked(autoIterationServiceMock.configure).mock
+                .calls[0][0];
+            await expect(sessionBridge.recycleSession('ws-1', 'handoff prompt')).resolves.toBe('new-session');
+            expect(sessionDataService.updateAgentSession).toHaveBeenCalledWith('old-session', {
+                status: SessionStatus.COMPLETED,
+                providerProcessPid: null,
+            });
+            expect(vi.mocked(sessionService.sendAcpMessage).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(sessionDataService.updateAgentSession).mock.invocationCallOrder[0]);
+            expect(workspaceAutoIterationService.finishSessionIfMatching).not.toHaveBeenCalled();
+        });
+        it('keeps the replacement active when predecessor retirement fails after handoff', async () => {
+            const autoIterationServiceMock = createAutoIterationServiceMock();
+            vi.mocked(workspaceAutoIterationService.getExecutionContext).mockResolvedValue({
+                autoIterationSessionId: 'old-session',
+            });
+            vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
+                id: 'new-session',
+            });
+            vi.mocked(sessionDataService.updateAgentSession).mockRejectedValueOnce(new Error('predecessor retirement failed'));
+            configureDomainBridges(createBridgeServices({ autoIterationService: autoIterationServiceMock }));
+            const sessionBridge = vi.mocked(autoIterationServiceMock.configure).mock
+                .calls[0][0];
+            await expect(sessionBridge.recycleSession('ws-1', 'handoff prompt')).resolves.toBe('new-session');
+            expect(sessionService.sendAcpMessage).toHaveBeenCalledWith('new-session', [
+                { type: 'text', text: 'handoff prompt' },
+            ]);
+            expect(sessionLifecycleService.stopSession).not.toHaveBeenCalledWith('new-session');
+            expect(sessionDomainService.clearSession).not.toHaveBeenCalledWith('new-session');
+            expect(sessionDataService.deleteAgentSession).not.toHaveBeenCalledWith('new-session');
+            expect(workspaceAutoIterationService.finishSessionIfMatching).not.toHaveBeenCalled();
+        });
+        it('rolls back a recycled session when replacement startup fails', async () => {
+            const autoIterationServiceMock = createAutoIterationServiceMock();
+            const startupError = new Error('runtime failed to start');
+            vi.mocked(workspaceAutoIterationService.getExecutionContext).mockResolvedValue({
+                autoIterationSessionId: 'old-session',
+            });
+            vi.mocked(workspaceAutoIterationService.finishSessionIfMatching)
+                .mockResolvedValueOnce(false)
+                .mockResolvedValueOnce(true);
+            vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
+                id: 'new-session',
+            });
+            vi.mocked(sessionLifecycleService.startSession).mockRejectedValueOnce(startupError);
+            configureDomainBridges(createBridgeServices({ autoIterationService: autoIterationServiceMock }));
+            const sessionBridge = vi.mocked(autoIterationServiceMock.configure).mock
+                .calls[0][0];
+            await expect(sessionBridge.recycleSession('ws-1', 'handoff prompt')).rejects.toThrow(startupError);
+            expect(sessionLifecycleService.stopSession).toHaveBeenCalledWith('old-session');
+            expect(sessionLifecycleService.stopSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDomainService.clearSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDataService.deleteAgentSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDataService.updateAgentSession).toHaveBeenCalledWith('old-session', {
+                status: SessionStatus.COMPLETED,
+                providerProcessPid: null,
+            });
+            expect(workspaceAutoIterationService.finishSessionIfMatching).toHaveBeenCalledWith('ws-1', 'new-session', AutoIterationStatus.FAILED);
+            expect(workspaceAutoIterationService.finishSessionIfMatching).toHaveBeenCalledWith('ws-1', 'old-session', AutoIterationStatus.FAILED);
+            expect(workspaceAutoIterationService.setSession).not.toHaveBeenCalled();
+            expect(sessionService.sendAcpMessage).not.toHaveBeenCalled();
+        });
+        it('retires the stopped predecessor when replacement creation fails', async () => {
+            const autoIterationServiceMock = createAutoIterationServiceMock();
+            const creationError = new Error('session row creation failed');
+            vi.mocked(workspaceAutoIterationService.getExecutionContext).mockResolvedValue({
+                autoIterationSessionId: 'old-session',
+            });
+            vi.mocked(workspaceAutoIterationService.finishSessionIfMatching).mockResolvedValueOnce(true);
+            vi.mocked(sessionDataService.createAgentSession).mockRejectedValueOnce(creationError);
+            configureDomainBridges(createBridgeServices({ autoIterationService: autoIterationServiceMock }));
+            const sessionBridge = vi.mocked(autoIterationServiceMock.configure).mock
+                .calls[0][0];
+            await expect(sessionBridge.recycleSession('ws-1', 'handoff prompt')).rejects.toThrow(creationError);
+            expect(sessionLifecycleService.stopSession).toHaveBeenCalledWith('old-session');
+            expect(sessionDataService.updateAgentSession).toHaveBeenCalledWith('old-session', {
+                status: SessionStatus.COMPLETED,
+                providerProcessPid: null,
+            });
+            expect(workspaceAutoIterationService.finishSessionIfMatching).toHaveBeenCalledWith('ws-1', 'old-session', AutoIterationStatus.FAILED);
+            expect(sessionLifecycleService.startSession).not.toHaveBeenCalled();
+            expect(sessionDataService.deleteAgentSession).not.toHaveBeenCalled();
+        });
+        it('clears the stopped predecessor when replacement pointer persistence fails', async () => {
+            const autoIterationServiceMock = createAutoIterationServiceMock();
+            const persistenceError = new Error('pointer update failed');
+            vi.mocked(workspaceAutoIterationService.getExecutionContext).mockResolvedValue({
+                autoIterationSessionId: 'old-session',
+            });
+            vi.mocked(workspaceAutoIterationService.finishSessionIfMatching)
+                .mockResolvedValueOnce(false)
+                .mockResolvedValueOnce(true);
+            vi.mocked(workspaceAutoIterationService.setSession).mockRejectedValueOnce(persistenceError);
+            vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
+                id: 'new-session',
+            });
+            configureDomainBridges(createBridgeServices({ autoIterationService: autoIterationServiceMock }));
+            const sessionBridge = vi.mocked(autoIterationServiceMock.configure).mock
+                .calls[0][0];
+            await expect(sessionBridge.recycleSession('ws-1', 'handoff prompt')).rejects.toThrow(persistenceError);
+            expect(sessionDomainService.clearSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDataService.deleteAgentSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDataService.updateAgentSession).toHaveBeenCalledWith('old-session', {
+                status: SessionStatus.COMPLETED,
+                providerProcessPid: null,
+            });
+            expect(workspaceAutoIterationService.finishSessionIfMatching).toHaveBeenCalledWith('ws-1', 'new-session', AutoIterationStatus.FAILED);
+            expect(workspaceAutoIterationService.finishSessionIfMatching).toHaveBeenCalledWith('ws-1', 'old-session', AutoIterationStatus.FAILED);
+            expect(sessionService.sendAcpMessage).not.toHaveBeenCalled();
+        });
         it('cleans up a recycled session when handoff send fails', async () => {
             const autoIterationServiceMock = createAutoIterationServiceMock();
             const sendError = new Error('prompt failed');
             vi.mocked(workspaceAutoIterationService.getExecutionContext).mockResolvedValue({
                 autoIterationSessionId: 'old-session',
             });
-            vi.mocked(workspaceAutoIterationService.clearSessionIfMatching).mockResolvedValue(true);
+            vi.mocked(workspaceAutoIterationService.finishSessionIfMatching).mockResolvedValueOnce(true);
             vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
                 id: 'new-session',
             });
@@ -509,16 +617,24 @@ describe('configureDomainBridges', () => {
             const sessionBridge = vi.mocked(autoIterationServiceMock.configure).mock
                 .calls[0][0];
             await expect(sessionBridge.recycleSession('ws-1', 'handoff prompt')).rejects.toThrow(sendError);
-            expect(sessionService.stopSession).toHaveBeenCalledWith('old-session');
-            expect(sessionService.startSession).toHaveBeenCalledWith('new-session', {
+            expect(sessionLifecycleService.stopSession).toHaveBeenCalledWith('old-session');
+            expect(sessionLifecycleService.startSession).toHaveBeenCalledWith('new-session', {
                 startupModePreset: 'non_interactive',
             });
             expect(workspaceAutoIterationService.setSession).toHaveBeenCalledWith('ws-1', 'new-session');
             expect(sessionService.sendAcpMessage).toHaveBeenCalledWith('new-session', [
                 { type: 'text', text: 'handoff prompt' },
             ]);
-            expect(sessionService.stopSession).toHaveBeenCalledWith('new-session');
-            expect(workspaceAutoIterationService.clearSessionIfMatching).toHaveBeenCalledWith('ws-1', 'new-session');
+            expect(sessionLifecycleService.stopSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDomainService.clearSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDataService.deleteAgentSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDataService.updateAgentSession).toHaveBeenCalledWith('old-session', {
+                status: SessionStatus.COMPLETED,
+                providerProcessPid: null,
+            });
+            expect(workspaceAutoIterationService.finishSessionIfMatching).toHaveBeenCalledWith('ws-1', 'new-session', AutoIterationStatus.FAILED);
+            expect(workspaceAutoIterationService.finishSessionIfMatching).toHaveBeenCalledTimes(1);
+            expect(vi.mocked(workspaceAutoIterationService.finishSessionIfMatching).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(sessionDataService.deleteAgentSession).mock.invocationCallOrder[0]);
             expect(vi.mocked(workspaceAutoIterationService.setSession).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(sessionService.sendAcpMessage).mock.invocationCallOrder[0]);
         });
         it('does not clear a newer auto-iteration session after recycle cleanup', async () => {
@@ -526,7 +642,7 @@ describe('configureDomainBridges', () => {
             vi.mocked(workspaceAutoIterationService.getExecutionContext).mockResolvedValue({
                 autoIterationSessionId: 'old-session',
             });
-            vi.mocked(workspaceAutoIterationService.clearSessionIfMatching).mockResolvedValue(false);
+            vi.mocked(workspaceAutoIterationService.finishSessionIfMatching).mockResolvedValue(false);
             vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
                 id: 'new-session',
             });
@@ -535,9 +651,59 @@ describe('configureDomainBridges', () => {
             const sessionBridge = vi.mocked(autoIterationServiceMock.configure).mock
                 .calls[0][0];
             await expect(sessionBridge.recycleSession('ws-1', 'handoff prompt')).rejects.toThrow('prompt failed');
-            expect(sessionService.stopSession).toHaveBeenCalledWith('new-session');
+            expect(sessionLifecycleService.stopSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDomainService.clearSession).toHaveBeenCalledWith('new-session');
+            expect(sessionDataService.deleteAgentSession).toHaveBeenCalledWith('new-session');
             expect(workspaceAutoIterationService.setSession).toHaveBeenCalledTimes(1);
-            expect(workspaceAutoIterationService.clearSessionIfMatching).toHaveBeenCalledWith('ws-1', 'new-session');
+            expect(workspaceAutoIterationService.finishSessionIfMatching).toHaveBeenCalledWith('ws-1', 'new-session', AutoIterationStatus.FAILED);
+            expect(workspaceAutoIterationService.finishSessionIfMatching).toHaveBeenCalledWith('ws-1', 'old-session', AutoIterationStatus.FAILED);
+        });
+        it('marks a created session failed when recycle rollback deletion fails', async () => {
+            const autoIterationServiceMock = createAutoIterationServiceMock();
+            const sendError = new Error('prompt failed');
+            vi.mocked(workspaceAutoIterationService.getExecutionContext).mockResolvedValue({
+                autoIterationSessionId: 'old-session',
+            });
+            vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
+                id: 'new-session',
+            });
+            vi.mocked(sessionDataService.deleteAgentSession).mockRejectedValueOnce(new Error('delete failed'));
+            vi.mocked(sessionService.sendAcpMessage).mockRejectedValueOnce(sendError);
+            configureDomainBridges(createBridgeServices({ autoIterationService: autoIterationServiceMock }));
+            const sessionBridge = vi.mocked(autoIterationServiceMock.configure).mock
+                .calls[0][0];
+            await expect(sessionBridge.recycleSession('ws-1', 'handoff prompt')).rejects.toThrow(sendError);
+            expect(sessionDataService.updateAgentSession).toHaveBeenCalledWith('new-session', {
+                status: SessionStatus.FAILED,
+                providerProcessPid: null,
+                providerMetadata: {
+                    rollbackReason: 'auto_iteration_recycle_failed_after_create',
+                },
+            });
+        });
+        it('preserves the handoff error when recycle rollback repair fails', async () => {
+            const autoIterationServiceMock = createAutoIterationServiceMock();
+            const sendError = new Error('prompt failed');
+            vi.mocked(workspaceAutoIterationService.getExecutionContext).mockResolvedValue({
+                autoIterationSessionId: 'old-session',
+            });
+            vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
+                id: 'new-session',
+            });
+            vi.mocked(sessionDataService.deleteAgentSession).mockRejectedValueOnce(new Error('delete failed'));
+            vi.mocked(sessionDataService.updateAgentSession).mockRejectedValueOnce(new Error('repair failed'));
+            vi.mocked(sessionService.sendAcpMessage).mockRejectedValueOnce(sendError);
+            configureDomainBridges(createBridgeServices({ autoIterationService: autoIterationServiceMock }));
+            const sessionBridge = vi.mocked(autoIterationServiceMock.configure).mock
+                .calls[0][0];
+            await expect(sessionBridge.recycleSession('ws-1', 'handoff prompt')).rejects.toThrow(sendError);
+            expect(sessionDataService.updateAgentSession).toHaveBeenCalledWith('new-session', {
+                status: SessionStatus.FAILED,
+                providerProcessPid: null,
+                providerMetadata: {
+                    rollbackReason: 'auto_iteration_recycle_failed_after_create',
+                },
+            });
         });
     });
     describe('session bridge delegation', () => {
@@ -578,21 +744,21 @@ describe('configureDomainBridges', () => {
             bridge.workspace.markSessionIdle('ws1', 's1', 12);
             expect(workspaceActivityService.markSessionIdle).toHaveBeenCalledWith('ws1', 's1', 12);
         });
-        it('sessionService workspace bridge delegates ratchet session end recording', async () => {
+        it('session lifecycle workspace bridge delegates ratchet session end recording', async () => {
             configureDomainBridges(createBridgeServices());
-            const bridge = getBridge(sessionService.configure);
+            const bridge = getBridge(sessionLifecycleService.configure);
             await bridge.workspace.recordRatchetSessionEnd('ws1', 's1', 'DIED');
             expect(ratchetService.recordSessionEnd).toHaveBeenCalledWith('ws1', 's1', 'DIED');
         });
-        it('sessionService message queue bridge delegates pending dispatch to chat handlers', async () => {
+        it('session lifecycle message queue bridge delegates pending dispatch to chat handlers', async () => {
             configureDomainBridges(createBridgeServices());
-            const bridge = getBridge(sessionService.configure);
+            const bridge = getBridge(sessionLifecycleService.configure);
             await bridge.messageQueue?.tryDispatchNextMessage('s1');
             expect(chatMessageHandlerService.tryDispatchNextMessage).toHaveBeenCalledWith('s1');
         });
-        it('sessionService prompt-turn callback delegates queue dispatch to chat handlers', async () => {
+        it('prompt completion service delegates queue dispatch to chat handlers', async () => {
             configureDomainBridges(createBridgeServices());
-            const onPromptTurnComplete = vi.mocked(sessionService.setPromptTurnCompleteHandler).mock
+            const onPromptTurnComplete = vi.mocked(sessionPromptTurnCompletionService.setHandler).mock
                 .calls[0]?.[0];
             expect(onPromptTurnComplete).toBeTypeOf('function');
             await onPromptTurnComplete?.('s1');
@@ -615,20 +781,12 @@ describe('configureDomainBridges', () => {
             expect(workspaceStateMachine.markFailed).toHaveBeenCalledWith('ws1', 'script error');
         });
     });
-    describe('github domain bridge delegation', () => {
-        it('prSnapshotService gets kanban bridge with updateCachedKanbanColumn', () => {
-            configureDomainBridges(createBridgeServices());
-            const bridge = getBridge(prSnapshotService.configure);
-            bridge.kanban.updateCachedKanbanColumn('ws1');
-            expect(kanbanStateService.updateCachedKanbanColumn).toHaveBeenCalledWith('ws1');
-        });
-    });
     describe('idempotency', () => {
         it('can be called multiple times without error', () => {
             configureDomainBridges(createBridgeServices());
             configureDomainBridges(createBridgeServices());
             expect(ratchetService.configure).toHaveBeenCalledTimes(2);
-            expect(kanbanStateService.configure).toHaveBeenCalledTimes(2);
+            expect(workspaceQueryService.configure).toHaveBeenCalledTimes(2);
         });
     });
 });