factory-factory 0.3.21 → 0.4.1

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

@@ -1,26 +1,61 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { autoIterationService, logbookService, } from '../../backend/services/auto-iteration/index.js';
 const mockLogger = vi.hoisted(() => ({
     info: vi.fn(),
     debug: vi.fn(),
     warn: vi.fn(),
     error: vi.fn(),
 }));
+const mockWorkspaceCreationService = vi.hoisted(() => ({ create: vi.fn() }));
 vi.mock('@/backend/services/logger.service', () => ({
     createLogger: () => mockLogger,
 }));
 vi.mock('@/backend/services/ratchet', () => ({
-    ratchetService: { configure: vi.fn(), clearRatchetActiveSessionIfMatching: vi.fn() },
+    ratchetService: { configure: vi.fn(), recordSessionEnd: vi.fn() },
     fixerSessionService: {
         configure: vi.fn(),
         acquireAndDispatch: vi.fn(),
         getActiveSession: vi.fn(),
     },
+}));
+vi.mock('./reconciliation.service', () => ({
     reconciliationService: { configure: vi.fn() },
 }));
 vi.mock('@/backend/services/workspace', () => ({
     kanbanStateService: { configure: vi.fn(), updateCachedKanbanColumn: vi.fn() },
-    workspaceAccessor: { create: vi.fn(), findRawById: vi.fn(), update: vi.fn() },
+    WorkspaceCreationService: class {
+        create = mockWorkspaceCreationService.create;
+    },
+    workspaceAutoIterationService: {
+        getExecutionContext: vi.fn(),
+        setStatus: vi.fn(),
+        setProgress: vi.fn(),
+        setSession: vi.fn(),
+        finishSessionIfMatching: vi.fn(),
+        clearSessionIfMatching: vi.fn(),
+    },
+    workspaceDataService: {
+        findById: vi.fn(),
+        findFixerContext: vi.fn(),
+        findPRContext: vi.fn(),
+        findStatusSnapshot: vi.fn(),
+        resetPRDiscoveryBackoff: vi.fn(),
+    },
+    workspaceMaintenanceService: { findNeedingWorktree: vi.fn() },
+    workspacePrSnapshotService: {
+        record: vi.fn(),
+        attachDiscoveredPRIfClaimMatches: vi.fn(),
+        updatePRSnapshotIfUrlMatches: vi.fn(),
+    },
+    workspaceRatchetService: { recordSessionEnd: vi.fn() },
+    workspaceRunScriptService: {
+        clearInitOutput: vi.fn(),
+        appendInitOutput: vi.fn(),
+        setInitScriptPid: vi.fn(),
+        clearInitScriptPid: vi.fn(),
+    },
     workspaceQueryService: { configure: vi.fn() },
+    workspaceSnapshotStore: { configure: vi.fn() },
     workspaceActivityService: {
         markSessionRunning: vi.fn(),
         markSessionIdle: vi.fn(),
@@ -31,8 +66,10 @@ vi.mock('@/backend/services/workspace', () => ({
 }));
 vi.mock('@/backend/services/session', () => ({
     sessionDataService: {
+        findAgentSessionById: vi.fn(),
         createAgentSession: vi.fn(),
         findAgentSessionsByWorkspaceId: vi.fn(),
+        acquireFixerSession: vi.fn(),
     },
     sessionService: {
         configure: vi.fn(),
@@ -59,13 +96,20 @@ vi.mock('@/backend/services/github', () => ({
         extractPRInfo: vi.fn(),
         getPRFullDetails: vi.fn(),
         getReviewComments: vi.fn(),
+        getResolvedReviewCommentIds: vi.fn(),
         computeCIStatus: vi.fn(),
         getAuthenticatedUsername: vi.fn(),
         fetchAndComputePRState: vi.fn(),
         checkHealth: vi.fn(),
         listReviewRequests: vi.fn(),
     },
-    prFetchRegistry: { register: vi.fn(), startFetch: vi.fn(), cancelFetch: vi.fn() },
+    prFetchRegistry: {
+        isRecentlyFetched: vi.fn(),
+        isFetchInFlight: vi.fn(),
+        register: vi.fn(),
+        startFetch: vi.fn(),
+        cancelFetch: vi.fn(),
+    },
     prSnapshotService: { configure: vi.fn(), refreshWorkspace: vi.fn() },
 }));
 vi.mock('@/backend/services/periodic-task', () => ({
@@ -74,69 +118,138 @@ vi.mock('@/backend/services/periodic-task', () => ({
 vi.mock('@/backend/services/run-script', () => ({
     startupScriptService: { configure: vi.fn() },
 }));
+vi.mock('@/backend/services/terminal', () => ({
+    terminalSessionService: { recoverOrphanedSessions: vi.fn() },
+}));
 vi.mock('./workspace-init.orchestrator', () => ({
     initializeWorkspaceWorktree: vi.fn(),
 }));
 import { githubCLIService, prFetchRegistry, 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, reconciliationService, } from '../../backend/services/ratchet/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 { getWorkspaceInitPolicy, kanbanStateService, workspaceAccessor, workspaceActivityService, workspaceQueryService, workspaceStateMachine, } from '../../backend/services/workspace/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 { configureDomainBridges } from './domain-bridges.orchestrator.js';
+import { reconciliationService } from './reconciliation.service.js';
 import { initializeWorkspaceWorktree } from './workspace-init.orchestrator.js';
 function getBridge(mockFn) {
     return vi.mocked(mockFn).mock.calls[0][0];
 }
+function createAutoIterationServiceMock() {
+    return {
+        configure: vi.fn(),
+        onSessionDeath: vi.fn(),
+    };
+}
+function createBridgeServices(overrides = {}) {
+    return {
+        autoIterationService,
+        chatEventForwarderService,
+        chatMessageHandlerService,
+        createLogger,
+        fixerSessionService,
+        getWorkspaceInitPolicy,
+        githubCLIService,
+        kanbanStateService,
+        logbookService,
+        periodicTaskService,
+        prFetchRegistry,
+        prSnapshotService,
+        ratchetService,
+        reconciliationService,
+        sessionDataService,
+        sessionDomainService,
+        sessionService,
+        startupScriptService,
+        terminalSessionService,
+        workspaceActivityService,
+        workspaceAutoIterationService,
+        workspaceCreationService: mockWorkspaceCreationService,
+        workspaceDataService,
+        workspaceMaintenanceService,
+        workspacePrSnapshotService,
+        workspaceQueryService,
+        workspaceRatchetService,
+        workspaceRunScriptService,
+        workspaceSnapshotStore,
+        workspaceStateMachine,
+        initializeWorkspaceWorktree,
+        ...overrides,
+    };
+}
 describe('configureDomainBridges', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
     it('configures all ratchet domain services', () => {
-        configureDomainBridges();
+        configureDomainBridges(createBridgeServices());
         expect(ratchetService.configure).toHaveBeenCalledTimes(1);
         expect(fixerSessionService.configure).toHaveBeenCalledTimes(1);
         expect(reconciliationService.configure).toHaveBeenCalledTimes(1);
     });
+    it('uses the supplied worktree initializer for reconciliation', async () => {
+        const injectedInitializer = vi.fn().mockResolvedValue(undefined);
+        configureDomainBridges(createBridgeServices({ initializeWorkspaceWorktree: injectedInitializer }));
+        const bridge = getBridge(reconciliationService.configure);
+        await bridge.workspace.initializeWorktree('ws-injected', { useExistingBranch: true });
+        expect(injectedInitializer).toHaveBeenCalledWith('ws-injected', {
+            useExistingBranch: true,
+        });
+        expect(initializeWorkspaceWorktree).not.toHaveBeenCalled();
+    });
     it('configures workspace domain services', () => {
-        configureDomainBridges();
+        configureDomainBridges(createBridgeServices());
         expect(kanbanStateService.configure).toHaveBeenCalledTimes(1);
         expect(workspaceQueryService.configure).toHaveBeenCalledTimes(1);
     });
     it('configures GitHub domain services', () => {
-        configureDomainBridges();
+        configureDomainBridges(createBridgeServices());
         expect(prSnapshotService.configure).toHaveBeenCalledTimes(1);
     });
     it('configures session domain services', () => {
-        configureDomainBridges();
+        configureDomainBridges(createBridgeServices());
         expect(chatEventForwarderService.configure).toHaveBeenCalledTimes(1);
         expect(chatMessageHandlerService.configure).toHaveBeenCalledTimes(1);
         expect(sessionService.configure).toHaveBeenCalledTimes(1);
         expect(sessionService.setPromptTurnCompleteHandler).toHaveBeenCalledTimes(1);
     });
     it('configures run-script domain services', () => {
-        configureDomainBridges();
+        configureDomainBridges(createBridgeServices());
         expect(startupScriptService.configure).toHaveBeenCalledTimes(1);
     });
     it('configures periodic task domain services', () => {
-        configureDomainBridges();
+        configureDomainBridges(createBridgeServices());
         expect(periodicTaskService.configure).toHaveBeenCalledTimes(1);
     });
+    it('configures only the caller-supplied periodic task service', () => {
+        const configure = vi.fn();
+        const suppliedPeriodicTaskService = new Proxy(periodicTaskService, {
+            get(target, property, receiver) {
+                return property === 'configure' ? configure : Reflect.get(target, property, receiver);
+            },
+        });
+        configureDomainBridges(createBridgeServices({ periodicTaskService: suppliedPeriodicTaskService }));
+        expect(configure).toHaveBeenCalledTimes(1);
+        expect(periodicTaskService.configure).not.toHaveBeenCalled();
+    });
     describe('ratchet bridge delegation', () => {
         it('session bridge delegates isSessionRunning to sessionService', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             bridge.session.isSessionRunning('s1');
             expect(sessionService.isSessionRunning).toHaveBeenCalledWith('s1');
         });
         it('session bridge delegates stopSession to sessionService', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             bridge.session.stopSession('s1');
             expect(sessionService.stopSession).toHaveBeenCalledWith('s1');
         });
         it('session bridge delegates startSession to sessionService', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             bridge.session.startSession('s1', { initialPrompt: 'hello' });
             expect(sessionService.startSession).toHaveBeenCalledWith('s1', {
@@ -144,31 +257,44 @@ describe('configureDomainBridges', () => {
             });
         });
         it('session bridge delegates sendSessionMessage to sessionService', async () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             await bridge.session.sendSessionMessage('s1', 'hello');
             expect(sessionService.sendSessionMessage).toHaveBeenCalledWith('s1', 'hello');
         });
         it('session bridge delegates injectCommittedUserMessage to sessionDomainService', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             bridge.session.injectCommittedUserMessage('s1', 'msg');
             expect(sessionDomainService.injectCommittedUserMessage).toHaveBeenCalledWith('s1', 'msg');
         });
         it('github bridge delegates extractPRInfo to githubCLIService', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             bridge.github.extractPRInfo('https://github.com/owner/repo/pull/1');
             expect(githubCLIService.extractPRInfo).toHaveBeenCalledWith('https://github.com/owner/repo/pull/1');
         });
+        it('github bridge forwards abort signals to PR reads', async () => {
+            const controller = new AbortController();
+            configureDomainBridges(createBridgeServices());
+            const bridge = getBridge(ratchetService.configure);
+            await bridge.github.getPRFullDetails('owner/repo', 42, controller.signal);
+            await bridge.github.getReviewComments('owner/repo', 42, undefined, controller.signal);
+            await bridge.github.getResolvedReviewCommentIds('owner/repo', 42, controller.signal);
+            await bridge.github.getAuthenticatedUsername(controller.signal);
+            expect(githubCLIService.getPRFullDetails).toHaveBeenCalledWith('owner/repo', 42, controller.signal);
+            expect(githubCLIService.getReviewComments).toHaveBeenCalledWith('owner/repo', 42, undefined, controller.signal);
+            expect(githubCLIService.getResolvedReviewCommentIds).toHaveBeenCalledWith('owner/repo', 42, controller.signal);
+            expect(githubCLIService.getAuthenticatedUsername).toHaveBeenCalledWith(controller.signal);
+        });
         it('github bridge delegates computeCIStatus with null input', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             bridge.github.computeCIStatus(null);
             expect(githubCLIService.computeCIStatus).toHaveBeenCalledWith(null);
         });
         it('github bridge maps conclusion null to undefined in computeCIStatus', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
             const checks = [{ name: 'build', status: 'completed', conclusion: null }];
             bridge.github.computeCIStatus(checks);
@@ -177,33 +303,47 @@ describe('configureDomainBridges', () => {
             ]);
         });
         it('github bridge delegates startFetch to prFetchRegistry', () => {
-            configureDomainBridges();
+            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();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
-            bridge.github.registerFetch('ws1');
-            expect(prFetchRegistry.register).toHaveBeenCalledWith('ws1');
+            bridge.github.registerFetch('ws1', 1);
+            expect(prFetchRegistry.register).toHaveBeenCalledWith('ws1', 1);
         });
         it('github bridge delegates cancelFetch to prFetchRegistry', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(ratchetService.configure);
-            bridge.github.cancelFetch('ws1');
-            expect(prFetchRegistry.cancelFetch).toHaveBeenCalledWith('ws1');
+            bridge.github.cancelFetch('ws1', 1);
+            expect(prFetchRegistry.cancelFetch).toHaveBeenCalledWith('ws1', 1);
         });
     });
     describe('reconciliation bridge delegation', () => {
         it('workspace bridge markFailed delegates to workspaceStateMachine', async () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(reconciliationService.configure);
             await bridge.workspace.markFailed('ws1', 'broken');
             expect(workspaceStateMachine.markFailed).toHaveBeenCalledWith('ws1', 'broken');
         });
         it('workspace bridge initializeWorktree delegates to initializeWorkspaceWorktree', async () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(reconciliationService.configure);
             await bridge.workspace.initializeWorktree('ws1', { branchName: 'feature/test' });
             expect(initializeWorkspaceWorktree).toHaveBeenCalledWith('ws1', {
@@ -213,31 +353,37 @@ describe('configureDomainBridges', () => {
     });
     describe('workspace bridge delegation', () => {
         it('kanban session bridge delegates isAnySessionWorking', () => {
-            configureDomainBridges();
+            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();
+            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();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(workspaceQueryService.configure);
             bridge.github.checkHealth();
             expect(githubCLIService.checkHealth).toHaveBeenCalled();
         });
         it('workspaceQueryService gets session bridge with runtime snapshots', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(workspaceQueryService.configure);
             bridge.session.getRuntimeSnapshot('s1');
             expect(sessionService.getRuntimeSnapshot).toHaveBeenCalledWith('s1');
         });
         it('workspaceQueryService gets prSnapshot bridge with refreshWorkspace', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(workspaceQueryService.configure);
             bridge.prSnapshot.refreshWorkspace('ws1', 'https://pr.url');
             expect(prSnapshotService.refreshWorkspace).toHaveBeenCalledWith('ws1', 'https://pr.url');
@@ -248,12 +394,12 @@ describe('configureDomainBridges', () => {
             const workspace = {
                 id: 'ws-periodic',
             };
-            vi.mocked(workspaceAccessor.create).mockResolvedValue(workspace);
+            mockWorkspaceCreationService.create.mockResolvedValue(workspace);
             vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
                 id: 'session-1',
             });
             vi.mocked(initializeWorkspaceWorktree).mockRejectedValue(new Error('init failed'));
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(periodicTaskService.configure);
             await expect(bridge.workspace.createWorkspaceForTask({
                 projectId: 'project-1',
@@ -262,14 +408,14 @@ describe('configureDomainBridges', () => {
                 periodicTaskId: 'periodic-task-1',
             })).resolves.toEqual({ workspaceId: 'ws-periodic' });
             await Promise.resolve();
-            expect(workspaceAccessor.create).toHaveBeenCalledWith(expect.objectContaining({
+            expect(mockWorkspaceCreationService.create).toHaveBeenCalledWith({
+                type: 'PERIODIC_TASK',
                 projectId: 'project-1',
                 name: 'Periodic task run',
-                creationSource: 'PERIODIC_TASK',
                 periodicTaskId: 'periodic-task-1',
+                initialPrompt: 'Do the recurring work',
                 ratchetEnabled: true,
-                creationMetadata: { initialPrompt: 'Do the recurring work' },
-            }));
+            });
             expect(sessionDataService.createAgentSession).toHaveBeenCalledWith({
                 workspaceId: 'ws-periodic',
                 workflow: 'implement',
@@ -278,7 +424,7 @@ describe('configureDomainBridges', () => {
             expect(mockLogger.error).toHaveBeenCalledWith('Failed to initialize workspace for periodic task', expect.any(Error), { workspaceId: 'ws-periodic' });
         });
         it('includes agent working state in periodic task workspace status', async () => {
-            vi.mocked(workspaceAccessor.findRawById).mockResolvedValue({
+            vi.mocked(workspaceDataService.findStatusSnapshot).mockResolvedValue({
                 status: 'READY',
                 prUrl: null,
                 prNumber: null,
@@ -289,7 +435,7 @@ describe('configureDomainBridges', () => {
                 { id: 'session-2' },
             ]);
             vi.mocked(sessionService.isAnySessionWorking).mockReturnValue(true);
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(periodicTaskService.configure);
             await expect(bridge.status.getWorkspaceStatus('ws-periodic')).resolves.toEqual({
                 status: 'READY',
@@ -301,7 +447,7 @@ describe('configureDomainBridges', () => {
             expect(sessionService.isAnySessionWorking).toHaveBeenCalledWith(['session-1', 'session-2']);
         });
         it('treats queued periodic task session messages as active agent work', async () => {
-            vi.mocked(workspaceAccessor.findRawById).mockResolvedValue({
+            vi.mocked(workspaceDataService.findStatusSnapshot).mockResolvedValue({
                 status: 'READY',
                 prUrl: null,
                 prNumber: null,
@@ -314,7 +460,7 @@ describe('configureDomainBridges', () => {
             vi.mocked(sessionService.isAnySessionWorking).mockReturnValue(false);
             vi.mocked(sessionService.isSessionRunning).mockReturnValue(true);
             vi.mocked(sessionDomainService.getQueueLength).mockReturnValueOnce(0).mockReturnValueOnce(1);
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(periodicTaskService.configure);
             await expect(bridge.status.getWorkspaceStatus('ws-periodic')).resolves.toEqual({
                 status: 'READY',
@@ -327,7 +473,7 @@ describe('configureDomainBridges', () => {
             expect(sessionDomainService.getQueueLength).toHaveBeenCalledWith('session-2');
         });
         it('does not read queued messages for stopped periodic task sessions', async () => {
-            vi.mocked(workspaceAccessor.findRawById).mockResolvedValue({
+            vi.mocked(workspaceDataService.findStatusSnapshot).mockResolvedValue({
                 status: 'READY',
                 prUrl: null,
                 prNumber: null,
@@ -338,7 +484,7 @@ describe('configureDomainBridges', () => {
             ]);
             vi.mocked(sessionService.isAnySessionWorking).mockReturnValue(false);
             vi.mocked(sessionService.isSessionRunning).mockReturnValue(false);
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(periodicTaskService.configure);
             await expect(bridge.status.getWorkspaceStatus('ws-periodic')).resolves.toMatchObject({
                 isAgentWorking: false,
@@ -347,52 +493,105 @@ describe('configureDomainBridges', () => {
             expect(sessionDomainService.getQueueLength).not.toHaveBeenCalled();
         });
     });
+    describe('auto-iteration session bridge', () => {
+        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(sessionDataService.createAgentSession).mockResolvedValue({
+                id: 'new-session',
+            });
+            vi.mocked(sessionService.sendAcpMessage).mockRejectedValue(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(sessionService.stopSession).toHaveBeenCalledWith('old-session');
+            expect(sessionService.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(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 () => {
+            const autoIterationServiceMock = createAutoIterationServiceMock();
+            vi.mocked(workspaceAutoIterationService.getExecutionContext).mockResolvedValue({
+                autoIterationSessionId: 'old-session',
+            });
+            vi.mocked(workspaceAutoIterationService.clearSessionIfMatching).mockResolvedValue(false);
+            vi.mocked(sessionDataService.createAgentSession).mockResolvedValue({
+                id: 'new-session',
+            });
+            vi.mocked(sessionService.sendAcpMessage).mockRejectedValue(new Error('prompt failed'));
+            configureDomainBridges(createBridgeServices({ autoIterationService: autoIterationServiceMock }));
+            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(workspaceAutoIterationService.setSession).toHaveBeenCalledTimes(1);
+            expect(workspaceAutoIterationService.clearSessionIfMatching).toHaveBeenCalledWith('ws-1', 'new-session');
+        });
+    });
     describe('session bridge delegation', () => {
         it('chatEventForwarder workspace bridge delegates markSessionRunning', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(chatEventForwarderService.configure);
             bridge.workspace.markSessionRunning('ws1', 's1');
             expect(workspaceActivityService.markSessionRunning).toHaveBeenCalledWith('ws1', 's1');
         });
         it('chatEventForwarder workspace bridge delegates markSessionIdle', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(chatEventForwarderService.configure);
-            bridge.workspace.markSessionIdle('ws1', 's1');
-            expect(workspaceActivityService.markSessionIdle).toHaveBeenCalledWith('ws1', 's1');
+            bridge.workspace.markSessionIdle('ws1', 's1', 12);
+            expect(workspaceActivityService.markSessionIdle).toHaveBeenCalledWith('ws1', 's1', 12);
         });
         it('chatEventForwarder workspace bridge delegates on', () => {
             const handler = vi.fn();
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(chatEventForwarderService.configure);
             bridge.workspace.on('request_notification', handler);
             expect(workspaceActivityService.on).toHaveBeenCalledWith('request_notification', handler);
         });
         it('chatMessageHandler initPolicy bridge delegates getWorkspaceInitPolicy', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(chatMessageHandlerService.configure);
             bridge.initPolicy.getWorkspaceInitPolicy({ status: 'READY' });
             expect(getWorkspaceInitPolicy).toHaveBeenCalledWith({ status: 'READY' });
         });
         it('sessionService workspace bridge delegates markSessionRunning', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(sessionService.configure);
             bridge.workspace.markSessionRunning('ws1', 's1');
             expect(workspaceActivityService.markSessionRunning).toHaveBeenCalledWith('ws1', 's1');
         });
         it('sessionService workspace bridge delegates markSessionIdle', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
+            const bridge = getBridge(sessionService.configure);
+            bridge.workspace.markSessionIdle('ws1', 's1', 12);
+            expect(workspaceActivityService.markSessionIdle).toHaveBeenCalledWith('ws1', 's1', 12);
+        });
+        it('sessionService workspace bridge delegates ratchet session end recording', async () => {
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(sessionService.configure);
-            bridge.workspace.markSessionIdle('ws1', 's1');
-            expect(workspaceActivityService.markSessionIdle).toHaveBeenCalledWith('ws1', 's1');
+            await bridge.workspace.recordRatchetSessionEnd('ws1', 's1', 'DIED');
+            expect(ratchetService.recordSessionEnd).toHaveBeenCalledWith('ws1', 's1', 'DIED');
         });
-        it('sessionService workspace bridge delegates ratchet session cleanup', async () => {
-            configureDomainBridges();
+        it('sessionService message queue bridge delegates pending dispatch to chat handlers', async () => {
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(sessionService.configure);
-            await bridge.workspace.clearRatchetActiveSessionIfMatching('ws1', 's1');
-            expect(ratchetService.clearRatchetActiveSessionIfMatching).toHaveBeenCalledWith('ws1', 's1');
+            await bridge.messageQueue?.tryDispatchNextMessage('s1');
+            expect(chatMessageHandlerService.tryDispatchNextMessage).toHaveBeenCalledWith('s1');
         });
         it('sessionService prompt-turn callback delegates queue dispatch to chat handlers', async () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const onPromptTurnComplete = vi.mocked(sessionService.setPromptTurnCompleteHandler).mock
                 .calls[0]?.[0];
             expect(onPromptTurnComplete).toBeTypeOf('function');
@@ -404,13 +603,13 @@ describe('configureDomainBridges', () => {
     });
     describe('run-script bridge delegation', () => {
         it('startupScript workspace bridge delegates markReady', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(startupScriptService.configure);
             bridge.workspace.markReady('ws1');
             expect(workspaceStateMachine.markReady).toHaveBeenCalledWith('ws1');
         });
         it('startupScript workspace bridge delegates markFailed', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(startupScriptService.configure);
             bridge.workspace.markFailed('ws1', 'script error');
             expect(workspaceStateMachine.markFailed).toHaveBeenCalledWith('ws1', 'script error');
@@ -418,7 +617,7 @@ describe('configureDomainBridges', () => {
     });
     describe('github domain bridge delegation', () => {
         it('prSnapshotService gets kanban bridge with updateCachedKanbanColumn', () => {
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
             const bridge = getBridge(prSnapshotService.configure);
             bridge.kanban.updateCachedKanbanColumn('ws1');
             expect(kanbanStateService.updateCachedKanbanColumn).toHaveBeenCalledWith('ws1');
@@ -426,8 +625,8 @@ describe('configureDomainBridges', () => {
     });
     describe('idempotency', () => {
         it('can be called multiple times without error', () => {
-            configureDomainBridges();
-            configureDomainBridges();
+            configureDomainBridges(createBridgeServices());
+            configureDomainBridges(createBridgeServices());
             expect(ratchetService.configure).toHaveBeenCalledTimes(2);
             expect(kanbanStateService.configure).toHaveBeenCalledTimes(2);
         });