factory-factory 0.4.9 → 0.4.11

package/dist/src/backend/services/ratchet/service/ratchet.service.test.js

@@ -1,3485 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { SERVICE_THRESHOLDS, SERVICE_TIMEOUT_MS } from '../../constants.js';
-import { CIStatus, RatchetState, SessionStatus } from '../../../../shared/core/index.js';
-import { unsafeCoerce } from '../../../../test-utils/unsafe-coerce.js';
-vi.mock('@/backend/services/workspace', () => ({
-    workspaceDataService: {
-        findById: vi.fn(),
-    },
-    workspaceRatchetService: {
-        findCandidates: vi.fn(),
-        findCandidateById: vi.fn(),
-        clearActiveSession: vi.fn(),
-        enable: vi.fn(),
-        disable: vi.fn(),
-        recordCheckIfEnabled: vi.fn(),
-        recordDispatchIfEnabled: vi.fn(),
-        adoptActiveSessionIfEnabled: vi.fn(),
-        recordSessionEnd: vi.fn(),
-    },
-}));
-vi.mock('@/backend/services/session', () => ({
-    sessionDataService: {
-        findAgentSessionById: vi.fn(),
-        findAgentSessionsByWorkspaceId: vi.fn(),
-    },
-}));
-vi.mock('@/backend/services/settings', () => ({
-    userSettingsService: {
-        get: vi.fn(),
-        getDefaultSessionProvider: vi.fn(),
-    },
-}));
-vi.mock('./fixer-session.service', () => ({
-    fixerSessionService: {
-        acquireAndDispatch: vi.fn(),
-    },
-}));
-vi.mock('@/backend/services/logger.service', () => ({
-    createLogger: () => ({
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-    }),
-}));
-import { userSettingsService } from '../../settings/index.js';
-import { workspaceDataService, workspaceRatchetService } from '../../workspace/index.js';
-import { fixerSessionService } from './fixer-session.service.js';
-import { RATCHET_DISPATCH_CHANGED, RATCHET_STATE_CHANGED, RATCHET_TOGGLED, ratchetService, } from './ratchet.service.js';
-import { buildRatchetingLogContext } from './ratchet-decision-logging.helpers.js';
-import { computeDispatchSnapshotKey, computeLatestReviewActivityAtMs, determineRatchetState, } from './ratchet-pr-state.helpers.js';
-const mockSessionBridge = {
-    findSessionById: vi.fn(),
-    findSessionsByWorkspaceId: vi.fn(),
-    acquireFixerSession: vi.fn(),
-    isSessionRunning: vi.fn(),
-    isSessionWorking: vi.fn(),
-    stopSession: vi.fn(),
-    startSession: vi.fn(),
-    restartSession: vi.fn(),
-    sendSessionMessage: vi.fn(),
-    injectCommittedUserMessage: vi.fn(),
-};
-const mockWorkspaceBridge = {
-    findFixerContext: vi.fn(),
-    recordSessionEnd: vi.fn(),
-    markDispatchStalled: vi.fn().mockResolvedValue(true),
-};
-const fakeCoordinator = { cooldownActive: false, inFlightSkips: 0 };
-const mockGitHubBridge = {
-    extractPRInfo: vi.fn(),
-    getPRFullDetails: vi.fn(),
-    getReviewComments: vi.fn(),
-    getResolvedReviewCommentIds: vi.fn(),
-    computeCIStatus: vi.fn(),
-    computePRState: vi.fn(() => 'OPEN'),
-    getAuthenticatedUsername: vi.fn(),
-    fetchAndComputePRState: vi.fn(),
-    coordinatePrFetch: vi.fn(async (_workspaceId, fetch, options) => {
-        if (fakeCoordinator.inFlightSkips > 0) {
-            fakeCoordinator.inFlightSkips -= 1;
-            return { status: 'skipped', reason: 'recently_fetched' };
-        }
-        if (fakeCoordinator.cooldownActive && !options?.ignoreCooldown) {
-            return { status: 'skipped', reason: 'recently_fetched' };
-        }
-        return { status: 'fetched', value: await fetch() };
-    }),
-};
-const mockSnapshotBridge = {
-    recordPrObservation: vi.fn(),
-    recordCINotification: vi.fn(),
-    recordReviewCheck: vi.fn(),
-};
-function setRatchetShuttingDown(shuttingDown) {
-    const controller = new AbortController();
-    if (shuttingDown) {
-        controller.abort();
-    }
-    const internals = unsafeCoerce(ratchetService);
-    internals.runSignal = controller.signal;
-    internals.stopped = shuttingDown;
-}
-describe('ratchet service (state-change + idle dispatch)', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        fakeCoordinator.cooldownActive = false;
-        fakeCoordinator.inFlightSkips = 0;
-        setRatchetShuttingDown(false);
-        unsafeCoerce(ratchetService).workspaceCheckTimeoutMs =
-            SERVICE_TIMEOUT_MS.ratchetWorkspaceCheck;
-        ratchetService.configure({
-            session: mockSessionBridge,
-            github: mockGitHubBridge,
-            snapshot: mockSnapshotBridge,
-            workspace: mockWorkspaceBridge,
-        });
-        vi.mocked(workspaceRatchetService.recordCheckIfEnabled).mockResolvedValue(true);
-        vi.mocked(workspaceRatchetService.recordDispatchIfEnabled).mockResolvedValue(true);
-        vi.mocked(workspaceRatchetService.adoptActiveSessionIfEnabled).mockResolvedValue(true);
-        vi.mocked(workspaceRatchetService.recordSessionEnd).mockResolvedValue(true);
-        vi.mocked(mockWorkspaceBridge.recordSessionEnd).mockResolvedValue(true);
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(mockGitHubBridge.getAuthenticatedUsername).mockResolvedValue(null);
-        vi.mocked(mockGitHubBridge.getResolvedReviewCommentIds).mockResolvedValue(new Set());
-        vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(false);
-        vi.mocked(userSettingsService.get).mockResolvedValue({
-            id: 'settings-1',
-            userId: 'default',
-            preferredIde: 'cursor',
-            customIdeCommand: null,
-            playSoundOnComplete: true,
-            notificationSoundPath: null,
-            workspaceOrder: null,
-            cachedSlashCommands: null,
-            ratchetEnabled: false,
-            ratchetReplyToPrComments: true,
-            ratchetReviewTriggerMode: 'CHANGES_REQUESTED',
-            defaultSessionProvider: 'CLAUDE',
-            defaultClaudeModel: 'sonnet',
-            defaultCodexModel: 'default',
-            defaultClaudeReasoningEffort: null,
-            defaultCodexReasoningEffort: null,
-            defaultWorkspacePermissions: 'STRICT',
-            ratchetPermissions: 'YOLO',
-            voiceModeEnabled: false,
-            deepgramApiKeyEncrypted: null,
-            voiceTtsModel: 'flux-haley-en',
-            voiceTtsSpeed: 1,
-            voiceUtteranceEndMs: 1000,
-            voiceBargeInSustainedMs: 16,
-            createdAt: new Date('2026-01-01T00:00:00.000Z'),
-            updatedAt: new Date('2026-01-01T00:00:00.000Z'),
-        });
-        vi.mocked(userSettingsService.getDefaultSessionProvider).mockResolvedValue('CLAUDE');
-    });
-    it('records session completion through the configured workspace bridge', async () => {
-        await ratchetService.recordSessionEnd('workspace-1', 'session-1', 'COMPLETED');
-        expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith('workspace-1', 'session-1', 'COMPLETED');
-        expect(workspaceRatchetService.recordSessionEnd).not.toHaveBeenCalled();
-    });
-    afterEach(() => {
-        ratchetService.removeAllListeners();
-    });
-    it('checks workspaces and processes each', async () => {
-        vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue([
-            {
-                id: 'ws-1',
-                prUrl: 'https://github.com/example/repo/pull/1',
-                prNumber: 1,
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiStatus: CIStatus.UNKNOWN,
-                defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-                ratchetLastCheckedAt: null,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-                ratchetDispatchStalled: false,
-            },
-        ]);
-        vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockResolvedValue({
-            workspaceId: 'ws-1',
-            previousState: RatchetState.IDLE,
-            newState: RatchetState.IDLE,
-            action: { type: 'WAITING', reason: 'noop' },
-        });
-        const result = await ratchetService.checkAllWorkspaces();
-        expect(result.checked).toBe(1);
-    });
-    it('does not dispatch when workspace ratcheting is disabled', async () => {
-        const workspace = {
-            id: 'ws-disabled',
-            prUrl: 'https://github.com/example/repo/pull/2',
-            prNumber: 2,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: false,
-            ratchetState: RatchetState.IDLE,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: null,
-            prReviewLastCheckedAt: null,
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        const fetchPRStateSpy = vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState');
-        const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(fetchPRStateSpy).not.toHaveBeenCalled();
-        expect(triggerSpy).not.toHaveBeenCalled();
-        expect(result).toMatchObject({
-            action: { type: 'DISABLED', reason: 'Workspace ratcheting disabled' },
-            newState: RatchetState.IDLE,
-        });
-        expect(workspaceRatchetService.recordCheckIfEnabled).not.toHaveBeenCalled();
-    });
-    it('reports a disabled workspace as IDLE without writing anything', async () => {
-        const workspace = {
-            id: 'ws-disabled-settle',
-            prUrl: 'https://github.com/example/repo/pull/2',
-            prNumber: 2,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: false,
-            ratchetState: RatchetState.IDLE,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: null,
-            prReviewLastCheckedAt: null,
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        const events = [];
-        ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-            events.push(event);
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            previousState: RatchetState.IDLE,
-            newState: RatchetState.IDLE,
-            action: { type: 'DISABLED' },
-        });
-        expect(events).toEqual([]);
-        expect(workspaceRatchetService.recordCheckIfEnabled).not.toHaveBeenCalled();
-    });
-    it('does not dispatch when workspace is not idle', async () => {
-        const workspace = {
-            id: 'ws-busy',
-            prUrl: 'https://github.com/example/repo/pull/3',
-            prNumber: 3,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.IDLE,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: null,
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: '2026-01-02T00:00:00Z',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: new Date('2026-01-02T00:00:00Z').getTime(),
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 3,
-            reviewComments: [
-                {
-                    author: 'reviewer',
-                    body: 'Please update this',
-                    path: 'src/test.ts',
-                    line: 3,
-                    url: 'https://github.com/example/repo/pull/3#discussion_r1',
-                },
-            ],
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
-            {
-                id: 'chat-1',
-                workflow: 'default-followup',
-                status: 'RUNNING',
-            },
-        ]);
-        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-        vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(true);
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: {
-                type: 'WAITING',
-                reason: 'Workspace has another working session',
-            },
-        });
-    });
-    it('dispatches when PR state changed since last ratchet', async () => {
-        const workspace = {
-            id: 'ws-change',
-            prUrl: 'https://github.com/example/repo/pull/4',
-            prNumber: 4,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.IDLE,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: '2026-01-01T00:00:00Z',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: '2026-01-02T00:00:00Z',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 4,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'ratchet-session',
-            promptSent: true,
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: { type: 'TRIGGERED_FIXER' },
-        });
-        expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalledWith('ws-change', {
-            sessionId: 'ratchet-session',
-            snapshotKey: '2026-01-02T00:00:00Z',
-            retryCount: 0,
-        });
-        expect(workspaceRatchetService.recordCheckIfEnabled).toHaveBeenLastCalledWith('ws-change', expect.any(Date));
-        expect(mockSnapshotBridge.recordReviewCheck).toHaveBeenCalledWith('ws-change', expect.any(Date));
-    });
-    it('stops fixer and returns disabled when active-session recording loses disable race', async () => {
-        const workspace = {
-            id: 'ws-disable-race-dispatch',
-            prUrl: 'https://github.com/example/repo/pull/40',
-            prNumber: 40,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.IDLE,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'old-snapshot',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: 'new-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 40,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'raced-session',
-            promptSent: true,
-        });
-        vi.mocked(workspaceRatchetService.recordDispatchIfEnabled).mockResolvedValue(false);
-        vi.mocked(workspaceRatchetService.recordCheckIfEnabled).mockResolvedValue(false);
-        vi.mocked(workspaceDataService.findById).mockResolvedValue({
-            id: 'ws-disable-race-dispatch',
-            ratchetEnabled: false,
-        });
-        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-        const events = [];
-        ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-            events.push(event);
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            newState: RatchetState.IDLE,
-            action: { type: 'DISABLED', reason: 'Workspace ratcheting disabled' },
-        });
-        expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalledWith('ws-disable-race-dispatch', { sessionId: 'raced-session', snapshotKey: 'new-snapshot', retryCount: 0 });
-        expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('raced-session');
-        expect(mockSnapshotBridge.recordReviewCheck).not.toHaveBeenCalled();
-        expect(events).toHaveLength(0);
-    });
-    it('dispatches when session is running but idle', async () => {
-        const workspace = {
-            id: 'ws-idle-session',
-            prUrl: 'https://github.com/example/repo/pull/44',
-            prNumber: 44,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.IDLE,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: '2026-01-01T00:00:00Z',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: '2026-01-02T00:00:00Z',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 44,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
-            {
-                id: 'chat-idle-1',
-                workflow: 'default-followup',
-                status: 'RUNNING',
-            },
-        ]);
-        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-        vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(false);
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'ratchet-session',
-            promptSent: true,
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: { type: 'TRIGGERED_FIXER' },
-        });
-        expect(mockSessionBridge.isSessionWorking).toHaveBeenCalledWith('chat-idle-1');
-        expect(fixerSessionService.acquireAndDispatch).toHaveBeenCalled();
-    });
-    it('does not dispatch when PR state unchanged since last dispatch', async () => {
-        const workspace = {
-            id: 'ws-unchanged',
-            prUrl: 'https://github.com/example/repo/pull/5',
-            prNumber: 5,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: '2026-01-02T00:00:00Z',
-            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: '2026-01-02T00:00:00Z',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 5,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: {
-                type: 'WAITING',
-                reason: 'PR state unchanged since last ratchet dispatch',
-            },
-        });
-        expect(mockSessionBridge.findSessionsByWorkspaceId).not.toHaveBeenCalled();
-        expect(mockSnapshotBridge.recordReviewCheck).not.toHaveBeenCalled();
-    });
-    it('marks the dispatch stalled when a settled dispatch achieved nothing', async () => {
-        const workspace = {
-            id: 'ws-1',
-            prUrl: 'https://github.com/example/repo/pull/5',
-            prNumber: 5,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: '2026-01-02T00:00:00Z',
-            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
-            ratchetDispatchOutcome: 'COMPLETED',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: '2026-01-02T00:00:00Z',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 5,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        await ratchetService.checkWorkspaceById('ws-1');
-        expect(mockWorkspaceBridge.markDispatchStalled).toHaveBeenCalledWith('ws-1', '2026-01-02T00:00:00Z');
-    });
-    it('marks the dispatch stalled when a DIED fixer exhausts its retries', async () => {
-        const workspace = {
-            id: 'ws-1',
-            prUrl: 'https://github.com/example/repo/pull/15',
-            prNumber: 15,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.FAILURE,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'same-snapshot',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'DIED',
-            ratchetDispatchRetryCount: SERVICE_THRESHOLDS.ratchetDispatchMaxRetries,
-        };
-        vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: 'same-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 15,
-        });
-        await ratchetService.checkWorkspaceById('ws-1');
-        expect(mockWorkspaceBridge.markDispatchStalled).toHaveBeenCalledWith('ws-1', 'same-snapshot');
-    });
-    it('publishes a dispatch-changed event when the stall flag actually flips', async () => {
-        const workspace = {
-            id: 'ws-1',
-            prUrl: 'https://github.com/example/repo/pull/5',
-            prNumber: 5,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.FAILURE,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'stalled-key',
-            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
-            ratchetDispatchOutcome: 'COMPLETED',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
-        vi.mocked(mockWorkspaceBridge.markDispatchStalled).mockResolvedValue(true);
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: 'stalled-key',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 5,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        const events = [];
-        ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-            events.push(event);
-        });
-        await ratchetService.checkWorkspaceById('ws-1');
-        expect(events).toEqual([{ workspaceId: 'ws-1' }]);
-    });
-    it('publishes nothing when the stall flag was already set', async () => {
-        const workspace = {
-            id: 'ws-1',
-            prUrl: 'https://github.com/example/repo/pull/5',
-            prNumber: 5,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.FAILURE,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'stalled-key',
-            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
-            ratchetDispatchOutcome: 'COMPLETED',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
-        vi.mocked(mockWorkspaceBridge.markDispatchStalled).mockResolvedValue(false);
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: 'stalled-key',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 5,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        const events = [];
-        ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-            events.push(event);
-        });
-        await ratchetService.checkWorkspaceById('ws-1');
-        expect(events).toEqual([]);
-    });
-    it('does not mark the dispatch stalled when the PR state has changed', async () => {
-        const workspace = {
-            id: 'ws-1',
-            prUrl: 'https://github.com/example/repo/pull/5',
-            prNumber: 5,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'old-snapshot',
-            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: '2026-01-02T00:00:00Z',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 5,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'fresh-session',
-            promptSent: true,
-        });
-        await ratchetService.checkWorkspaceById('ws-1');
-        expect(mockWorkspaceBridge.markDispatchStalled).not.toHaveBeenCalled();
-    });
-    it('does not dispatch repeatedly for unchanged CHANGES_REQUESTED state', async () => {
-        const workspace = {
-            id: 'ws-review-unchanged',
-            prUrl: 'https://github.com/example/repo/pull/55',
-            prNumber: 55,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.REVIEW_PENDING,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'ci:SUCCESS|changes-requested:1735776000000',
-            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'ci:SUCCESS|changes-requested:1735776000000',
-            hasChangesRequested: true,
-            latestReviewActivityAtMs: new Date('2026-01-02T00:00:00Z').getTime(),
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 55,
-            reviewComments: [
-                {
-                    author: 'reviewer',
-                    body: 'Please revise this',
-                    path: 'src/example.ts',
-                    line: 9,
-                    url: 'https://github.com/example/repo/pull/55#discussion_r1',
-                },
-            ],
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(triggerSpy).not.toHaveBeenCalled();
-        expect(result).toMatchObject({
-            action: {
-                type: 'WAITING',
-                reason: 'PR state unchanged since last ratchet dispatch',
-            },
-        });
-        expect(mockSessionBridge.findSessionsByWorkspaceId).not.toHaveBeenCalled();
-    });
-    it('dispatches for CHANGES_REQUESTED when there are no PR review comments', async () => {
-        const workspace = {
-            id: 'ws-review-no-comments',
-            prUrl: 'https://github.com/example/repo/pull/56',
-            prNumber: 56,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.REVIEW_PENDING,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'ci:SUCCESS|changes-requested:old',
-            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'ci:SUCCESS|changes-requested:new',
-            hasChangesRequested: true,
-            latestReviewActivityAtMs: new Date('2026-01-03T00:00:00Z').getTime(),
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 56,
-            reviewComments: [],
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'ratchet-session',
-            promptSent: true,
-        });
-        const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(triggerSpy).toHaveBeenCalled();
-        expect(result).toMatchObject({
-            action: { type: 'TRIGGERED_FIXER' },
-        });
-    });
-    it('dispatches for PR review summary feedback in all-feedback mode', async () => {
-        const workspace = {
-            id: 'ws-review-summary',
-            prUrl: 'https://github.com/example/repo/pull/57',
-            prNumber: 57,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'ci:SUCCESS|no-changes-requested:old|merge:clean',
-            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.mocked(userSettingsService.get).mockResolvedValue({
-            ratchetReviewTriggerMode: 'ALL_REVIEW_FEEDBACK',
-            ratchetReplyToPrComments: true,
-            ratchetPermissions: 'YOLO',
-        });
-        const fetchPRStateSpy = vi
-            .spyOn(unsafeCoerce(ratchetService), 'fetchPRState')
-            .mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'ci:SUCCESS|no-changes-requested:1767315600000|merge:clean',
-            hasChangesRequested: false,
-            hasMergeConflict: false,
-            latestReviewActivityAtMs: new Date('2026-01-02T01:00:00Z').getTime(),
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 57,
-            reviewComments: [
-                {
-                    author: 'cubic-dev-ai',
-                    body: 'Please fix the hydration edge case.',
-                    path: 'PR review',
-                    line: null,
-                    url: 'https://github.com/example/repo/pull/57#pullrequestreview-1',
-                },
-            ],
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'ratchet-session',
-            promptSent: true,
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: { type: 'TRIGGERED_FIXER' },
-            newState: RatchetState.READY,
-        });
-        expect(fixerSessionService.acquireAndDispatch).toHaveBeenCalled();
-        expect(fetchPRStateSpy).toHaveBeenCalledWith(workspace, null, expect.objectContaining({ reviewTriggerMode: 'ALL_REVIEW_FEEDBACK' }), expect.any(AbortSignal));
-    });
-    it('treats closed PR as IDLE and does not dispatch', () => {
-        const state = determineRatchetState({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: '2026-01-02T00:00:00Z',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            prState: 'CLOSED',
-            prNumber: 6,
-        });
-        expect(state).toBe(RatchetState.IDLE);
-    });
-    it('handles prompt delivery failure by clearing active session and stopping runner', async () => {
-        const workspace = {
-            id: 'ws-prompt-fail',
-            prUrl: 'https://github.com/example/repo/pull/7',
-            prNumber: 7,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.IDLE,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: null,
-            prReviewLastCheckedAt: null,
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: '2026-01-02T00:00:00Z',
-            hasChangesRequested: true,
-            latestReviewActivityAtMs: new Date('2026-01-02T00:00:00Z').getTime(),
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 7,
-            reviewComments: [
-                {
-                    author: 'reviewer',
-                    body: 'Please fix this',
-                    path: 'src/example.ts',
-                    line: 12,
-                    url: 'https://github.com/example/repo/pull/7#discussion_r1',
-                },
-            ],
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'ratchet-session',
-            promptSent: false,
-        });
-        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-        vi.mocked(mockSessionBridge.stopSession).mockResolvedValue();
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: { type: 'ERROR', error: 'Failed to deliver initial ratchet prompt' },
-        });
-        expect(workspaceRatchetService.clearActiveSession).toHaveBeenCalledWith(workspace.id, 'ratchet-session');
-        expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('ratchet-session');
-    });
-    it('routes an aborted prompt-failure path through orphan cleanup', async () => {
-        const controller = new AbortController();
-        const timeoutError = new Error('Workspace check timed out');
-        let finishPointerClear;
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'aborted-prompt-session',
-            promptSent: false,
-        });
-        vi.mocked(workspaceRatchetService.clearActiveSession).mockImplementation(() => new Promise((resolve) => {
-            finishPointerClear = () => resolve({});
-        }));
-        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-        const trigger = unsafeCoerce(ratchetService).triggerFixer({
-            id: 'ws-aborted-prompt',
-            prUrl: 'https://github.com/example/repo/pull/7',
-        }, {
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: 'failed:7',
-            prNumber: 7,
-            reviewComments: [],
-            hasMergeConflict: false,
-        }, 0, controller.signal);
-        await vi.waitFor(() => expect(workspaceRatchetService.clearActiveSession).toHaveBeenCalled());
-        controller.abort(timeoutError);
-        finishPointerClear();
-        await expect(trigger).rejects.toBe(timeoutError);
-        expect(workspaceRatchetService.recordSessionEnd).toHaveBeenCalledWith('ws-aborted-prompt', 'aborted-prompt-session', 'COMPLETED');
-        expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('aborted-prompt-session');
-    });
-    it('publishes a dispatch invalidation after lifecycle settlement', async () => {
-        const events = [];
-        ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-            events.push(event);
-        });
-        await ratchetService.recordSessionEnd('ws-1', 'session-1', 'DIED');
-        expect(events).toContainEqual({ workspaceId: 'ws-1' });
-    });
-    it('does not publish a dispatch change when lifecycle settlement loses its CAS', async () => {
-        const events = [];
-        ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-            events.push(event);
-        });
-        vi.mocked(mockWorkspaceBridge.recordSessionEnd).mockResolvedValue(false);
-        await ratchetService.recordSessionEnd('ws-1', 'session-1', 'DIED');
-        expect(events).toHaveLength(0);
-    });
-    it('does not dispatch on a clean PR with no new review activity', async () => {
-        const recentCheck = new Date();
-        const workspace = {
-            id: 'ws-clean',
-            prUrl: 'https://github.com/example/repo/pull/8',
-            prNumber: 8,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: '2026-01-01T00:00:00Z',
-            prReviewLastCheckedAt: recentCheck,
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: '2026-01-03T00:00:00Z',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: recentCheck.getTime() - 1000,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 8,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(triggerSpy).not.toHaveBeenCalled();
-        expect(result).toMatchObject({
-            action: {
-                type: 'WAITING',
-                reason: 'PR is clean (green CI and no new review activity)',
-            },
-        });
-    });
-    it('dispatches stale actionable review comments when the PR snapshot changes', async () => {
-        const recentCheck = new Date();
-        const workspace = {
-            id: 'ws-stale-actionable-review',
-            prUrl: 'https://github.com/example/repo/pull/43',
-            prNumber: 43,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.FAILURE,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'failed-snapshot',
-            prReviewLastCheckedAt: recentCheck,
-            ratchetDispatchOutcome: 'COMPLETED',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'successful-snapshot',
-            hasChangesRequested: false,
-            hasMergeConflict: false,
-            latestReviewActivityAtMs: recentCheck.getTime() - 1000,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 43,
-            reviewComments: [
-                {
-                    author: 'reviewer',
-                    body: 'Please handle this edge case.',
-                    path: 'src/example.ts',
-                    line: 10,
-                    url: 'https://github.com/example/repo/pull/43#discussion_r1',
-                },
-            ],
-        });
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'ratchet-review-session',
-            promptSent: true,
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: { type: 'TRIGGERED_FIXER', sessionId: 'ratchet-review-session' },
-        });
-        expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalledWith('ws-stale-actionable-review', {
-            sessionId: 'ratchet-review-session',
-            snapshotKey: 'successful-snapshot',
-            retryCount: 0,
-        });
-    });
-    it('returns disabled when stale check-state update loses disable race', async () => {
-        const recentCheck = new Date();
-        const workspace = {
-            id: 'ws-disable-race-state',
-            prUrl: 'https://github.com/example/repo/pull/41',
-            prNumber: 41,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'old-snapshot',
-            prReviewLastCheckedAt: recentCheck,
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'new-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: recentCheck.getTime() - 1000,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 41,
-        });
-        vi.mocked(workspaceRatchetService.recordCheckIfEnabled).mockResolvedValue(false);
-        vi.mocked(workspaceDataService.findById).mockResolvedValue({
-            id: 'ws-disable-race-state',
-            ratchetEnabled: false,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        const events = [];
-        ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-            events.push(event);
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            newState: RatchetState.IDLE,
-            action: { type: 'DISABLED', reason: 'Workspace ratcheting disabled' },
-        });
-        expect(events).toHaveLength(0);
-        ratchetService.removeAllListeners();
-    });
-    it('persists PR state and review decision the check observed, not just CI', async () => {
-        const workspace = {
-            id: 'ws-observation',
-            prUrl: 'https://github.com/example/repo/pull/44',
-            prNumber: 44,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.SUCCESS,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'observation-snapshot',
-            prReviewLastCheckedAt: null,
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'observation-snapshot',
-            hasChangesRequested: true,
-            hasMergeConflict: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            cachedPrState: 'CHANGES_REQUESTED',
-            reviewDecision: 'CHANGES_REQUESTED',
-            prNumber: 44,
-            reviewComments: [],
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({
-            workspaceId: 'ws-observation',
-            prUrl: 'https://github.com/example/repo/pull/44',
-            prState: 'CHANGES_REQUESTED',
-            reviewState: 'CHANGES_REQUESTED',
-            ciStatus: CIStatus.SUCCESS,
-            hasMergeConflict: false,
-        }));
-    });
-    it('stops live ratchet sessions before persisting a merged PR', async () => {
-        const workspace = {
-            id: 'ws-merged',
-            prUrl: 'https://github.com/example/repo/pull/45',
-            prNumber: 45,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.SUCCESS,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'merged-snapshot',
-            prReviewLastCheckedAt: null,
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'merged-snapshot',
-            hasChangesRequested: false,
-            hasMergeConflict: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'MERGED',
-            cachedPrState: 'MERGED',
-            reviewDecision: null,
-            prNumber: 45,
-            reviewComments: [],
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
-            {
-                id: 'ratchet-running',
-                workflow: 'ratchet',
-                status: SessionStatus.RUNNING,
-            },
-            {
-                id: 'ratchet-idle',
-                workflow: 'ratchet',
-                status: SessionStatus.IDLE,
-            },
-            {
-                id: 'ratchet-completed',
-                workflow: 'ratchet',
-                status: SessionStatus.COMPLETED,
-            },
-            {
-                id: 'manual-running',
-                workflow: 'default',
-                status: SessionStatus.RUNNING,
-            },
-        ]);
-        vi.mocked(mockSessionBridge.isSessionRunning).mockImplementation((sessionId) => ['ratchet-running', 'ratchet-idle', 'manual-running'].includes(sessionId));
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(mockSessionBridge.stopSession).toHaveBeenCalledTimes(2);
-        expect(mockSessionBridge.stopSession).toHaveBeenNthCalledWith(1, 'ratchet-running');
-        expect(mockSessionBridge.stopSession).toHaveBeenNthCalledWith(2, 'ratchet-idle');
-        expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({
-            workspaceId: 'ws-merged',
-            prUrl: 'https://github.com/example/repo/pull/45',
-            prState: 'MERGED',
-        }));
-        expect(vi.mocked(mockSessionBridge.stopSession).mock.invocationCallOrder.at(-1)).toBeLessThan(vi.mocked(mockSnapshotBridge.recordPrObservation).mock.invocationCallOrder[0] ?? 0);
-        expect(result).toMatchObject({
-            newState: RatchetState.MERGED,
-            action: { type: 'COMPLETED' },
-        });
-    });
-    it('does not persist a merged PR when stopping a ratchet session fails', async () => {
-        const workspace = {
-            id: 'ws-merged-stop-failure',
-            prUrl: 'https://github.com/example/repo/pull/46',
-            prNumber: 46,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.SUCCESS,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: 'ratchet-running',
-            ratchetDispatchSnapshotKey: 'merged-stop-failure-snapshot',
-            prReviewLastCheckedAt: null,
-            ratchetDispatchOutcome: 'RUNNING',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'merged-stop-failure-snapshot',
-            hasChangesRequested: false,
-            hasMergeConflict: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'MERGED',
-            cachedPrState: 'MERGED',
-            reviewDecision: null,
-            prNumber: 46,
-            reviewComments: [],
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
-            {
-                id: 'ratchet-running',
-                workflow: 'ratchet',
-                status: SessionStatus.RUNNING,
-            },
-        ]);
-        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-        vi.mocked(mockSessionBridge.stopSession).mockRejectedValue(new Error('stop failed'));
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            previousState: RatchetState.READY,
-            newState: RatchetState.READY,
-            action: { type: 'ERROR', error: 'stop failed' },
-        });
-        expect(workspaceRatchetService.recordCheckIfEnabled).not.toHaveBeenCalled();
-        expect(mockSnapshotBridge.recordPrObservation).not.toHaveBeenCalled();
-    });
-    it('persists a newly observed merge conflict even when CI status is unchanged', async () => {
-        const workspace = {
-            id: 'ws-conflict',
-            prUrl: 'https://github.com/example/repo/pull/43',
-            prNumber: 43,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.SUCCESS,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'conflict-snapshot',
-            prReviewLastCheckedAt: null,
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'conflict-snapshot',
-            hasChangesRequested: false,
-            hasMergeConflict: true,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            cachedPrState: 'OPEN',
-            reviewDecision: null,
-            prNumber: 43,
-            reviewComments: [],
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({
-            workspaceId: 'ws-conflict',
-            prUrl: 'https://github.com/example/repo/pull/43',
-            ciStatus: CIStatus.SUCCESS,
-            hasMergeConflict: true,
-        }));
-    });
-    it('redispatches with an incremented retry count when the previous fixer died', async () => {
-        const workspace = {
-            id: 'ws-died-retry',
-            prUrl: 'https://github.com/example/repo/pull/13',
-            prNumber: 13,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.FAILURE,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'same-snapshot',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'DIED',
-            ratchetDispatchRetryCount: 1,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: 'same-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 13,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'retry-session',
-            promptSent: true,
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: { type: 'TRIGGERED_FIXER' },
-        });
-        expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalledWith('ws-died-retry', {
-            sessionId: 'retry-session',
-            snapshotKey: 'same-snapshot',
-            retryCount: 2,
-        });
-    });
-    it('redispatches a died fixer even when the PR is otherwise clean', async () => {
-        const checkedAt = new Date('2026-01-02T00:00:00Z');
-        const workspace = {
-            id: 'ws-died-clean',
-            prUrl: 'https://github.com/example/repo/pull/14',
-            prNumber: 14,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.SUCCESS,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'clean-snapshot',
-            prReviewLastCheckedAt: checkedAt,
-            ratchetDispatchOutcome: 'DIED',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'clean-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: checkedAt.getTime() - 1000,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 14,
-            reviewComments: [],
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'retry-session',
-            promptSent: true,
-        });
-        const events = [];
-        ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-            events.push(event);
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: { type: 'TRIGGERED_FIXER' },
-        });
-        expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalledWith('ws-died-clean', {
-            sessionId: 'retry-session',
-            snapshotKey: 'clean-snapshot',
-            retryCount: 1,
-        });
-        expect(events).toContainEqual({ workspaceId: 'ws-died-clean' });
-    });
-    it('stops retrying a died fixer once the retry budget is exhausted', async () => {
-        const workspace = {
-            id: 'ws-died-exhausted',
-            prUrl: 'https://github.com/example/repo/pull/15',
-            prNumber: 15,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.FAILURE,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'same-snapshot',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'DIED',
-            ratchetDispatchRetryCount: 3,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: 'same-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 15,
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: {
-                type: 'WAITING',
-                reason: 'Fixer died 4 times for this PR state; waiting for PR state to change',
-            },
-        });
-        expect(fixerSessionService.acquireAndDispatch).not.toHaveBeenCalled();
-    });
-    it('resets the retry count when the PR state changes after a death', async () => {
-        const workspace = {
-            id: 'ws-died-changed',
-            prUrl: 'https://github.com/example/repo/pull/16',
-            prNumber: 16,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.FAILURE,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'old-snapshot',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'DIED',
-            ratchetDispatchRetryCount: 3,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: 'new-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 16,
-        });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'fresh-session',
-            promptSent: true,
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: { type: 'TRIGGERED_FIXER' },
-        });
-        expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalledWith('ws-died-changed', { sessionId: 'fresh-session', snapshotKey: 'new-snapshot', retryCount: 0 });
-    });
-    it('does not redispatch when the previous fixer completed and PR state is unchanged', async () => {
-        const workspace = {
-            id: 'ws-completed-unchanged',
-            prUrl: 'https://github.com/example/repo/pull/17',
-            prNumber: 17,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.FAILURE,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'same-snapshot',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'COMPLETED',
-            ratchetDispatchRetryCount: 2,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: 'same-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 17,
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: {
-                type: 'WAITING',
-                reason: 'PR state unchanged since last ratchet dispatch',
-            },
-        });
-        expect(fixerSessionService.acquireAndDispatch).not.toHaveBeenCalled();
-    });
-    it('dispatches a fresh fixer after switching PRs with identical merge-conflict state', async () => {
-        const previousSnapshotKey = computeDispatchSnapshotKey(123, CIStatus.SUCCESS, false, null, null, true);
-        const currentSnapshotKey = computeDispatchSnapshotKey(456, CIStatus.SUCCESS, false, null, null, true);
-        expect(previousSnapshotKey).toBe('pr:123|ci:SUCCESS|no-changes-requested:none|merge:conflict');
-        expect(currentSnapshotKey).toBe('pr:456|ci:SUCCESS|no-changes-requested:none|merge:conflict');
-        const workspace = {
-            id: 'ws-pr-switch-merge-conflict',
-            prUrl: 'https://github.com/example/repo/pull/456',
-            prNumber: 456,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.SUCCESS,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.MERGE_CONFLICT,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: previousSnapshotKey,
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'COMPLETED',
-            ratchetDispatchRetryCount: 2,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: currentSnapshotKey,
-            hasChangesRequested: false,
-            hasMergeConflict: true,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 456,
-            reviewComments: [],
-        });
-        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-            status: 'started',
-            sessionId: 'fresh-pr-session',
-            promptSent: true,
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: { type: 'TRIGGERED_FIXER' },
-        });
-        expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalledWith(workspace.id, {
-            sessionId: 'fresh-pr-session',
-            snapshotKey: currentSnapshotKey,
-            retryCount: 0,
-        });
-    });
-    it('settles the dispatch as DIED when ratchet session process is not running', async () => {
-        const workspace = {
-            id: 'ws-stale-active',
-            prUrl: 'https://github.com/example/repo/pull/9',
-            prNumber: 9,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: 'ratchet-session',
-            ratchetDispatchSnapshotKey: 'previous-snapshot-key',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'RUNNING',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
-            id: 'ratchet-session',
-            provider: 'CLAUDE',
-            status: SessionStatus.RUNNING,
-        });
-        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(false);
-        const result = await unsafeCoerce(ratchetService).checkActiveFixerSession(workspace);
-        expect(result).toEqual({ kind: 'settled', outcome: 'DIED' });
-        expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith(workspace.id, 'ratchet-session', 'DIED');
-    });
-    it('settles the dispatch as DIED when ratchet session is not found in database', async () => {
-        const workspace = {
-            id: 'ws-missing-session',
-            prUrl: 'https://github.com/example/repo/pull/12',
-            prNumber: 12,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: 'deleted-session',
-            ratchetDispatchSnapshotKey: 'previous-snapshot-key',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'RUNNING',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue(null);
-        const events = [];
-        ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-            events.push(event);
-        });
-        const result = await unsafeCoerce(ratchetService).checkActiveFixerSession(workspace);
-        expect(result).toEqual({ kind: 'settled', outcome: 'DIED' });
-        expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith(workspace.id, 'deleted-session', 'DIED');
-        expect(events).toEqual([{ workspaceId: 'ws-missing-session' }]);
-    });
-    it('reports a concurrent end when another path already settled the dispatch', async () => {
-        const workspace = {
-            id: 'ws-concurrent-end',
-            prUrl: 'https://github.com/example/repo/pull/12',
-            prNumber: 12,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: 'finished-session',
-            ratchetDispatchSnapshotKey: 'previous-snapshot-key',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'RUNNING',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue(null);
-        vi.mocked(mockWorkspaceBridge.recordSessionEnd).mockResolvedValue(false);
-        const events = [];
-        ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-            events.push(event);
-        });
-        const result = await unsafeCoerce(ratchetService).checkActiveFixerSession(workspace);
-        expect(result).toEqual({ kind: 'ended_concurrently' });
-        expect(events).toHaveLength(0);
-    });
-    it('waits for the next cycle when the fixer ends concurrently mid-check', async () => {
-        const workspace = {
-            id: 'ws-concurrent-wait',
-            prUrl: 'https://github.com/example/repo/pull/12',
-            prNumber: 12,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: 'finished-session',
-            ratchetDispatchSnapshotKey: 'previous-snapshot-key',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'RUNNING',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-            ciStatus: CIStatus.FAILURE,
-            snapshotKey: 'new-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 12,
-        });
-        vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue(null);
-        vi.mocked(mockWorkspaceBridge.recordSessionEnd).mockResolvedValue(false);
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            action: {
-                type: 'WAITING',
-                reason: 'Fixer session ended during this check; re-evaluating next cycle',
-            },
-        });
-        expect(fixerSessionService.acquireAndDispatch).not.toHaveBeenCalled();
-    });
-    it('settles the dispatch as COMPLETED when ratchet session finished its work', async () => {
-        const workspace = {
-            id: 'ws-idle-active',
-            prUrl: 'https://github.com/example/repo/pull/11',
-            prNumber: 11,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: 'ratchet-session',
-            ratchetDispatchSnapshotKey: 'snapshot-key',
-            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
-            ratchetDispatchOutcome: 'RUNNING',
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
-            id: 'ratchet-session',
-            provider: 'CLAUDE',
-            status: SessionStatus.RUNNING,
-        });
-        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-        vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(false);
-        vi.mocked(mockSessionBridge.stopSession).mockResolvedValue();
-        const result = await unsafeCoerce(ratchetService).checkActiveFixerSession(workspace);
-        expect(result).toEqual({ kind: 'settled', outcome: 'COMPLETED' });
-        expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith(workspace.id, 'ratchet-session', 'COMPLETED');
-        expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('ratchet-session');
-    });
-    it('decides to trigger fixer when context is actionable', async () => {
-        const decision = await unsafeCoerce(ratchetService).decideRatchetAction({
-            workspace: { id: 'ws-decide', ratchetEnabled: true },
-            prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.FAILURE },
-            isCleanPrWithNoNewReviewActivity: false,
-            activeFixerCheck: { kind: 'none' },
-            dispatchOutcome: null,
-            dispatchRetryCount: 0,
-            hasStateChangedSinceLastDispatch: true,
-        });
-        expect(decision).toEqual({ type: 'TRIGGER_FIXER', retryCount: 0 });
-    });
-    it('waits when CI is not in terminal state (PENDING)', async () => {
-        const decision = await unsafeCoerce(ratchetService).decideRatchetAction({
-            workspace: { id: 'ws-decide', ratchetEnabled: true },
-            prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.PENDING },
-            isCleanPrWithNoNewReviewActivity: false,
-            activeFixerCheck: { kind: 'none' },
-            dispatchOutcome: null,
-            dispatchRetryCount: 0,
-            hasStateChangedSinceLastDispatch: true,
-        });
-        expect(decision).toEqual({
-            type: 'RETURN_ACTION',
-            action: { type: 'WAITING', reason: 'Waiting for CI to complete (not in terminal state)' },
-        });
-    });
-    it('waits when CI is not in terminal state (UNKNOWN)', async () => {
-        const decision = await unsafeCoerce(ratchetService).decideRatchetAction({
-            workspace: { id: 'ws-decide', ratchetEnabled: true },
-            prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.UNKNOWN },
-            isCleanPrWithNoNewReviewActivity: false,
-            activeFixerCheck: { kind: 'none' },
-            dispatchOutcome: null,
-            dispatchRetryCount: 0,
-            hasStateChangedSinceLastDispatch: true,
-        });
-        expect(decision).toEqual({
-            type: 'RETURN_ACTION',
-            action: { type: 'WAITING', reason: 'Waiting for CI to complete (not in terminal state)' },
-        });
-    });
-    it('prefers precomputed review-activity diagnostics from decision context', () => {
-        const workspace = {
-            id: 'ws-log-diag',
-            prUrl: 'https://github.com/example/repo/pull/10',
-            prNumber: 10,
-            prState: 'OPEN',
-            prReviewState: null,
-            prHasMergeConflict: false,
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: true,
-            ratchetState: RatchetState.READY,
-            ratchetActiveSessionId: null,
-            ratchetDispatchSnapshotKey: 'prev-snapshot',
-            prReviewLastCheckedAt: null,
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        const prStateInfo = {
-            ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'next-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: null,
-            statusCheckRollup: null,
-            prState: 'OPEN',
-            prNumber: 10,
-        };
-        const logContext = buildRatchetingLogContext({
-            workspace: workspace,
-            previousState: RatchetState.READY,
-            newState: RatchetState.READY,
-            action: { type: 'WAITING', reason: 'noop' },
-            prStateInfo: prStateInfo,
-            prNumber: 10,
-            decisionContext: { hasNewReviewActivitySinceLastDispatch: true },
-        });
-        expect(logContext.reviewTimestampComparison?.hasNewReviewActivitySinceLastDispatch).toBe(true);
-    });
-    it('ignores review activity authored by the authenticated user', () => {
-        const latestActivity = computeLatestReviewActivityAtMs({
-            reviews: [
-                {
-                    submittedAt: '2026-01-02T00:00:00Z',
-                    author: { login: 'ratchet-bot' },
-                    state: 'CHANGES_REQUESTED',
-                },
-                {
-                    submittedAt: '2026-01-01T00:00:00Z',
-                    author: { login: 'reviewer' },
-                    state: 'CHANGES_REQUESTED',
-                },
-            ],
-            comments: [{ updatedAt: '2026-01-02T01:00:00Z', author: { login: 'ratchet-bot' } }],
-        }, [{ updatedAt: '2026-01-01T02:00:00Z', author: { login: 'reviewer2' } }], 'ratchet-bot', 'CHANGES_REQUESTED');
-        expect(latestActivity).toBe(new Date('2026-01-01T02:00:00Z').getTime());
-    });
-    describe('determineRatchetState', () => {
-        const callDetermineRatchetState = (pr) => determineRatchetState(pr);
-        it('returns MERGED for merged PR', () => {
-            expect(callDetermineRatchetState({
-                ciStatus: CIStatus.SUCCESS,
-                prState: 'MERGED',
-                hasChangesRequested: false,
-            })).toBe(RatchetState.MERGED);
-        });
-        it('returns IDLE for closed (non-merged) PR', () => {
-            expect(callDetermineRatchetState({
-                ciStatus: CIStatus.SUCCESS,
-                prState: 'CLOSED',
-                hasChangesRequested: false,
-            })).toBe(RatchetState.IDLE);
-        });
-        it('returns CI_RUNNING for PENDING CI on open PR', () => {
-            expect(callDetermineRatchetState({
-                ciStatus: CIStatus.PENDING,
-                prState: 'OPEN',
-                hasChangesRequested: false,
-            })).toBe(RatchetState.CI_RUNNING);
-        });
-        it('returns CI_RUNNING for UNKNOWN CI on open PR', () => {
-            expect(callDetermineRatchetState({
-                ciStatus: CIStatus.UNKNOWN,
-                prState: 'OPEN',
-                hasChangesRequested: false,
-            })).toBe(RatchetState.CI_RUNNING);
-        });
-        it('returns CI_FAILED for FAILURE CI on open PR', () => {
-            expect(callDetermineRatchetState({
-                ciStatus: CIStatus.FAILURE,
-                prState: 'OPEN',
-                hasChangesRequested: false,
-            })).toBe(RatchetState.CI_FAILED);
-        });
-        it('returns REVIEW_PENDING when changes requested on open PR with passing CI', () => {
-            expect(callDetermineRatchetState({
-                ciStatus: CIStatus.SUCCESS,
-                prState: 'OPEN',
-                hasChangesRequested: true,
-            })).toBe(RatchetState.REVIEW_PENDING);
-        });
-        it('returns READY when open PR with passing CI and no changes requested', () => {
-            expect(callDetermineRatchetState({
-                ciStatus: CIStatus.SUCCESS,
-                prState: 'OPEN',
-                hasChangesRequested: false,
-            })).toBe(RatchetState.READY);
-        });
-        it('returns CI_FAILED even when changes are requested if CI is failing', () => {
-            expect(callDetermineRatchetState({
-                ciStatus: CIStatus.FAILURE,
-                prState: 'OPEN',
-                hasChangesRequested: true,
-            })).toBe(RatchetState.CI_FAILED);
-        });
-    });
-    describe('computeDispatchSnapshotKey', () => {
-        const callComputeSnapshotKey = (ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks) => computeDispatchSnapshotKey(123, ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks);
-        it('includes CI status in key for non-failure states', () => {
-            const key = callComputeSnapshotKey(CIStatus.SUCCESS, false, null, null);
-            expect(key).toContain('ci:SUCCESS');
-            expect(key).toContain('no-changes-requested');
-            expect(key).toContain('none');
-        });
-        it('includes failed check details in key for FAILURE status', () => {
-            const key = callComputeSnapshotKey(CIStatus.FAILURE, false, null, [
-                {
-                    name: 'test',
-                    conclusion: 'FAILURE',
-                    detailsUrl: 'https://github.com/o/r/actions/runs/12345',
-                },
-            ]);
-            expect(key).toContain('ci:FAILURE');
-            expect(key).toContain('test:FAILURE:12345');
-        });
-        it('sorts failed checks for stable key generation', () => {
-            const key = callComputeSnapshotKey(CIStatus.FAILURE, false, null, [
-                {
-                    name: 'ztest',
-                    conclusion: 'FAILURE',
-                    detailsUrl: 'https://github.com/o/r/actions/runs/2',
-                },
-                {
-                    name: 'atest',
-                    conclusion: 'FAILURE',
-                    detailsUrl: 'https://github.com/o/r/actions/runs/1',
-                },
-            ]);
-            expect(key.indexOf('atest')).toBeLessThan(key.indexOf('ztest'));
-        });
-        it('uses unknown for FAILURE with empty check array', () => {
-            const key = callComputeSnapshotKey(CIStatus.FAILURE, false, null, []);
-            expect(key).toContain('ci:FAILURE:unknown');
-        });
-        it('includes review activity timestamp in key', () => {
-            const ts = 1_735_776_000_000;
-            const key = callComputeSnapshotKey(CIStatus.SUCCESS, true, ts, null);
-            expect(key).toContain(`changes-requested:${ts}`);
-        });
-    });
-    describe('computeLatestReviewActivityAtMs edge cases', () => {
-        const callCompute = (prDetails, reviewComments, authenticatedUsername) => computeLatestReviewActivityAtMs(prDetails, reviewComments, authenticatedUsername, 'CHANGES_REQUESTED');
-        it('returns null when there are no reviews or comments', () => {
-            expect(callCompute({ reviews: [], comments: [] }, [], null)).toBeNull();
-        });
-        it('returns null when all activity is from the authenticated user', () => {
-            expect(callCompute({
-                reviews: [
-                    {
-                        submittedAt: '2026-01-01T00:00:00Z',
-                        author: { login: 'me' },
-                        state: 'CHANGES_REQUESTED',
-                    },
-                ],
-                comments: [{ updatedAt: '2026-01-02T00:00:00Z', author: { login: 'me' } }],
-            }, [{ updatedAt: '2026-01-03T00:00:00Z', author: { login: 'me' } }], 'me')).toBeNull();
-        });
-        it('does not filter when authenticatedUsername is null', () => {
-            const result = callCompute({
-                reviews: [
-                    {
-                        submittedAt: '2026-01-01T00:00:00Z',
-                        author: { login: 'bot' },
-                        state: 'CHANGES_REQUESTED',
-                    },
-                ],
-                comments: [],
-            }, [], null);
-            expect(result).toBe(new Date('2026-01-01T00:00:00Z').getTime());
-        });
-        it('ignores reviews with null submittedAt and ordinary PR comments', () => {
-            const result = callCompute({
-                reviews: [
-                    {
-                        submittedAt: null,
-                        author: { login: 'reviewer' },
-                        state: 'CHANGES_REQUESTED',
-                    },
-                ],
-                comments: [{ updatedAt: '2026-01-02T00:00:00Z', author: { login: 'commenter' } }],
-            }, [], null);
-            expect(result).toBeNull();
-        });
-        it('returns the latest timestamp across all sources', () => {
-            const result = callCompute({
-                reviews: [
-                    {
-                        submittedAt: '2026-01-01T00:00:00Z',
-                        author: { login: 'a' },
-                        state: 'CHANGES_REQUESTED',
-                    },
-                ],
-                comments: [{ updatedAt: '2026-01-03T00:00:00Z', author: { login: 'b' } }],
-            }, [{ updatedAt: '2026-01-02T00:00:00Z', author: { login: 'c' } }], null);
-            expect(result).toBe(new Date('2026-01-02T00:00:00Z').getTime());
-        });
-    });
-    describe('processWorkspace error handling', () => {
-        it('returns ERROR action when fetchPRState returns null', async () => {
-            const workspace = {
-                id: 'ws-fetch-err',
-                prUrl: 'https://github.com/example/repo/pull/99',
-                prNumber: 99,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue(null);
-            const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-            expect(result).toMatchObject({
-                action: { type: 'ERROR', error: 'Failed to fetch PR state' },
-                newState: RatchetState.IDLE,
-            });
-        });
-        it('returns WAITING action when fetchPRState skips a recent fetch', async () => {
-            const workspace = {
-                id: 'ws-recent-fetch',
-                prUrl: 'https://github.com/example/repo/pull/99',
-                prNumber: 99,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({ skipped: true, reason: 'recently_fetched' });
-            const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-            expect(result).toMatchObject({
-                action: { type: 'WAITING', reason: 'recently_fetched' },
-                newState: RatchetState.IDLE,
-            });
-            expect(workspaceRatchetService.clearActiveSession).not.toHaveBeenCalled();
-        });
-        it('returns WAITING when shutting down', async () => {
-            setRatchetShuttingDown(true);
-            const workspace = {
-                id: 'ws-shutdown',
-                prUrl: 'https://github.com/example/repo/pull/1',
-                prNumber: 1,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-            expect(result).toMatchObject({
-                action: { type: 'WAITING', reason: 'Shutting down' },
-                previousState: RatchetState.CI_FAILED,
-                newState: RatchetState.CI_FAILED,
-            });
-        });
-        it('returns ERROR and preserves state when processWorkspace throws', async () => {
-            const workspace = {
-                id: 'ws-throw',
-                prUrl: 'https://github.com/example/repo/pull/50',
-                prNumber: 50,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockRejectedValue(new Error('Unexpected explosion'));
-            const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-            expect(result).toMatchObject({
-                action: { type: 'ERROR', error: 'Unexpected explosion' },
-                previousState: RatchetState.CI_FAILED,
-                newState: RatchetState.CI_FAILED,
-            });
-        });
-    });
-    describe('checkAllWorkspaces', () => {
-        it('returns zero counts when shutting down', async () => {
-            setRatchetShuttingDown(true);
-            const result = await ratchetService.checkAllWorkspaces();
-            expect(result).toEqual({ checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] });
-        });
-        it('returns zero counts when no workspaces have PRs', async () => {
-            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue([]);
-            const result = await ratchetService.checkAllWorkspaces();
-            expect(result).toEqual({ checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] });
-        });
-        it('loads the global review trigger mode once for the whole batch', async () => {
-            const workspaces = ['ws-one', 'ws-two'].map((id) => ({
-                id,
-                prUrl: `https://github.com/example/repo/pull/${id}`,
-                prNumber: 1,
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiStatus: CIStatus.UNKNOWN,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            }));
-            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue(workspaces);
-            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({ skipped: true, reason: 'recently_fetched' });
-            const result = await ratchetService.checkAllWorkspaces();
-            expect(result.checked).toBe(2);
-            expect(userSettingsService.get).toHaveBeenCalledTimes(1);
-        });
-        it('returns an error result when one workspace check times out', async () => {
-            unsafeCoerce(ratchetService).workspaceCheckTimeoutMs = 5;
-            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue([
-                {
-                    id: 'ws-timeout',
-                    prUrl: 'https://github.com/example/repo/pull/1',
-                    prNumber: 1,
-                    prState: 'OPEN',
-                    prCiStatus: CIStatus.FAILURE,
-                    defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                    ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-                    ratchetEnabled: true,
-                    ratchetState: RatchetState.IDLE,
-                    ratchetActiveSessionId: null,
-                    ratchetDispatchSnapshotKey: null,
-                    prReviewLastCheckedAt: null,
-                    ratchetDispatchOutcome: null,
-                    ratchetDispatchRetryCount: 0,
-                },
-                {
-                    id: 'ws-fast',
-                    prUrl: 'https://github.com/example/repo/pull/2',
-                    prNumber: 2,
-                    prState: 'OPEN',
-                    prCiStatus: CIStatus.SUCCESS,
-                    defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                    ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-                    ratchetEnabled: true,
-                    ratchetState: RatchetState.CI_RUNNING,
-                    ratchetActiveSessionId: null,
-                    ratchetDispatchSnapshotKey: null,
-                    prReviewLastCheckedAt: null,
-                    ratchetDispatchOutcome: null,
-                    ratchetDispatchRetryCount: 0,
-                },
-            ]);
-            vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockImplementation((workspace, _opts, signal) => {
-                if (workspace.id === 'ws-timeout') {
-                    return new Promise((_resolve, reject) => {
-                        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
-                    });
-                }
-                return Promise.resolve({
-                    workspaceId: workspace.id,
-                    previousState: RatchetState.CI_RUNNING,
-                    newState: RatchetState.CI_RUNNING,
-                    action: { type: 'WAITING', reason: 'noop' },
-                });
-            });
-            const result = await ratchetService.checkAllWorkspaces();
-            expect(result.checked).toBe(2);
-            expect(result.results).toEqual(expect.arrayContaining([
-                expect.objectContaining({
-                    workspaceId: 'ws-timeout',
-                    action: expect.objectContaining({
-                        type: 'ERROR',
-                        error: expect.stringContaining('timed out'),
-                    }),
-                }),
-                expect.objectContaining({
-                    workspaceId: 'ws-fast',
-                    action: { type: 'WAITING', reason: 'noop' },
-                }),
-            ]));
-        });
-        it('does not count concurrency queue wait toward the workspace timeout', async () => {
-            unsafeCoerce(ratchetService).workspaceCheckTimeoutMs = 5;
-            const workspaces = Array.from({ length: 4 }, (_, index) => ({
-                id: `ws-queued-timeout-${index}`,
-                prUrl: `https://github.com/example/repo/pull/${index + 1}`,
-                prNumber: index + 1,
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiStatus: CIStatus.UNKNOWN,
-                defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            }));
-            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue(workspaces);
-            const processWorkspaceSpy = vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace');
-            processWorkspaceSpy.mockImplementation((workspace, _opts, signal) => {
-                if (workspace.id !== 'ws-queued-timeout-3') {
-                    return new Promise((_resolve, reject) => {
-                        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
-                    });
-                }
-                return Promise.resolve({
-                    workspaceId: workspace.id,
-                    previousState: RatchetState.IDLE,
-                    newState: RatchetState.IDLE,
-                    action: { type: 'WAITING', reason: 'ran after queue' },
-                });
-            });
-            const result = await ratchetService.checkAllWorkspaces();
-            expect(processWorkspaceSpy).toHaveBeenCalledWith(expect.objectContaining({ id: 'ws-queued-timeout-3' }), undefined, expect.any(AbortSignal), expect.any(Function), 'CHANGES_REQUESTED');
-            expect(result.results[3]).toMatchObject({
-                workspaceId: 'ws-queued-timeout-3',
-                action: { type: 'WAITING', reason: 'ran after queue' },
-            });
-        });
-        it('lets a committed dispatch finish instead of reporting a timeout error', async () => {
-            unsafeCoerce(ratchetService).workspaceCheckTimeoutMs = 5;
-            const workspace = {
-                id: 'ws-committed-dispatch',
-                prUrl: 'https://github.com/example/repo/pull/1',
-                prNumber: 1,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-            };
-            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue([workspace]);
-            let finishCommit;
-            const commitBarrier = new Promise((resolve) => {
-                finishCommit = resolve;
-            });
-            vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockImplementation(async (workspaceArg, _opts, signal, commitSideEffects) => {
-                commitSideEffects();
-                await commitBarrier;
-                signal.throwIfAborted();
-                return {
-                    workspaceId: workspaceArg.id,
-                    previousState: RatchetState.IDLE,
-                    newState: RatchetState.IDLE,
-                    action: { type: 'TRIGGERED_FIXER', sessionId: 'session-1', promptSent: true },
-                };
-            });
-            const resultPromise = ratchetService.checkAllWorkspaces();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            finishCommit();
-            const result = await resultPromise;
-            expect(result.results[0]).toMatchObject({
-                workspaceId: workspace.id,
-                action: { type: 'TRIGGERED_FIXER', sessionId: 'session-1' },
-            });
-        });
-        it('runs at most three workspace checks concurrently', async () => {
-            const workspaces = Array.from({ length: 7 }, (_, index) => ({
-                id: `ws-${index}`,
-                prUrl: `https://github.com/example/repo/pull/${index + 1}`,
-                prNumber: index + 1,
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiStatus: CIStatus.UNKNOWN,
-                defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            }));
-            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue(workspaces);
-            let active = 0;
-            let maximumActive = 0;
-            let releaseChecks;
-            const checkBarrier = new Promise((resolve) => {
-                releaseChecks = resolve;
-            });
-            vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockImplementation(async (workspace) => {
-                active += 1;
-                maximumActive = Math.max(maximumActive, active);
-                await checkBarrier;
-                active -= 1;
-                return {
-                    workspaceId: workspace.id,
-                    previousState: RatchetState.IDLE,
-                    newState: RatchetState.IDLE,
-                    action: { type: 'WAITING', reason: 'noop' },
-                };
-            });
-            const resultPromise = ratchetService.checkAllWorkspaces();
-            await vi.waitFor(() => expect(active).toBe(3));
-            expect(maximumActive).toBe(3);
-            releaseChecks();
-            const result = await resultPromise;
-            expect(maximumActive).toBe(3);
-            expect(result.checked).toBe(7);
-            expect(result.results).toHaveLength(7);
-        });
-    });
-    describe('shutdown behavior', () => {
-        it('stops immediately while monitor loop is sleeping', async () => {
-            vi.useFakeTimers();
-            vi.spyOn(ratchetService, 'checkAllWorkspaces').mockResolvedValue({
-                checked: 0,
-                stateChanges: 0,
-                actionsTriggered: 0,
-                results: [],
-            });
-            ratchetService.start();
-            await Promise.resolve();
-            await Promise.resolve();
-            await expect(ratchetService.stop()).resolves.toBeUndefined();
-            vi.useRealTimers();
-        });
-    });
-    describe('check abort safety', () => {
-        afterEach(() => {
-            ratchetService.removeAllListeners();
-        });
-        it('does not continue to side effects after a timed-out await completes', async () => {
-            unsafeCoerce(ratchetService).workspaceCheckTimeoutMs = 5;
-            const workspace = {
-                id: 'ws-zombie',
-                prUrl: 'https://github.com/example/repo/pull/1',
-                prNumber: 1,
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiStatus: CIStatus.FAILURE,
-                defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue([workspace]);
-            let releaseFetch;
-            const fetchBarrier = new Promise((resolve) => {
-                releaseFetch = resolve;
-            });
-            const finishSpy = vi.spyOn(unsafeCoerce(ratchetService), 'finishRatchetCheck');
-            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockImplementation(async () => {
-                await fetchBarrier;
-                return {
-                    ciStatus: CIStatus.FAILURE,
-                    snapshotKey: 'failed:1',
-                    hasChangesRequested: false,
-                    hasMergeConflict: false,
-                    latestReviewActivityAtMs: null,
-                    statusCheckRollup: [],
-                    prState: 'OPEN',
-                    prNumber: 1,
-                    reviewComments: [],
-                };
-            });
-            const result = await ratchetService.checkAllWorkspaces();
-            expect(result.results[0]?.action.type).toBe('ERROR');
-            releaseFetch();
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            expect(finishSpy).not.toHaveBeenCalled();
-            expect(workspaceRatchetService.recordCheckIfEnabled).not.toHaveBeenCalled();
-        });
-    });
-    describe('checkWorkspaceById', () => {
-        it('returns null when shutting down', async () => {
-            setRatchetShuttingDown(true);
-            const result = await ratchetService.checkWorkspaceById('ws-1');
-            expect(result).toBeNull();
-        });
-        it('returns null when workspace not found', async () => {
-            setRatchetShuttingDown(false);
-            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(null);
-            const result = await ratchetService.checkWorkspaceById('ws-nonexistent');
-            expect(result).toBeNull();
-        });
-        it('skips the PR fetch when the workspace was recently fetched', async () => {
-            const workspace = {
-                id: 'ws-cooldown',
-                prUrl: 'https://github.com/example/repo/pull/9',
-                prNumber: 9,
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiStatus: CIStatus.UNKNOWN,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_RUNNING,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
-            vi.mocked(mockGitHubBridge.extractPRInfo).mockReturnValue({
-                owner: 'example',
-                repo: 'repo',
-                number: 9,
-            });
-            fakeCoordinator.cooldownActive = true;
-            const result = await ratchetService.checkWorkspaceById('ws-cooldown');
-            expect(result?.action).toEqual({ type: 'WAITING', reason: 'recently_fetched' });
-            expect(mockGitHubBridge.getPRFullDetails).not.toHaveBeenCalled();
-        });
-        it('bypasses the PR fetch cooldown when requested by an event-driven check', async () => {
-            const workspace = {
-                id: 'ws-bypass',
-                prUrl: 'https://github.com/example/repo/pull/9',
-                prNumber: 9,
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiStatus: CIStatus.UNKNOWN,
-                defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_RUNNING,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
-            vi.mocked(mockGitHubBridge.extractPRInfo).mockReturnValue({
-                owner: 'example',
-                repo: 'repo',
-                number: 9,
-            });
-            fakeCoordinator.cooldownActive = true;
-            vi.mocked(mockGitHubBridge.getPRFullDetails).mockResolvedValue({
-                isDraft: false,
-                state: 'OPEN',
-                number: 9,
-                url: 'https://github.com/example/repo/pull/9',
-                reviewDecision: null,
-                mergeStateStatus: 'CLEAN',
-                reviews: [],
-                comments: [],
-                statusCheckRollup: null,
-            });
-            vi.mocked(mockGitHubBridge.getReviewComments).mockResolvedValue([]);
-            vi.mocked(mockGitHubBridge.computeCIStatus).mockReturnValue(CIStatus.SUCCESS);
-            const result = await ratchetService.checkWorkspaceById('ws-bypass', {
-                bypassPrFetchCooldown: true,
-            });
-            expect(mockGitHubBridge.getPRFullDetails).toHaveBeenCalledWith('example/repo', 9, expect.any(AbortSignal));
-            expect(result?.newState).toBe(RatchetState.READY);
-            expect(result?.action).not.toEqual({ type: 'WAITING', reason: 'recently_fetched' });
-        });
-        it('reruns a bypassed check once when the first attempt was dedup-skipped', async () => {
-            const workspace = {
-                id: 'ws-rerun',
-                prUrl: 'https://github.com/example/repo/pull/9',
-                prNumber: 9,
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiStatus: CIStatus.UNKNOWN,
-                defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_RUNNING,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
-            vi.mocked(mockGitHubBridge.extractPRInfo).mockReturnValue({
-                owner: 'example',
-                repo: 'repo',
-                number: 9,
-            });
-            fakeCoordinator.inFlightSkips = 1;
-            vi.mocked(mockGitHubBridge.getPRFullDetails).mockResolvedValue({
-                isDraft: false,
-                state: 'OPEN',
-                number: 9,
-                url: 'https://github.com/example/repo/pull/9',
-                reviewDecision: null,
-                mergeStateStatus: 'CLEAN',
-                reviews: [],
-                comments: [],
-                statusCheckRollup: null,
-            });
-            vi.mocked(mockGitHubBridge.getReviewComments).mockResolvedValue([]);
-            vi.mocked(mockGitHubBridge.computeCIStatus).mockReturnValue(CIStatus.SUCCESS);
-            const result = await ratchetService.checkWorkspaceById('ws-rerun', {
-                bypassPrFetchCooldown: true,
-            });
-            expect(mockGitHubBridge.getPRFullDetails).toHaveBeenCalledTimes(1);
-            expect(result?.newState).toBe(RatchetState.READY);
-            expect(result?.action).not.toEqual({ type: 'WAITING', reason: 'recently_fetched' });
-        });
-        it('does not rerun a bypassed check more than once', async () => {
-            const workspace = {
-                id: 'ws-rerun-cap',
-                prUrl: 'https://github.com/example/repo/pull/9',
-                prNumber: 9,
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiStatus: CIStatus.UNKNOWN,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_RUNNING,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
-            vi.mocked(mockGitHubBridge.extractPRInfo).mockReturnValue({
-                owner: 'example',
-                repo: 'repo',
-                number: 9,
-            });
-            fakeCoordinator.inFlightSkips = Number.POSITIVE_INFINITY;
-            const result = await ratchetService.checkWorkspaceById('ws-rerun-cap', {
-                bypassPrFetchCooldown: true,
-            });
-            expect(result?.action).toEqual({ type: 'WAITING', reason: 'recently_fetched' });
-            expect(mockGitHubBridge.coordinatePrFetch).toHaveBeenCalledTimes(2);
-            expect(mockGitHubBridge.getPRFullDetails).not.toHaveBeenCalled();
-        });
-        it('deduplicates concurrent checks for the same workspace', async () => {
-            setRatchetShuttingDown(false);
-            const workspace = {
-                id: 'ws-1',
-                prUrl: 'https://github.com/example/repo/pull/1',
-                prNumber: 1,
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiStatus: CIStatus.UNKNOWN,
-                defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
-            let releaseCheck;
-            const checkBarrier = new Promise((resolve) => {
-                releaseCheck = () => resolve();
-            });
-            const result = {
-                workspaceId: 'ws-1',
-                previousState: RatchetState.IDLE,
-                newState: RatchetState.IDLE,
-                action: { type: 'WAITING', reason: 'noop' },
-            };
-            const processWorkspaceSpy = vi
-                .spyOn(unsafeCoerce(ratchetService), 'processWorkspace')
-                .mockImplementation(async () => {
-                await checkBarrier;
-                return result;
-            });
-            const first = ratchetService.checkWorkspaceById('ws-1');
-            const second = ratchetService.checkWorkspaceById('ws-1');
-            await vi.waitFor(() => expect(processWorkspaceSpy).toHaveBeenCalledTimes(1));
-            expect(processWorkspaceSpy).toHaveBeenCalledTimes(1);
-            releaseCheck();
-            const [firstResult, secondResult] = await Promise.all([first, second]);
-            expect(firstResult).toEqual(result);
-            expect(secondResult).toEqual(result);
-            expect(processWorkspaceSpy).toHaveBeenCalledTimes(1);
-        });
-        it('deduplicates a same-workspace check before it enters the concurrency queue', async () => {
-            const makeWorkspace = (id) => ({
-                id,
-                prUrl: `https://github.com/example/repo/pull/${id}`,
-                prNumber: 1,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-            });
-            const workspaces = [
-                makeWorkspace('blocker-1'),
-                makeWorkspace('blocker-2'),
-                makeWorkspace('blocker-3'),
-                makeWorkspace('queued-target'),
-            ];
-            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue(workspaces);
-            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspaces[3]);
-            let releaseBlockers;
-            const blockerBarrier = new Promise((resolve) => {
-                releaseBlockers = resolve;
-            });
-            let activeBlockers = 0;
-            let targetRuns = 0;
-            vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockImplementation(async (workspace) => {
-                if (workspace.id.startsWith('blocker-')) {
-                    activeBlockers += 1;
-                    await blockerBarrier;
-                }
-                else {
-                    targetRuns += 1;
-                }
-                return {
-                    workspaceId: workspace.id,
-                    previousState: RatchetState.IDLE,
-                    newState: RatchetState.IDLE,
-                    action: { type: 'WAITING', reason: 'noop' },
-                };
-            });
-            const batch = ratchetService.checkAllWorkspaces();
-            await vi.waitFor(() => expect(activeBlockers).toBe(3));
-            const direct = ratchetService.checkWorkspaceById('queued-target');
-            await Promise.resolve();
-            expect(targetRuns).toBe(0);
-            releaseBlockers();
-            const [batchResult, directResult] = await Promise.all([batch, direct]);
-            expect(targetRuns).toBe(1);
-            expect(directResult).toEqual(batchResult.results[3]);
-        });
-        it('keeps a limiter slot occupied until a timed-out runner finishes cleanup', async () => {
-            unsafeCoerce(ratchetService).workspaceCheckTimeoutMs = 5;
-            const makeWorkspace = (id) => ({
-                id,
-                prUrl: `https://github.com/example/repo/pull/${id}`,
-                prNumber: 1,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-            });
-            const workspaces = [
-                makeWorkspace('timed-out-1'),
-                makeWorkspace('timed-out-2'),
-                makeWorkspace('timed-out-3'),
-                makeWorkspace('after-timeouts'),
-            ];
-            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue(workspaces);
-            let finishCleanup;
-            const cleanupBarrier = new Promise((resolve) => {
-                finishCleanup = resolve;
-            });
-            let activeTimedOutChecks = 0;
-            let targetRuns = 0;
-            vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockImplementation(async (workspace, _opts, signal) => {
-                if (workspace.id.startsWith('timed-out-')) {
-                    activeTimedOutChecks += 1;
-                    await new Promise((resolve) => {
-                        signal.addEventListener('abort', () => resolve(), { once: true });
-                    });
-                    await cleanupBarrier;
-                    signal.throwIfAborted();
-                }
-                targetRuns += workspace.id === 'after-timeouts' ? 1 : 0;
-                return {
-                    workspaceId: workspace.id,
-                    previousState: RatchetState.IDLE,
-                    newState: RatchetState.IDLE,
-                    action: { type: 'WAITING', reason: 'noop' },
-                };
-            });
-            const batch = ratchetService.checkAllWorkspaces();
-            await vi.waitFor(() => expect(activeTimedOutChecks).toBe(3));
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(targetRuns).toBe(0);
-            finishCleanup();
-            await batch;
-            expect(targetRuns).toBe(1);
-        });
-        it('runs a direct workspace check without waiting for the batch limiter', async () => {
-            const makeWorkspace = (id) => ({
-                id,
-                prUrl: `https://github.com/example/repo/pull/${id}`,
-                prNumber: 1,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-            });
-            const batchWorkspaces = [
-                makeWorkspace('batch-blocker-1'),
-                makeWorkspace('batch-blocker-2'),
-                makeWorkspace('batch-blocker-3'),
-            ];
-            const directWorkspace = makeWorkspace('direct-target');
-            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue(batchWorkspaces);
-            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(directWorkspace);
-            let releaseBatch;
-            const batchBarrier = new Promise((resolve) => {
-                releaseBatch = resolve;
-            });
-            let activeBatchChecks = 0;
-            let directRuns = 0;
-            vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockImplementation(async (workspace) => {
-                if (workspace.id.startsWith('batch-blocker-')) {
-                    activeBatchChecks += 1;
-                    await batchBarrier;
-                }
-                else {
-                    directRuns += 1;
-                }
-                return {
-                    workspaceId: workspace.id,
-                    previousState: RatchetState.IDLE,
-                    newState: RatchetState.IDLE,
-                    action: { type: 'WAITING', reason: 'noop' },
-                };
-            });
-            const batch = ratchetService.checkAllWorkspaces();
-            await vi.waitFor(() => expect(activeBatchChecks).toBe(3));
-            const directResult = await ratchetService.checkWorkspaceById(directWorkspace.id);
-            expect(directRuns).toBe(1);
-            expect(directResult?.workspaceId).toBe(directWorkspace.id);
-            releaseBatch();
-            await batch;
-        });
-    });
-    describe('decideRatchetAction edge cases', () => {
-        const callDecide = (context) => unsafeCoerce(ratchetService).decideRatchetAction(context);
-        const arrangeOtherWorkingSession = () => {
-            vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
-                { id: 'other-session' },
-            ]);
-            vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(true);
-        };
-        it('returns COMPLETED for merged PR', async () => {
-            expect(await callDecide({
-                workspace: { id: 'ws-decide', ratchetEnabled: true },
-                prStateInfo: { prState: 'MERGED', ciStatus: CIStatus.SUCCESS },
-                isCleanPrWithNoNewReviewActivity: false,
-                activeFixerCheck: { kind: 'none' },
-                dispatchOutcome: null,
-                dispatchRetryCount: 0,
-                hasStateChangedSinceLastDispatch: true,
-            })).toEqual({ type: 'RETURN_ACTION', action: { type: 'COMPLETED' } });
-        });
-        it('returns WAITING for non-open PR', async () => {
-            const result = (await callDecide({
-                workspace: { id: 'ws-decide', ratchetEnabled: true },
-                prStateInfo: { prState: 'CLOSED', ciStatus: CIStatus.SUCCESS },
-                isCleanPrWithNoNewReviewActivity: false,
-                activeFixerCheck: { kind: 'none' },
-                dispatchOutcome: null,
-                dispatchRetryCount: 0,
-                hasStateChangedSinceLastDispatch: true,
-            }));
-            expect(result.action?.reason).toBe('PR is not open');
-        });
-        it('returns active session when one exists', async () => {
-            const activeSession = { type: 'FIXER_ACTIVE', sessionId: 's-1' };
-            const result = (await callDecide({
-                workspace: { id: 'ws-decide', ratchetEnabled: true },
-                prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.FAILURE },
-                isCleanPrWithNoNewReviewActivity: false,
-                activeFixerCheck: { kind: 'active', action: activeSession },
-                dispatchOutcome: 'RUNNING',
-                dispatchRetryCount: 0,
-                hasStateChangedSinceLastDispatch: true,
-            }));
-            expect(result.action).toEqual(activeSession);
-        });
-        it('returns WAITING when other active session blocks dispatch', async () => {
-            arrangeOtherWorkingSession();
-            const result = (await callDecide({
-                workspace: { id: 'ws-decide', ratchetEnabled: true },
-                prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.FAILURE },
-                isCleanPrWithNoNewReviewActivity: false,
-                activeFixerCheck: { kind: 'none' },
-                dispatchOutcome: null,
-                dispatchRetryCount: 0,
-                hasStateChangedSinceLastDispatch: true,
-            }));
-            expect(result.action?.reason).toBe('Workspace has another working session');
-        });
-        it('returns WAITING when there are no CI failures or PR review comments', async () => {
-            const result = (await callDecide({
-                workspace: { id: 'ws-decide', ratchetEnabled: true },
-                prStateInfo: {
-                    prState: 'OPEN',
-                    ciStatus: CIStatus.SUCCESS,
-                    reviewComments: [],
-                },
-                isCleanPrWithNoNewReviewActivity: false,
-                activeFixerCheck: { kind: 'none' },
-                dispatchOutcome: null,
-                dispatchRetryCount: 0,
-                hasStateChangedSinceLastDispatch: true,
-            }));
-            expect(result.action?.reason).toBe('No CI failures or PR review comments to address');
-        });
-        it('waits when the fixer ended concurrently during the check', async () => {
-            const result = (await callDecide({
-                workspace: { id: 'ws-decide', ratchetEnabled: true },
-                prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.FAILURE },
-                isCleanPrWithNoNewReviewActivity: false,
-                activeFixerCheck: { kind: 'ended_concurrently' },
-                dispatchOutcome: 'COMPLETED',
-                dispatchRetryCount: 0,
-                hasStateChangedSinceLastDispatch: false,
-            }));
-            expect(result.action?.reason).toBe('Fixer session ended during this check; re-evaluating next cycle');
-        });
-        it('retries a died fixer ahead of the unchanged-state gate', async () => {
-            const result = await callDecide({
-                workspace: { id: 'ws-decide', ratchetEnabled: true },
-                prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.FAILURE },
-                isCleanPrWithNoNewReviewActivity: false,
-                activeFixerCheck: { kind: 'settled', outcome: 'DIED' },
-                dispatchOutcome: 'DIED',
-                dispatchRetryCount: 2,
-                hasStateChangedSinceLastDispatch: false,
-            });
-            expect(result).toEqual({ type: 'TRIGGER_FIXER', retryCount: 3 });
-        });
-        it('does not retry a died fixer while another session is working', async () => {
-            arrangeOtherWorkingSession();
-            const result = (await callDecide({
-                workspace: { id: 'ws-decide', ratchetEnabled: true },
-                prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.FAILURE },
-                isCleanPrWithNoNewReviewActivity: false,
-                activeFixerCheck: { kind: 'settled', outcome: 'DIED' },
-                dispatchOutcome: 'DIED',
-                dispatchRetryCount: 0,
-                hasStateChangedSinceLastDispatch: false,
-            }));
-            expect(result.action?.reason).toBe('Workspace has another working session');
-        });
-        it('gives up on a died fixer once the retry budget is spent', async () => {
-            const result = (await callDecide({
-                workspace: { id: 'ws-decide', ratchetEnabled: true },
-                prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.FAILURE },
-                isCleanPrWithNoNewReviewActivity: false,
-                activeFixerCheck: { kind: 'none' },
-                dispatchOutcome: 'DIED',
-                dispatchRetryCount: 3,
-                hasStateChangedSinceLastDispatch: false,
-            }));
-            expect(result.action?.reason).toBe('Fixer died 4 times for this PR state; waiting for PR state to change');
-        });
-    });
-    describe('checkActiveFixerSession edge cases', () => {
-        const callCheckActiveFixerSession = (workspace) => unsafeCoerce(ratchetService).checkActiveFixerSession(workspace);
-        it('returns none when ratchetActiveSessionId is null', async () => {
-            const result = await callCheckActiveFixerSession({
-                id: 'ws-1',
-                ratchetActiveSessionId: null,
-            });
-            expect(result).toEqual({ kind: 'none' });
-        });
-        it('settles a non-RUNNING session as COMPLETED when its status is not FAILED', async () => {
-            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
-                id: 'completed-session',
-                provider: 'CLAUDE',
-                status: SessionStatus.IDLE,
-            });
-            const result = await callCheckActiveFixerSession({
-                id: 'ws-3',
-                ratchetActiveSessionId: 'completed-session',
-            });
-            expect(result).toEqual({ kind: 'settled', outcome: 'COMPLETED' });
-            expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith('ws-3', 'completed-session', 'COMPLETED');
-        });
-        it('settles a FAILED session as DIED', async () => {
-            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
-                id: 'failed-session',
-                provider: 'CLAUDE',
-                status: SessionStatus.FAILED,
-            });
-            const result = await callCheckActiveFixerSession({
-                id: 'ws-4',
-                ratchetActiveSessionId: 'failed-session',
-            });
-            expect(result).toEqual({ kind: 'settled', outcome: 'DIED' });
-            expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith('ws-4', 'failed-session', 'DIED');
-        });
-        it('waits for provider-mismatch cleanup before returning a successful settlement', async () => {
-            let finishStop;
-            const pendingStop = new Promise((resolve) => {
-                finishStop = resolve;
-            });
-            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
-                id: 'codex-session',
-                provider: 'CODEX',
-                status: SessionStatus.RUNNING,
-            });
-            vi.mocked(mockSessionBridge.stopSession).mockReturnValue(pendingStop);
-            const check = callCheckActiveFixerSession({
-                id: 'ws-5',
-                ratchetActiveSessionId: 'codex-session',
-                defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-            });
-            await vi.waitFor(() => expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('codex-session'));
-            await expect(Promise.race([check, Promise.resolve({ kind: 'cleanup_pending' })])).resolves.toEqual({ kind: 'cleanup_pending' });
-            expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith('ws-5', 'codex-session', 'DIED');
-            finishStop();
-            await expect(check).resolves.toEqual({ kind: 'settled', outcome: 'DIED' });
-        });
-        it('returns cancellation without waiting for provider-mismatch cleanup', async () => {
-            const controller = new AbortController();
-            const timeoutError = new Error('Workspace check timed out');
-            let finishStop;
-            const pendingStop = new Promise((resolve) => {
-                finishStop = resolve;
-            });
-            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
-                id: 'codex-session',
-                provider: 'CODEX',
-                status: SessionStatus.RUNNING,
-            });
-            vi.mocked(mockSessionBridge.stopSession).mockReturnValue(pendingStop);
-            vi.mocked(mockWorkspaceBridge.recordSessionEnd).mockImplementation(() => {
-                controller.abort(timeoutError);
-                return Promise.resolve(true);
-            });
-            const check = unsafeCoerce(ratchetService).checkActiveFixerSession({
-                id: 'ws-provider-mismatch-cancelled-after-settlement',
-                ratchetActiveSessionId: 'codex-session',
-                defaultSessionProvider: 'WORKSPACE_DEFAULT',
-                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
-            }, controller.signal);
-            const outcome = check.then((value) => ({ status: 'resolved', value }), (error) => ({ status: 'rejected', error }));
-            await vi.waitFor(() => expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('codex-session'));
-            await expect(Promise.race([outcome, Promise.resolve({ status: 'pending' })])).resolves.toEqual({ status: 'rejected', error: timeoutError });
-            expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith('ws-provider-mismatch-cancelled-after-settlement', 'codex-session', 'DIED');
-            finishStop();
-            await pendingStop;
-        });
-        it('stops completed session even when abort fires after settlement', async () => {
-            const controller = new AbortController();
-            const timeoutError = new Error('Workspace check timed out');
-            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
-                id: 'completed-session',
-                provider: 'CLAUDE',
-                status: SessionStatus.RUNNING,
-            });
-            vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-            vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(false);
-            vi.mocked(mockSessionBridge.stopSession).mockResolvedValue();
-            vi.mocked(mockWorkspaceBridge.recordSessionEnd).mockImplementation(() => {
-                controller.abort(timeoutError);
-                return Promise.resolve(true);
-            });
-            const check = unsafeCoerce(ratchetService).checkActiveFixerSession({
-                id: 'ws-completed-aborted-after-settlement',
-                ratchetActiveSessionId: 'completed-session',
-                defaultSessionProvider: 'CLAUDE',
-                ratchetSessionProvider: 'CLAUDE',
-            }, controller.signal);
-            await expect(check).rejects.toBe(timeoutError);
-            expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('completed-session');
-        });
-        it('returns the active fixer when the session is working', async () => {
-            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
-                id: 'working-session',
-                provider: 'CLAUDE',
-                status: SessionStatus.RUNNING,
-            });
-            vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-            vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(true);
-            const result = await callCheckActiveFixerSession({
-                id: 'ws-6',
-                ratchetActiveSessionId: 'working-session',
-            });
-            expect(result).toEqual({
-                kind: 'active',
-                action: { type: 'FIXER_ACTIVE', sessionId: 'working-session' },
-            });
-            expect(mockWorkspaceBridge.recordSessionEnd).not.toHaveBeenCalled();
-        });
-        it('does not settle or stop a fixer after cancellation during session lookup', async () => {
-            const controller = new AbortController();
-            const timeoutError = new Error('Workspace check timed out');
-            let finishLookup;
-            vi.mocked(mockSessionBridge.findSessionById).mockImplementation(() => new Promise((resolve) => {
-                finishLookup = resolve;
-            }));
-            const check = unsafeCoerce(ratchetService).checkActiveFixerSession({
-                id: 'ws-cancelled-active-check',
-                ratchetActiveSessionId: 'session-1',
-            }, controller.signal);
-            await vi.waitFor(() => expect(mockSessionBridge.findSessionById).toHaveBeenCalled());
-            controller.abort(timeoutError);
-            finishLookup(null);
-            await expect(check).rejects.toBe(timeoutError);
-            expect(mockWorkspaceBridge.recordSessionEnd).not.toHaveBeenCalled();
-            expect(mockSessionBridge.stopSession).not.toHaveBeenCalled();
-        });
-        it('publishes a successful fallback settlement before observing post-write cancellation', async () => {
-            const controller = new AbortController();
-            const timeoutError = new Error('Workspace check timed out');
-            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue(null);
-            vi.mocked(mockWorkspaceBridge.recordSessionEnd).mockImplementation(() => {
-                controller.abort(timeoutError);
-                return Promise.resolve(true);
-            });
-            const events = [];
-            ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-                events.push(event);
-            });
-            const check = unsafeCoerce(ratchetService).checkActiveFixerSession({
-                id: 'ws-cancelled-after-settlement',
-                ratchetActiveSessionId: 'session-1',
-                ratchetDispatchRetryCount: 2,
-            }, controller.signal);
-            await expect(check).rejects.toBe(timeoutError);
-            expect(events).toEqual([{ workspaceId: 'ws-cancelled-after-settlement' }]);
-        });
-    });
-    describe('triggerFixer error handling', () => {
-        it('commits the workspace check as soon as the fixer session starts', async () => {
-            const commitSideEffects = vi.fn();
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockImplementation(async (input) => {
-                await input.afterStart?.({ sessionId: 'started-session', prompt: 'prompt' });
-                return {
-                    status: 'started',
-                    sessionId: 'started-session',
-                    promptSent: true,
-                };
-            });
-            const result = await unsafeCoerce(ratchetService).triggerFixer({
-                id: 'ws-started-dispatch',
-                prUrl: 'https://github.com/example/repo/pull/20',
-            }, {
-                ciStatus: CIStatus.FAILURE,
-                snapshotKey: 'failed:20',
-                prNumber: 20,
-                reviewComments: [],
-                hasMergeConflict: false,
-            }, 0, new AbortController().signal, commitSideEffects);
-            expect(result).toMatchObject({
-                type: 'TRIGGERED_FIXER',
-                sessionId: 'started-session',
-            });
-            expect(commitSideEffects).toHaveBeenCalledTimes(2);
-        });
-        it('cleans up a fixer when cancellation races with session startup', async () => {
-            const controller = new AbortController();
-            const timeoutError = new Error('Workspace check timed out');
-            const commitSideEffects = vi.fn();
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockImplementation(async (input) => {
-                controller.abort(timeoutError);
-                try {
-                    await input.afterStart?.({ sessionId: 'cancelled-startup-session', prompt: 'prompt' });
-                    return {
-                        status: 'started',
-                        sessionId: 'cancelled-startup-session',
-                        promptSent: true,
-                    };
-                }
-                catch (error) {
-                    return {
-                        status: 'error',
-                        error: error instanceof Error ? error.message : String(error),
-                    };
-                }
-            });
-            vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-            const trigger = unsafeCoerce(ratchetService).triggerFixer({
-                id: 'ws-cancelled-startup',
-                prUrl: 'https://github.com/example/repo/pull/20',
-            }, {
-                ciStatus: CIStatus.FAILURE,
-                snapshotKey: 'failed:20',
-                prNumber: 20,
-                reviewComments: [],
-                hasMergeConflict: false,
-            }, 0, controller.signal, commitSideEffects);
-            await expect(trigger).rejects.toBe(timeoutError);
-            expect(commitSideEffects).toHaveBeenCalledTimes(1);
-            expect(workspaceRatchetService.recordSessionEnd).toHaveBeenCalledWith('ws-cancelled-startup', 'cancelled-startup-session', 'COMPLETED');
-            expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('cancelled-startup-session');
-        });
-        it('does not clean up a fixer after its dispatch record is persisted', async () => {
-            const controller = new AbortController();
-            const timeoutError = new Error('Workspace check timed out');
-            let finishRecord;
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'started',
-                sessionId: 'cancelled-session',
-                promptSent: true,
-            });
-            vi.mocked(workspaceRatchetService.recordDispatchIfEnabled).mockImplementation(() => new Promise((resolve) => {
-                finishRecord = resolve;
-            }));
-            vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-            const commitSideEffects = vi.fn();
-            const events = [];
-            ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-                events.push(event);
-            });
-            const trigger = unsafeCoerce(ratchetService).triggerFixer({
-                id: 'ws-cancelled-dispatch',
-                prUrl: 'https://github.com/example/repo/pull/20',
-            }, {
-                ciStatus: CIStatus.FAILURE,
-                snapshotKey: 'failed:20',
-                prNumber: 20,
-                reviewComments: [],
-                hasMergeConflict: false,
-            }, 0, controller.signal, commitSideEffects);
-            await vi.waitFor(() => expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalled());
-            controller.abort(timeoutError);
-            finishRecord(true);
-            await expect(trigger).rejects.toBe(timeoutError);
-            expect(commitSideEffects).toHaveBeenCalledTimes(1);
-            expect(workspaceRatchetService.recordSessionEnd).not.toHaveBeenCalled();
-            expect(mockSessionBridge.stopSession).not.toHaveBeenCalled();
-            expect(events).toEqual([{ workspaceId: 'ws-cancelled-dispatch' }]);
-        });
-        it('persists and commits a dispatch while prompt completion is pending', async () => {
-            let finishPrompt;
-            const promptCompletion = new Promise((resolve) => {
-                finishPrompt = resolve;
-            });
-            let finishRecord;
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'started',
-                sessionId: 'pending-prompt-session',
-                promptSent: true,
-                promptCompletion,
-            });
-            vi.mocked(workspaceRatchetService.recordDispatchIfEnabled).mockImplementation(() => new Promise((resolve) => {
-                finishRecord = resolve;
-            }));
-            const commitSideEffects = vi.fn();
-            const trigger = unsafeCoerce(ratchetService).triggerFixer({
-                id: 'ws-pending-prompt',
-                prUrl: 'https://github.com/example/repo/pull/20',
-            }, {
-                ciStatus: CIStatus.FAILURE,
-                snapshotKey: 'failed:20',
-                prNumber: 20,
-                reviewComments: [],
-                hasMergeConflict: false,
-            }, 0, new AbortController().signal, commitSideEffects);
-            await vi.waitFor(() => expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalled());
-            expect(commitSideEffects).toHaveBeenCalledTimes(1);
-            finishRecord(true);
-            await expect(trigger).resolves.toMatchObject({ type: 'TRIGGERED_FIXER' });
-            expect(commitSideEffects).toHaveBeenCalledTimes(1);
-            finishPrompt(true);
-            await promptCompletion;
-        });
-        it('settles a persisted dispatch as died when prompt completion fails', async () => {
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'started',
-                sessionId: 'failed-prompt-session',
-                promptSent: true,
-                promptCompletion: Promise.resolve(false),
-            });
-            vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-            const events = [];
-            ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-                events.push(event);
-            });
-            const result = await unsafeCoerce(ratchetService).triggerFixer({
-                id: 'ws-failed-prompt',
-                prUrl: 'https://github.com/example/repo/pull/20',
-            }, {
-                ciStatus: CIStatus.FAILURE,
-                snapshotKey: 'failed:20',
-                prNumber: 20,
-                reviewComments: [],
-                hasMergeConflict: false,
-            }, 0);
-            expect(result).toMatchObject({ type: 'TRIGGERED_FIXER' });
-            await vi.waitFor(() => expect(workspaceRatchetService.recordSessionEnd).toHaveBeenCalledWith('ws-failed-prompt', 'failed-prompt-session', 'DIED'));
-            expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('failed-prompt-session');
-            await vi.waitFor(() => expect(events).toEqual([
-                { workspaceId: 'ws-failed-prompt' },
-                { workspaceId: 'ws-failed-prompt' },
-            ]));
-        });
-        it('does not stop a newer active session when an old prompt completion fails', async () => {
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'started',
-                sessionId: 'stale-prompt-session',
-                promptSent: true,
-                promptCompletion: Promise.resolve(false),
-            });
-            vi.mocked(workspaceRatchetService.recordSessionEnd).mockResolvedValue(false);
-            vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-            const events = [];
-            ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-                events.push(event);
-            });
-            await unsafeCoerce(ratchetService).triggerFixer({
-                id: 'ws-replaced-prompt',
-                prUrl: 'https://github.com/example/repo/pull/20',
-            }, {
-                ciStatus: CIStatus.FAILURE,
-                snapshotKey: 'failed:20',
-                prNumber: 20,
-                reviewComments: [],
-                hasMergeConflict: false,
-            }, 0);
-            await vi.waitFor(() => expect(workspaceRatchetService.recordSessionEnd).toHaveBeenCalled());
-            expect(mockSessionBridge.stopSession).not.toHaveBeenCalled();
-            expect(events).toEqual([{ workspaceId: 'ws-replaced-prompt' }]);
-        });
-        it('cleans up a fixer through prompt failure after its dispatch record is persisted', async () => {
-            const controller = new AbortController();
-            const timeoutError = new Error('Workspace check timed out');
-            let finishRecord;
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'started',
-                sessionId: 'cancelled-session',
-                promptSent: true,
-                promptCompletion: Promise.resolve(false),
-            });
-            vi.mocked(workspaceRatchetService.recordDispatchIfEnabled).mockImplementation(() => new Promise((resolve) => {
-                finishRecord = resolve;
-            }));
-            vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-            const commitSideEffects = vi.fn();
-            const trigger = unsafeCoerce(ratchetService).triggerFixer({
-                id: 'ws-cancelled-dispatch',
-                prUrl: 'https://github.com/example/repo/pull/20',
-            }, {
-                ciStatus: CIStatus.FAILURE,
-                snapshotKey: 'failed:20',
-                prNumber: 20,
-                reviewComments: [],
-                hasMergeConflict: false,
-            }, 0, controller.signal, commitSideEffects);
-            await vi.waitFor(() => expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalled());
-            controller.abort(timeoutError);
-            finishRecord(true);
-            await expect(trigger).rejects.toBe(timeoutError);
-            expect(commitSideEffects).toHaveBeenCalledTimes(1);
-            await vi.waitFor(() => expect(workspaceRatchetService.recordSessionEnd).toHaveBeenCalledWith('ws-cancelled-dispatch', 'cancelled-session', 'DIED'));
-            expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('cancelled-session');
-        });
-        it('cleans up a started fixer when dispatch persistence fails', async () => {
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'started',
-                sessionId: 'unrecorded-session',
-                promptSent: true,
-            });
-            vi.mocked(workspaceRatchetService.recordDispatchIfEnabled).mockRejectedValue(new Error('dispatch record write failed'));
-            vi.mocked(workspaceRatchetService.recordSessionEnd).mockRejectedValue(new Error('dispatch cleanup write failed'));
-            vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-            const commitSideEffects = vi.fn();
-            const result = await unsafeCoerce(ratchetService).triggerFixer({
-                id: 'ws-unrecorded-dispatch',
-                prUrl: 'https://github.com/example/repo/pull/20',
-            }, {
-                ciStatus: CIStatus.FAILURE,
-                snapshotKey: 'failed:20',
-                prNumber: 20,
-                reviewComments: [],
-                hasMergeConflict: false,
-            }, 0, new AbortController().signal, commitSideEffects);
-            expect(result).toMatchObject({ type: 'ERROR', error: 'dispatch record write failed' });
-            expect(commitSideEffects).toHaveBeenCalledTimes(1);
-            expect(workspaceRatchetService.recordSessionEnd).toHaveBeenCalledWith('ws-unrecorded-dispatch', 'unrecorded-session', 'COMPLETED');
-            expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('unrecorded-session');
-        });
-        it('handles acquireAndDispatch throwing an error', async () => {
-            const workspace = {
-                id: 'ws-trigger-fail',
-                prUrl: 'https://github.com/example/repo/pull/20',
-                prNumber: 20,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockRejectedValue(new Error('Session creation failed'));
-            const result = await unsafeCoerce(ratchetService).triggerFixer(workspace, {
-                ciStatus: CIStatus.FAILURE,
-                prNumber: 20,
-            }, 0);
-            expect(result).toMatchObject({
-                type: 'ERROR',
-                error: 'Session creation failed',
-            });
-        });
-        it('handles already_active result from acquireAndDispatch', async () => {
-            const workspace = {
-                id: 'ws-already-active',
-                prUrl: 'https://github.com/example/repo/pull/21',
-                prNumber: 21,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 2,
-            };
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'already_active',
-                sessionId: 'existing-session',
-            });
-            const events = [];
-            ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
-                events.push(event);
-            });
-            const result = await unsafeCoerce(ratchetService).triggerFixer(workspace, {
-                ciStatus: CIStatus.FAILURE,
-                prNumber: 21,
-            }, 0);
-            expect(result).toMatchObject({
-                type: 'FIXER_ACTIVE',
-                sessionId: 'existing-session',
-            });
-            expect(workspaceRatchetService.adoptActiveSessionIfEnabled).toHaveBeenCalledWith('ws-already-active', 'existing-session');
-            expect(workspaceRatchetService.recordDispatchIfEnabled).not.toHaveBeenCalled();
-            expect(events).toEqual([{ workspaceId: 'ws-already-active' }]);
-        });
-        it('stops already-active fixer when active-session recording loses disable race', async () => {
-            const workspace = {
-                id: 'ws-already-active-disabled',
-                prUrl: 'https://github.com/example/repo/pull/24',
-                prNumber: 24,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'already_active',
-                sessionId: 'existing-session',
-            });
-            vi.mocked(workspaceRatchetService.adoptActiveSessionIfEnabled).mockResolvedValue(false);
-            vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
-            const result = await unsafeCoerce(ratchetService).triggerFixer(workspace, {
-                ciStatus: CIStatus.FAILURE,
-                prNumber: 24,
-            }, 0);
-            expect(result).toMatchObject({
-                type: 'DISABLED',
-                reason: 'Workspace ratcheting disabled',
-            });
-            expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('existing-session');
-        });
-        it('handles skipped result from acquireAndDispatch', async () => {
-            const workspace = {
-                id: 'ws-skipped',
-                prUrl: 'https://github.com/example/repo/pull/22',
-                prNumber: 22,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'skipped',
-                reason: 'No worktree path',
-            });
-            const result = await unsafeCoerce(ratchetService).triggerFixer(workspace, {
-                ciStatus: CIStatus.FAILURE,
-                prNumber: 22,
-            }, 0);
-            expect(result).toMatchObject({
-                type: 'ERROR',
-                error: 'No worktree path',
-            });
-        });
-    });
-    describe('workspace ratchet toggle events', () => {
-        afterEach(() => {
-            ratchetService.removeAllListeners();
-        });
-        it('emits ratchet_toggled when enabling workspace ratcheting', async () => {
-            vi.mocked(workspaceDataService.findById).mockResolvedValue({
-                id: 'ws-enable',
-                ratchetState: RatchetState.CI_FAILED,
-                ratchetActiveSessionId: null,
-                ratchetDispatchOutcome: 'DIED',
-                ratchetDispatchRetryCount: 2,
-            });
-            const toggledEvents = [];
-            const stateEvents = [];
-            ratchetService.on(RATCHET_TOGGLED, (event) => {
-                toggledEvents.push(event);
-            });
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                stateEvents.push(event);
-            });
-            await ratchetService.setWorkspaceRatcheting('ws-enable', true);
-            expect(workspaceRatchetService.enable).toHaveBeenCalledWith('ws-enable');
-            expect(toggledEvents).toEqual([
-                {
-                    workspaceId: 'ws-enable',
-                    enabled: true,
-                    ratchetState: RatchetState.CI_FAILED,
-                },
-            ]);
-            expect(stateEvents).toHaveLength(0);
-        });
-        it('emits ratchet_toggled and ratchet_state_changed when disabling non-idle workspace', async () => {
-            vi.mocked(workspaceDataService.findById).mockResolvedValue({
-                id: 'ws-disable',
-                ratchetState: RatchetState.CI_RUNNING,
-                ratchetActiveSessionId: null,
-            });
-            const toggledEvents = [];
-            const stateEvents = [];
-            ratchetService.on(RATCHET_TOGGLED, (event) => {
-                toggledEvents.push(event);
-            });
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                stateEvents.push(event);
-            });
-            await ratchetService.setWorkspaceRatcheting('ws-disable', false);
-            expect(workspaceRatchetService.disable).toHaveBeenCalledWith('ws-disable');
-            expect(stateEvents).toEqual([
-                {
-                    workspaceId: 'ws-disable',
-                    fromState: RatchetState.CI_RUNNING,
-                    toState: RatchetState.IDLE,
-                },
-            ]);
-            expect(toggledEvents).toEqual([
-                {
-                    workspaceId: 'ws-disable',
-                    enabled: false,
-                    ratchetState: RatchetState.IDLE,
-                },
-            ]);
-        });
-        it('stops ratchet workflow sessions found after disabling workspace', async () => {
-            vi.mocked(workspaceDataService.findById).mockResolvedValue({
-                id: 'ws-disable-raced-session',
-                ratchetState: RatchetState.CI_RUNNING,
-                ratchetActiveSessionId: null,
-            });
-            vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
-                {
-                    id: 'raced-ratchet-session',
-                    workflow: 'ratchet',
-                    status: SessionStatus.RUNNING,
-                },
-                {
-                    id: 'manual-session',
-                    workflow: 'default',
-                    status: SessionStatus.RUNNING,
-                },
-            ]);
-            vi.mocked(mockSessionBridge.isSessionRunning).mockImplementation((sessionId) => sessionId === 'raced-ratchet-session');
-            await ratchetService.setWorkspaceRatcheting('ws-disable-raced-session', false);
-            expect(mockSessionBridge.findSessionsByWorkspaceId).toHaveBeenCalledWith('ws-disable-raced-session');
-            expect(mockSessionBridge.stopSession).toHaveBeenCalledTimes(1);
-            expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('raced-ratchet-session');
-        });
-    });
-    describe('event emission', () => {
-        afterEach(() => {
-            ratchetService.removeAllListeners();
-        });
-        it('never emits from a check on a disabled workspace', async () => {
-            const workspace = {
-                id: 'ws-disabled-idle',
-                prUrl: 'https://github.com/example/repo/pull/31',
-                prNumber: 31,
-                ratchetEnabled: false,
-                ratchetState: RatchetState.IDLE,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            const events = [];
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                events.push(event);
-            });
-            await unsafeCoerce(ratchetService).processWorkspace(workspace);
-            expect(events).toHaveLength(0);
-        });
-        it('emits ratchet_state_changed on main path when state changes', async () => {
-            const workspace = {
-                id: 'ws-state-change',
-                prUrl: 'https://github.com/example/repo/pull/32',
-                prNumber: 32,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-                ciStatus: CIStatus.FAILURE,
-                snapshotKey: 'new-snapshot-key',
-                hasChangesRequested: false,
-                latestReviewActivityAtMs: null,
-                statusCheckRollup: null,
-                prState: 'OPEN',
-                prNumber: 32,
-            });
-            vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'started',
-                sessionId: 'ratchet-session-32',
-                promptSent: true,
-            });
-            const events = [];
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                events.push(event);
-            });
-            await unsafeCoerce(ratchetService).processWorkspace(workspace);
-            expect(events).toHaveLength(1);
-            expect(events[0]).toEqual({
-                workspaceId: 'ws-state-change',
-                fromState: RatchetState.IDLE,
-                toState: RatchetState.CI_FAILED,
-                prCiStatus: CIStatus.FAILURE,
-            });
-        });
-        it('does NOT emit when main path state unchanged', async () => {
-            const workspace = {
-                id: 'ws-no-change',
-                prUrl: 'https://github.com/example/repo/pull/33',
-                prNumber: 33,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
-                ciStatus: CIStatus.FAILURE,
-                snapshotKey: 'new-snapshot-key',
-                hasChangesRequested: false,
-                latestReviewActivityAtMs: null,
-                statusCheckRollup: null,
-                prState: 'OPEN',
-                prNumber: 33,
-            });
-            vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
-                status: 'started',
-                sessionId: 'ratchet-session-33',
-                promptSent: true,
-            });
-            const events = [];
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                events.push(event);
-            });
-            await unsafeCoerce(ratchetService).processWorkspace(workspace);
-            expect(events).toHaveLength(0);
-        });
-        it('does NOT emit on error path', async () => {
-            const workspace = {
-                id: 'ws-error',
-                prUrl: 'https://github.com/example/repo/pull/34',
-                prNumber: 34,
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-                ratchetActiveSessionId: null,
-                ratchetDispatchSnapshotKey: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue(null);
-            const events = [];
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                events.push(event);
-            });
-            const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-            expect(result).toMatchObject({
-                action: { type: 'ERROR' },
-            });
-            expect(events).toHaveLength(0);
-        });
-    });
-});
-//# sourceMappingURL=ratchet.service.test.js.map