factory-factory 0.4.0 → 0.4.2

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

@@ -3,26 +3,29 @@ import { SERVICE_TIMEOUT_MS } from '../../../../backend/services/constants.js';
 import { CIStatus, RatchetState, SessionStatus } from '../../../../shared/core/index.js';
 import { unsafeCoerce } from '../../../../test-utils/unsafe-coerce.js';
 vi.mock('@/backend/services/workspace', () => ({
-    workspaceAccessor: {
+    workspaceDataService: {
         findById: vi.fn(),
-        findWithPRsForRatchet: vi.fn(),
-        findForRatchetById: vi.fn(),
-        update: vi.fn(),
-        transitionRatchetStateIfEnabled: vi.fn(),
-        settleRatchetIdleWhileDisabled: vi.fn(),
-        recordRatchetDispatchIfEnabled: vi.fn(),
-        adoptRatchetActiveSessionIfEnabled: vi.fn(),
-        recordRatchetSessionEnd: 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', () => ({
-    agentSessionAccessor: {
-        findById: vi.fn(),
-        findByWorkspaceId: vi.fn(),
+    sessionDataService: {
+        findAgentSessionById: vi.fn(),
+        findAgentSessionsByWorkspaceId: vi.fn(),
     },
 }));
 vi.mock('@/backend/services/settings', () => ({
-    userSettingsAccessor: {
+    userSettingsService: {
         get: vi.fn(),
         getDefaultSessionProvider: vi.fn(),
     },
@@ -40,15 +43,16 @@ vi.mock('@/backend/services/logger.service', () => ({
         error: vi.fn(),
     }),
 }));
-import { agentSessionAccessor } from '../../../../backend/services/session/index.js';
-import { userSettingsAccessor } from '../../../../backend/services/settings/index.js';
-import { workspaceAccessor } from '../../../../backend/services/workspace/index.js';
+import { userSettingsService } from '../../../../backend/services/settings/index.js';
+import { workspaceDataService, workspaceRatchetService } from '../../../../backend/services/workspace/index.js';
 import { fixerSessionService } from './fixer-session.service.js';
-import { RATCHET_STATE_CHANGED, RATCHET_TOGGLED, ratchetService, } from './ratchet.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(),
@@ -57,47 +61,70 @@ const mockSessionBridge = {
     sendSessionMessage: vi.fn(),
     injectCommittedUserMessage: vi.fn(),
 };
+const mockWorkspaceBridge = {
+    findFixerContext: vi.fn(),
+    recordSessionEnd: vi.fn(),
+};
+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(),
-    isRecentlyFetched: vi.fn(),
-    isFetchInFlight: vi.fn(),
-    startFetch: vi.fn(),
-    registerFetch: vi.fn(),
-    cancelFetch: 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 = {
-    recordCIObservation: vi.fn(),
+    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();
-        unsafeCoerce(ratchetService).isShuttingDown = false;
+        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(workspaceAccessor.transitionRatchetStateIfEnabled).mockResolvedValue(true);
-        vi.mocked(workspaceAccessor.settleRatchetIdleWhileDisabled).mockResolvedValue(true);
-        vi.mocked(workspaceAccessor.recordRatchetDispatchIfEnabled).mockResolvedValue(true);
-        vi.mocked(workspaceAccessor.adoptRatchetActiveSessionIfEnabled).mockResolvedValue(true);
-        vi.mocked(workspaceAccessor.recordRatchetSessionEnd).mockResolvedValue(true);
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        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(userSettingsAccessor.get).mockResolvedValue({
+        vi.mocked(userSettingsService.get).mockResolvedValue({
             id: 'settings-1',
             userId: 'default',
             preferredIde: 'cursor',
@@ -108,6 +135,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             cachedSlashCommands: null,
             ratchetEnabled: false,
             ratchetReplyToPrComments: true,
+            ratchetReviewTriggerMode: 'CHANGES_REQUESTED',
             defaultSessionProvider: 'CLAUDE',
             defaultClaudeModel: 'sonnet',
             defaultCodexModel: 'default',
@@ -118,25 +146,33 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             createdAt: new Date('2026-01-01T00:00:00.000Z'),
             updatedAt: new Date('2026-01-01T00:00:00.000Z'),
         });
-        vi.mocked(userSettingsAccessor.getDefaultSessionProvider).mockResolvedValue('CLAUDE');
+        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(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue([
+        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,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -157,17 +193,18 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: null,
+            ratchetDispatchSnapshotKey: null,
             prReviewLastCheckedAt: null,
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
         };
         const fetchPRStateSpy = vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState');
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
         const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
         const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
         expect(fetchPRStateSpy).not.toHaveBeenCalled();
@@ -176,70 +213,37 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             action: { type: 'DISABLED', reason: 'Workspace ratcheting disabled' },
             newState: RatchetState.IDLE,
         });
-        expect(workspaceAccessor.settleRatchetIdleWhileDisabled).toHaveBeenCalledWith('ws-disabled', RatchetState.IDLE);
+        expect(workspaceRatchetService.recordCheckIfEnabled).not.toHaveBeenCalled();
     });
-    it('settles a disabled workspace to IDLE via CAS and emits an accurate fromState', async () => {
+    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.CI_FAILED,
+            ratchetState: RatchetState.IDLE,
             ratchetActiveSessionId: null,
-            ratchetLastCiRunId: null,
+            ratchetDispatchSnapshotKey: null,
             prReviewLastCheckedAt: null,
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
         };
-        vi.mocked(workspaceAccessor.settleRatchetIdleWhileDisabled).mockResolvedValue(true);
         const events = [];
         ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
             events.push(event);
         });
         const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(workspaceAccessor.settleRatchetIdleWhileDisabled).toHaveBeenCalledWith('ws-disabled-settle', RatchetState.CI_FAILED);
         expect(result).toMatchObject({
-            previousState: RatchetState.CI_FAILED,
+            previousState: RatchetState.IDLE,
             newState: RatchetState.IDLE,
             action: { type: 'DISABLED' },
         });
-        expect(events).toEqual([
-            {
-                workspaceId: 'ws-disabled-settle',
-                fromState: RatchetState.CI_FAILED,
-                toState: RatchetState.IDLE,
-            },
-        ]);
-    });
-    it('does not emit for a disabled workspace when the settle CAS loses', async () => {
-        const workspace = {
-            id: 'ws-disabled-settle-race',
-            prUrl: 'https://github.com/example/repo/pull/2',
-            prNumber: 2,
-            prState: 'OPEN',
-            prCiStatus: CIStatus.UNKNOWN,
-            ratchetEnabled: false,
-            ratchetState: RatchetState.CI_FAILED,
-            ratchetActiveSessionId: null,
-            ratchetLastCiRunId: null,
-            prReviewLastCheckedAt: null,
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-        };
-        vi.mocked(workspaceAccessor.settleRatchetIdleWhileDisabled).mockResolvedValue(false);
-        const events = [];
-        ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-            events.push(event);
-        });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(result).toMatchObject({
-            previousState: RatchetState.CI_FAILED,
-            newState: RatchetState.CI_FAILED,
-            action: { type: 'DISABLED' },
-        });
         expect(events).toEqual([]);
+        expect(workspaceRatchetService.recordCheckIfEnabled).not.toHaveBeenCalled();
     });
     it('does not dispatch when workspace is not idle', async () => {
         const workspace = {
@@ -247,11 +251,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: null,
+            ratchetDispatchSnapshotKey: null,
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -274,8 +280,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 },
             ],
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
             {
                 id: 'chat-1',
                 workflow: 'default-followup',
@@ -298,11 +303,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: '2026-01-01T00:00:00Z',
+            ratchetDispatchSnapshotKey: '2026-01-01T00:00:00Z',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -316,8 +323,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 4,
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
         vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
             status: 'started',
             sessionId: 'ratchet-session',
@@ -327,16 +333,12 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         expect(result).toMatchObject({
             action: { type: 'TRIGGERED_FIXER' },
         });
-        expect(workspaceAccessor.recordRatchetDispatchIfEnabled).toHaveBeenCalledWith('ws-change', {
+        expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalledWith('ws-change', {
             sessionId: 'ratchet-session',
             snapshotKey: '2026-01-02T00:00:00Z',
             retryCount: 0,
         });
-        const finalUpdatePayload = vi
-            .mocked(workspaceAccessor.transitionRatchetStateIfEnabled)
-            .mock.calls.at(-1)?.[2];
-        expect(finalUpdatePayload).not.toHaveProperty('ratchetLastCiRunId');
-        expect(finalUpdatePayload).not.toHaveProperty('prReviewLastCheckedAt');
+        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 () => {
@@ -345,11 +347,13 @@ describe('ratchet service (state-change + idle 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,
-            ratchetLastCiRunId: 'old-snapshot',
+            ratchetDispatchSnapshotKey: 'old-snapshot',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -363,27 +367,32 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 40,
         });
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
         vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
             status: 'started',
             sessionId: 'raced-session',
             promptSent: true,
         });
-        vi.mocked(workspaceAccessor.recordRatchetDispatchIfEnabled).mockResolvedValue(false);
-        vi.mocked(workspaceAccessor.transitionRatchetStateIfEnabled).mockResolvedValue(false);
-        vi.mocked(workspaceAccessor.findById).mockResolvedValue({
+        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(workspaceAccessor.recordRatchetDispatchIfEnabled).toHaveBeenCalledWith('ws-disable-race-dispatch', { sessionId: 'raced-session', snapshotKey: 'new-snapshot', retryCount: 0 });
+        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 = {
@@ -391,11 +400,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: '2026-01-01T00:00:00Z',
+            ratchetDispatchSnapshotKey: '2026-01-01T00:00:00Z',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -409,8 +420,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 44,
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
             {
                 id: 'chat-idle-1',
                 workflow: 'default-followup',
@@ -437,11 +447,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: '2026-01-02T00:00:00Z',
+            ratchetDispatchSnapshotKey: '2026-01-02T00:00:00Z',
             prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -455,8 +467,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 5,
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
         const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
         expect(result).toMatchObject({
             action: {
@@ -464,7 +475,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 reason: 'PR state unchanged since last ratchet dispatch',
             },
         });
-        expect(agentSessionAccessor.findByWorkspaceId).not.toHaveBeenCalled();
+        expect(mockSessionBridge.findSessionsByWorkspaceId).not.toHaveBeenCalled();
         expect(mockSnapshotBridge.recordReviewCheck).not.toHaveBeenCalled();
     });
     it('does not dispatch repeatedly for unchanged CHANGES_REQUESTED state', async () => {
@@ -473,11 +484,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: 'ci:SUCCESS|changes-requested:1735776000000',
+            ratchetDispatchSnapshotKey: 'ci:SUCCESS|changes-requested:1735776000000',
             prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -500,8 +513,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 },
             ],
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
         const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
         const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
         expect(triggerSpy).not.toHaveBeenCalled();
@@ -511,19 +523,21 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 reason: 'PR state unchanged since last ratchet dispatch',
             },
         });
-        expect(agentSessionAccessor.findByWorkspaceId).not.toHaveBeenCalled();
+        expect(mockSessionBridge.findSessionsByWorkspaceId).not.toHaveBeenCalled();
     });
-    it('does not dispatch for CHANGES_REQUESTED when there are no PR review comments', async () => {
+    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,
-            ratchetLastCiRunId: 'ci:SUCCESS|changes-requested:old',
+            ratchetDispatchSnapshotKey: 'ci:SUCCESS|changes-requested:old',
             prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -538,34 +552,44 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prNumber: 56,
             reviewComments: [],
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        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).not.toHaveBeenCalled();
+        expect(triggerSpy).toHaveBeenCalled();
         expect(result).toMatchObject({
-            action: {
-                type: 'WAITING',
-                reason: 'No CI failures or PR review comments to address',
-            },
+            action: { type: 'TRIGGERED_FIXER' },
         });
     });
-    it('dispatches for PR review summary feedback without changes requested', async () => {
+    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,
-            ratchetLastCiRunId: 'ci:SUCCESS|no-changes-requested:old|merge:clean',
+            ratchetDispatchSnapshotKey: 'ci:SUCCESS|no-changes-requested:old|merge:clean',
             prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
         };
-        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+        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,
@@ -584,8 +608,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 },
             ],
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
         vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
             status: 'started',
             sessionId: 'ratchet-session',
@@ -597,6 +620,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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({
@@ -615,11 +639,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: null,
+            ratchetDispatchSnapshotKey: null,
             prReviewLastCheckedAt: null,
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -642,8 +668,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 },
             ],
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
         vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
             status: 'started',
             sessionId: 'ratchet-session',
@@ -655,9 +680,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         expect(result).toMatchObject({
             action: { type: 'ERROR', error: 'Failed to deliver initial ratchet prompt' },
         });
-        expect(workspaceAccessor.update).toHaveBeenCalledWith(workspace.id, {
-            ratchetActiveSessionId: null,
-        });
+        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 () => {
@@ -669,7 +692,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             sessionId: 'aborted-prompt-session',
             promptSent: false,
         });
-        vi.mocked(workspaceAccessor.update).mockImplementation(() => new Promise((resolve) => {
+        vi.mocked(workspaceRatchetService.clearActiveSession).mockImplementation(() => new Promise((resolve) => {
             finishPointerClear = () => resolve({});
         }));
         vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
@@ -683,13 +706,30 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             reviewComments: [],
             hasMergeConflict: false,
         }, 0, controller.signal);
-        await vi.waitFor(() => expect(workspaceAccessor.update).toHaveBeenCalled());
+        await vi.waitFor(() => expect(workspaceRatchetService.clearActiveSession).toHaveBeenCalled());
         controller.abort(timeoutError);
         finishPointerClear();
         await expect(trigger).rejects.toBe(timeoutError);
-        expect(workspaceAccessor.recordRatchetSessionEnd).toHaveBeenCalledWith('ws-aborted-prompt', 'aborted-prompt-session', 'COMPLETED');
+        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 = {
@@ -697,11 +737,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: '2026-01-01T00:00:00Z',
+            ratchetDispatchSnapshotKey: '2026-01-01T00:00:00Z',
             prReviewLastCheckedAt: recentCheck,
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -715,8 +757,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 8,
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
         const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
         const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
         expect(triggerSpy).not.toHaveBeenCalled();
@@ -727,6 +768,58 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             },
         });
     });
+    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 = {
@@ -734,11 +827,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: 'old-snapshot',
+            ratchetDispatchSnapshotKey: 'old-snapshot',
             prReviewLastCheckedAt: recentCheck,
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -752,12 +847,12 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 41,
         });
-        vi.mocked(workspaceAccessor.transitionRatchetStateIfEnabled).mockResolvedValue(false);
-        vi.mocked(workspaceAccessor.findById).mockResolvedValue({
+        vi.mocked(workspaceRatchetService.recordCheckIfEnabled).mockResolvedValue(false);
+        vi.mocked(workspaceDataService.findById).mockResolvedValue({
             id: 'ws-disable-race-state',
             ratchetEnabled: false,
         });
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
         const events = [];
         ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
             events.push(event);
@@ -770,55 +865,117 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         expect(events).toHaveLength(0);
         ratchetService.removeAllListeners();
     });
-    it('reports a concurrent state change without emitting when the check loses the CAS while still enabled', async () => {
-        const recentCheck = new Date();
+    it('persists PR state and review decision the check observed, not just CI', async () => {
         const workspace = {
-            id: 'ws-superseded',
-            prUrl: 'https://github.com/example/repo/pull/42',
-            prNumber: 42,
+            id: 'ws-observation',
+            prUrl: 'https://github.com/example/repo/pull/44',
+            prNumber: 44,
             prState: 'OPEN',
-            prCiStatus: CIStatus.UNKNOWN,
+            prReviewState: null,
+            prHasMergeConflict: false,
+            prCiStatus: CIStatus.SUCCESS,
             ratchetEnabled: true,
-            ratchetState: RatchetState.CI_RUNNING,
+            ratchetState: RatchetState.READY,
             ratchetActiveSessionId: null,
-            ratchetLastCiRunId: 'old-snapshot',
-            prReviewLastCheckedAt: recentCheck,
+            ratchetDispatchSnapshotKey: 'observation-snapshot',
+            prReviewLastCheckedAt: null,
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
         };
         vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
             ciStatus: CIStatus.SUCCESS,
-            snapshotKey: 'new-snapshot',
-            hasChangesRequested: false,
-            latestReviewActivityAtMs: recentCheck.getTime() - 1000,
+            snapshotKey: 'observation-snapshot',
+            hasChangesRequested: true,
+            hasMergeConflict: false,
+            latestReviewActivityAtMs: null,
             statusCheckRollup: null,
             prState: 'OPEN',
-            prNumber: 42,
+            cachedPrState: 'CHANGES_REQUESTED',
+            reviewDecision: 'CHANGES_REQUESTED',
+            prNumber: 44,
+            reviewComments: [],
         });
-        vi.mocked(workspaceAccessor.transitionRatchetStateIfEnabled).mockResolvedValue(false);
-        vi.mocked(workspaceAccessor.findById).mockResolvedValue({
-            id: 'ws-superseded',
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
+        await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({
+            workspaceId: 'ws-observation',
+            prState: 'CHANGES_REQUESTED',
+            reviewState: 'CHANGES_REQUESTED',
+            ciStatus: CIStatus.SUCCESS,
+            hasMergeConflict: false,
+        }));
+    });
+    it('persists a merge observed by the check even when CI status is unchanged', 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.IDLE,
-        });
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
-        const events = [];
-        ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-            events.push(event);
+            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: [],
         });
-        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(workspaceAccessor.transitionRatchetStateIfEnabled).toHaveBeenCalledWith('ws-superseded', RatchetState.CI_RUNNING, expect.objectContaining({ ratchetState: RatchetState.READY }));
-        expect(result).toMatchObject({
-            previousState: RatchetState.CI_RUNNING,
-            newState: RatchetState.CI_RUNNING,
-            action: {
-                type: 'WAITING',
-                reason: 'Ratchet state changed concurrently during this check; re-evaluating next cycle',
-            },
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
+        await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({ workspaceId: 'ws-merged', prState: 'MERGED' }));
+    });
+    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: [],
         });
-        expect(events).toHaveLength(0);
-        expect(mockSnapshotBridge.recordCIObservation).not.toHaveBeenCalled();
-        expect(mockSnapshotBridge.recordReviewCheck).not.toHaveBeenCalled();
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
+        await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({
+            workspaceId: 'ws-conflict',
+            ciStatus: CIStatus.SUCCESS,
+            hasMergeConflict: true,
+        }));
     });
     it('redispatches with an incremented retry count when the previous fixer died', async () => {
         const workspace = {
@@ -826,11 +983,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: 'same-snapshot',
+            ratchetDispatchSnapshotKey: 'same-snapshot',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'DIED',
             ratchetDispatchRetryCount: 1,
@@ -844,8 +1003,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 13,
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
         vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
             status: 'started',
             sessionId: 'retry-session',
@@ -855,7 +1013,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         expect(result).toMatchObject({
             action: { type: 'TRIGGERED_FIXER' },
         });
-        expect(workspaceAccessor.recordRatchetDispatchIfEnabled).toHaveBeenCalledWith('ws-died-retry', {
+        expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalledWith('ws-died-retry', {
             sessionId: 'retry-session',
             snapshotKey: 'same-snapshot',
             retryCount: 2,
@@ -868,11 +1026,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: 'clean-snapshot',
+            ratchetDispatchSnapshotKey: 'clean-snapshot',
             prReviewLastCheckedAt: checkedAt,
             ratchetDispatchOutcome: 'DIED',
             ratchetDispatchRetryCount: 0,
@@ -887,22 +1047,26 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prNumber: 14,
             reviewComments: [],
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        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(workspaceAccessor.recordRatchetDispatchIfEnabled).toHaveBeenCalledWith('ws-died-clean', {
+        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 = {
@@ -910,11 +1074,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: 'same-snapshot',
+            ratchetDispatchSnapshotKey: 'same-snapshot',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'DIED',
             ratchetDispatchRetryCount: 3,
@@ -928,7 +1094,6 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 15,
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
         const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
         expect(result).toMatchObject({
             action: {
@@ -944,11 +1109,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: 'old-snapshot',
+            ratchetDispatchSnapshotKey: 'old-snapshot',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'DIED',
             ratchetDispatchRetryCount: 3,
@@ -962,8 +1129,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 16,
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
         vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
             status: 'started',
             sessionId: 'fresh-session',
@@ -973,7 +1139,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         expect(result).toMatchObject({
             action: { type: 'TRIGGERED_FIXER' },
         });
-        expect(workspaceAccessor.recordRatchetDispatchIfEnabled).toHaveBeenCalledWith('ws-died-changed', { sessionId: 'fresh-session', snapshotKey: 'new-snapshot', retryCount: 0 });
+        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 = {
@@ -981,11 +1147,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: 'same-snapshot',
+            ratchetDispatchSnapshotKey: 'same-snapshot',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'COMPLETED',
             ratchetDispatchRetryCount: 2,
@@ -999,7 +1167,6 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 17,
         });
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
         const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
         expect(result).toMatchObject({
             action: {
@@ -1009,22 +1176,71 @@ describe('ratchet service (state-change + idle 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',
-            ratchetLastCiRunId: 'previous-snapshot-key',
+            ratchetDispatchSnapshotKey: 'previous-snapshot-key',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'RUNNING',
             ratchetDispatchRetryCount: 0,
         };
-        vi.mocked(agentSessionAccessor.findById).mockResolvedValue({
+        vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
             id: 'ratchet-session',
             provider: 'CLAUDE',
             status: SessionStatus.RUNNING,
@@ -1032,7 +1248,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(false);
         const result = await unsafeCoerce(ratchetService).checkActiveFixerSession(workspace);
         expect(result).toEqual({ kind: 'settled', outcome: 'DIED' });
-        expect(workspaceAccessor.recordRatchetSessionEnd).toHaveBeenCalledWith(workspace.id, 'ratchet-session', '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 = {
@@ -1040,19 +1256,26 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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',
-            ratchetLastCiRunId: 'previous-snapshot-key',
+            ratchetDispatchSnapshotKey: 'previous-snapshot-key',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'RUNNING',
             ratchetDispatchRetryCount: 0,
         };
-        vi.mocked(agentSessionAccessor.findById).mockResolvedValue(null);
+        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(workspaceAccessor.recordRatchetSessionEnd).toHaveBeenCalledWith(workspace.id, 'deleted-session', '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 = {
@@ -1060,19 +1283,26 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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',
-            ratchetLastCiRunId: 'previous-snapshot-key',
+            ratchetDispatchSnapshotKey: 'previous-snapshot-key',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'RUNNING',
             ratchetDispatchRetryCount: 0,
         };
-        vi.mocked(agentSessionAccessor.findById).mockResolvedValue(null);
-        vi.mocked(workspaceAccessor.recordRatchetSessionEnd).mockResolvedValue(false);
+        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 = {
@@ -1080,11 +1310,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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',
-            ratchetLastCiRunId: 'previous-snapshot-key',
+            ratchetDispatchSnapshotKey: 'previous-snapshot-key',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'RUNNING',
             ratchetDispatchRetryCount: 0,
@@ -1098,9 +1330,8 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 12,
         });
-        vi.mocked(agentSessionAccessor.findById).mockResolvedValue(null);
-        vi.mocked(workspaceAccessor.recordRatchetSessionEnd).mockResolvedValue(false);
-        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue(null);
+        vi.mocked(mockWorkspaceBridge.recordSessionEnd).mockResolvedValue(false);
         const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
         expect(result).toMatchObject({
             action: {
@@ -1116,16 +1347,18 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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',
-            ratchetLastCiRunId: 'snapshot-key',
+            ratchetDispatchSnapshotKey: 'snapshot-key',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'RUNNING',
             ratchetDispatchRetryCount: 0,
         };
-        vi.mocked(agentSessionAccessor.findById).mockResolvedValue({
+        vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
             id: 'ratchet-session',
             provider: 'CLAUDE',
             status: SessionStatus.RUNNING,
@@ -1135,7 +1368,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         vi.mocked(mockSessionBridge.stopSession).mockResolvedValue();
         const result = await unsafeCoerce(ratchetService).checkActiveFixerSession(workspace);
         expect(result).toEqual({ kind: 'settled', outcome: 'COMPLETED' });
-        expect(workspaceAccessor.recordRatchetSessionEnd).toHaveBeenCalledWith(workspace.id, 'ratchet-session', '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 () => {
@@ -1186,11 +1419,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: 'prev-snapshot',
+            ratchetDispatchSnapshotKey: 'prev-snapshot',
             prReviewLastCheckedAt: null,
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -1218,11 +1453,19 @@ describe('ratchet service (state-change + idle dispatch)', () => {
     it('ignores review activity authored by the authenticated user', () => {
         const latestActivity = computeLatestReviewActivityAtMs({
             reviews: [
-                { submittedAt: '2026-01-02T00:00:00Z', author: { login: 'ratchet-bot' } },
-                { submittedAt: '2026-01-01T00:00:00Z', author: { login: 'reviewer' } },
+                {
+                    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');
+        }, [{ 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', () => {
@@ -1285,7 +1528,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         });
     });
     describe('computeDispatchSnapshotKey', () => {
-        const callComputeSnapshotKey = (ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks) => computeDispatchSnapshotKey(ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks);
+        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');
@@ -1329,36 +1572,60 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         });
     });
     describe('computeLatestReviewActivityAtMs edge cases', () => {
-        const callCompute = (prDetails, reviewComments, authenticatedUsername) => computeLatestReviewActivityAtMs(prDetails, reviewComments, authenticatedUsername);
+        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' } }],
+                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' } }],
+                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 that have null submittedAt', () => {
+        it('ignores reviews with null submittedAt and ordinary PR comments', () => {
             const result = callCompute({
-                reviews: [{ submittedAt: null, author: { login: 'reviewer' } }],
+                reviews: [
+                    {
+                        submittedAt: null,
+                        author: { login: 'reviewer' },
+                        state: 'CHANGES_REQUESTED',
+                    },
+                ],
                 comments: [{ updatedAt: '2026-01-02T00:00:00Z', author: { login: 'commenter' } }],
             }, [], null);
-            expect(result).toBe(new Date('2026-01-02T00:00:00Z').getTime());
+            expect(result).toBeNull();
         });
         it('returns the latest timestamp across all sources', () => {
             const result = callCompute({
-                reviews: [{ submittedAt: '2026-01-01T00:00:00Z', author: { login: 'a' } }],
+                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-03T00:00:00Z').getTime());
+            expect(result).toBe(new Date('2026-01-02T00:00:00Z').getTime());
         });
     });
     describe('processWorkspace error handling', () => {
@@ -1370,13 +1637,12 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.IDLE,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             };
             vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue(null);
-            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
             const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
             expect(result).toMatchObject({
                 action: { type: 'ERROR', error: 'Failed to fetch PR state' },
@@ -1391,7 +1657,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.IDLE,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -1402,10 +1668,10 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 action: { type: 'WAITING', reason: 'recently_fetched' },
                 newState: RatchetState.IDLE,
             });
-            expect(workspaceAccessor.update).not.toHaveBeenCalled();
+            expect(workspaceRatchetService.clearActiveSession).not.toHaveBeenCalled();
         });
         it('returns WAITING when shutting down', async () => {
-            unsafeCoerce(ratchetService).isShuttingDown = true;
+            setRatchetShuttingDown(true);
             const workspace = {
                 id: 'ws-shutdown',
                 prUrl: 'https://github.com/example/repo/pull/1',
@@ -1413,7 +1679,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.CI_FAILED,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -1433,7 +1699,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.CI_FAILED,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -1449,18 +1715,41 @@ describe('ratchet service (state-change + idle dispatch)', () => {
     });
     describe('checkAllWorkspaces', () => {
         it('returns zero counts when shutting down', async () => {
-            unsafeCoerce(ratchetService).isShuttingDown = true;
+            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(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue([]);
+            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(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue([
+            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue([
                 {
                     id: 'ws-timeout',
                     prUrl: 'https://github.com/example/repo/pull/1',
@@ -1472,7 +1761,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                     ratchetEnabled: true,
                     ratchetState: RatchetState.IDLE,
                     ratchetActiveSessionId: null,
-                    ratchetLastCiRunId: null,
+                    ratchetDispatchSnapshotKey: null,
                     prReviewLastCheckedAt: null,
                     ratchetDispatchOutcome: null,
                     ratchetDispatchRetryCount: 0,
@@ -1488,7 +1777,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                     ratchetEnabled: true,
                     ratchetState: RatchetState.CI_RUNNING,
                     ratchetActiveSessionId: null,
-                    ratchetLastCiRunId: null,
+                    ratchetDispatchSnapshotKey: null,
                     prReviewLastCheckedAt: null,
                     ratchetDispatchOutcome: null,
                     ratchetDispatchRetryCount: 0,
@@ -1530,18 +1819,20 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             }));
-            vi.mocked(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue(workspaces);
+            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') {
@@ -1557,7 +1848,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 });
             });
             const result = await ratchetService.checkAllWorkspaces();
-            expect(processWorkspaceSpy).toHaveBeenCalledWith(expect.objectContaining({ id: 'ws-queued-timeout-3' }), undefined, expect.any(AbortSignal), expect.any(Function));
+            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' },
@@ -1572,7 +1863,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.IDLE,
             };
-            vi.mocked(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue([workspace]);
+            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue([workspace]);
             let finishCommit;
             const commitBarrier = new Promise((resolve) => {
                 finishCommit = resolve;
@@ -1603,18 +1894,20 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             }));
-            vi.mocked(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue(workspaces);
+            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue(workspaces);
             let active = 0;
             let maximumActive = 0;
             let releaseChecks;
@@ -1659,98 +1952,10 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             vi.useRealTimers();
         });
     });
-    describe('markPrClosed', () => {
+    describe('check abort safety', () => {
         afterEach(() => {
             ratchetService.removeAllListeners();
         });
-        it('resets ratchet state to IDLE via CAS on fromState and emits a state change', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue({
-                id: 'ws-closed',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-            });
-            vi.mocked(workspaceAccessor.transitionRatchetStateIfEnabled).mockResolvedValue(true);
-            const stateEvents = [];
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                stateEvents.push(event);
-            });
-            await ratchetService.markPrClosed('ws-closed');
-            expect(workspaceAccessor.transitionRatchetStateIfEnabled).toHaveBeenCalledWith('ws-closed', RatchetState.CI_FAILED, {
-                ratchetState: RatchetState.IDLE,
-                ratchetLastCheckedAt: expect.any(Date),
-            });
-            expect(stateEvents).toEqual([
-                {
-                    workspaceId: 'ws-closed',
-                    fromState: RatchetState.CI_FAILED,
-                    toState: RatchetState.IDLE,
-                },
-            ]);
-        });
-        it('emits the fromState that actually won the compare-and-swap after losing a race', async () => {
-            vi.mocked(workspaceAccessor.findById)
-                .mockResolvedValueOnce({
-                id: 'ws-closed',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-            })
-                .mockResolvedValueOnce({
-                id: 'ws-closed',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_RUNNING,
-            });
-            vi.mocked(workspaceAccessor.transitionRatchetStateIfEnabled)
-                .mockResolvedValueOnce(false)
-                .mockResolvedValueOnce(true);
-            const stateEvents = [];
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                stateEvents.push(event);
-            });
-            await ratchetService.markPrClosed('ws-closed');
-            expect(workspaceAccessor.transitionRatchetStateIfEnabled).toHaveBeenNthCalledWith(1, 'ws-closed', RatchetState.CI_FAILED, expect.objectContaining({ ratchetState: RatchetState.IDLE }));
-            expect(workspaceAccessor.transitionRatchetStateIfEnabled).toHaveBeenNthCalledWith(2, 'ws-closed', RatchetState.CI_RUNNING, expect.objectContaining({ ratchetState: RatchetState.IDLE }));
-            expect(stateEvents).toEqual([
-                {
-                    workspaceId: 'ws-closed',
-                    fromState: RatchetState.CI_RUNNING,
-                    toState: RatchetState.IDLE,
-                },
-            ]);
-        });
-        it('is a no-op when ratchet state is already IDLE', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue({
-                id: 'ws-closed',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-            });
-            await ratchetService.markPrClosed('ws-closed');
-            expect(workspaceAccessor.transitionRatchetStateIfEnabled).not.toHaveBeenCalled();
-        });
-        it('does not emit when ratcheting was disabled concurrently', async () => {
-            vi.mocked(workspaceAccessor.findById)
-                .mockResolvedValueOnce({
-                id: 'ws-closed',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-            })
-                .mockResolvedValueOnce({
-                id: 'ws-closed',
-                ratchetEnabled: false,
-                ratchetState: RatchetState.IDLE,
-            });
-            vi.mocked(workspaceAccessor.transitionRatchetStateIfEnabled).mockResolvedValue(false);
-            const stateEvents = [];
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                stateEvents.push(event);
-            });
-            await ratchetService.markPrClosed('ws-closed');
-            expect(stateEvents).toEqual([]);
-        });
-        it('is a no-op when workspace is not found', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue(null);
-            await ratchetService.markPrClosed('ws-missing');
-            expect(workspaceAccessor.transitionRatchetStateIfEnabled).not.toHaveBeenCalled();
-        });
         it('does not continue to side effects after a timed-out await completes', async () => {
             unsafeCoerce(ratchetService).workspaceCheckTimeoutMs = 5;
             const workspace = {
@@ -1758,18 +1963,20 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             };
-            vi.mocked(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue([workspace]);
+            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue([workspace]);
             let releaseFetch;
             const fetchBarrier = new Promise((resolve) => {
                 releaseFetch = resolve;
@@ -1794,18 +2001,18 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             releaseFetch();
             await new Promise((resolve) => setTimeout(resolve, 0));
             expect(finishSpy).not.toHaveBeenCalled();
-            expect(workspaceAccessor.transitionRatchetStateIfEnabled).not.toHaveBeenCalled();
+            expect(workspaceRatchetService.recordCheckIfEnabled).not.toHaveBeenCalled();
         });
     });
     describe('checkWorkspaceById', () => {
         it('returns null when shutting down', async () => {
-            unsafeCoerce(ratchetService).isShuttingDown = true;
+            setRatchetShuttingDown(true);
             const result = await ratchetService.checkWorkspaceById('ws-1');
             expect(result).toBeNull();
         });
         it('returns null when workspace not found', async () => {
-            unsafeCoerce(ratchetService).isShuttingDown = false;
-            vi.mocked(workspaceAccessor.findForRatchetById).mockResolvedValue(null);
+            setRatchetShuttingDown(false);
+            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(null);
             const result = await ratchetService.checkWorkspaceById('ws-nonexistent');
             expect(result).toBeNull();
         });
@@ -1815,22 +2022,24 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             };
-            vi.mocked(workspaceAccessor.findForRatchetById).mockResolvedValue(workspace);
+            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
             vi.mocked(mockGitHubBridge.extractPRInfo).mockReturnValue({
                 owner: 'example',
                 repo: 'repo',
                 number: 9,
             });
-            vi.mocked(mockGitHubBridge.isRecentlyFetched).mockReturnValue(true);
+            fakeCoordinator.cooldownActive = true;
             const result = await ratchetService.checkWorkspaceById('ws-cooldown');
             expect(result?.action).toEqual({ type: 'WAITING', reason: 'recently_fetched' });
             expect(mockGitHubBridge.getPRFullDetails).not.toHaveBeenCalled();
@@ -1841,25 +2050,28 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             };
-            vi.mocked(workspaceAccessor.findForRatchetById).mockResolvedValue(workspace);
+            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
             vi.mocked(mockGitHubBridge.extractPRInfo).mockReturnValue({
                 owner: 'example',
                 repo: 'repo',
                 number: 9,
             });
-            vi.mocked(mockGitHubBridge.isRecentlyFetched).mockReturnValue(true);
+            fakeCoordinator.cooldownActive = true;
             vi.mocked(mockGitHubBridge.getPRFullDetails).mockResolvedValue({
+                isDraft: false,
                 state: 'OPEN',
                 number: 9,
                 url: 'https://github.com/example/repo/pull/9',
@@ -1884,25 +2096,28 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             };
-            vi.mocked(workspaceAccessor.findForRatchetById).mockResolvedValue(workspace);
+            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
             vi.mocked(mockGitHubBridge.extractPRInfo).mockReturnValue({
                 owner: 'example',
                 repo: 'repo',
                 number: 9,
             });
-            vi.mocked(mockGitHubBridge.isFetchInFlight).mockReturnValueOnce(true).mockReturnValue(false);
+            fakeCoordinator.inFlightSkips = 1;
             vi.mocked(mockGitHubBridge.getPRFullDetails).mockResolvedValue({
+                isDraft: false,
                 state: 'OPEN',
                 number: 9,
                 url: 'https://github.com/example/repo/pull/9',
@@ -1927,48 +2142,52 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             };
-            vi.mocked(workspaceAccessor.findForRatchetById).mockResolvedValue(workspace);
+            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
             vi.mocked(mockGitHubBridge.extractPRInfo).mockReturnValue({
                 owner: 'example',
                 repo: 'repo',
                 number: 9,
             });
-            vi.mocked(mockGitHubBridge.isFetchInFlight).mockReturnValue(true);
+            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.isFetchInFlight).toHaveBeenCalledTimes(2);
+            expect(mockGitHubBridge.coordinatePrFetch).toHaveBeenCalledTimes(2);
             expect(mockGitHubBridge.getPRFullDetails).not.toHaveBeenCalled();
         });
         it('deduplicates concurrent checks for the same workspace', async () => {
-            unsafeCoerce(ratchetService).isShuttingDown = false;
+            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,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             };
-            vi.mocked(workspaceAccessor.findForRatchetById).mockResolvedValue(workspace);
+            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
             let releaseCheck;
             const checkBarrier = new Promise((resolve) => {
                 releaseCheck = () => resolve();
@@ -2009,8 +2228,8 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 makeWorkspace('blocker-3'),
                 makeWorkspace('queued-target'),
             ];
-            vi.mocked(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue(workspaces);
-            vi.mocked(workspaceAccessor.findForRatchetById).mockResolvedValue(workspaces[3]);
+            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue(workspaces);
+            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspaces[3]);
             let releaseBlockers;
             const blockerBarrier = new Promise((resolve) => {
                 releaseBlockers = resolve;
@@ -2057,7 +2276,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 makeWorkspace('timed-out-3'),
                 makeWorkspace('after-timeouts'),
             ];
-            vi.mocked(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue(workspaces);
+            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue(workspaces);
             let finishCleanup;
             const cleanupBarrier = new Promise((resolve) => {
                 finishCleanup = resolve;
@@ -2103,8 +2322,8 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 makeWorkspace('batch-blocker-3'),
             ];
             const directWorkspace = makeWorkspace('direct-target');
-            vi.mocked(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue(batchWorkspaces);
-            vi.mocked(workspaceAccessor.findForRatchetById).mockResolvedValue(directWorkspace);
+            vi.mocked(workspaceRatchetService.findCandidates).mockResolvedValue(batchWorkspaces);
+            vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(directWorkspace);
             let releaseBatch;
             const batchBarrier = new Promise((resolve) => {
                 releaseBatch = resolve;
@@ -2138,7 +2357,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
     describe('decideRatchetAction edge cases', () => {
         const callDecide = (context) => unsafeCoerce(ratchetService).decideRatchetAction(context);
         const arrangeOtherWorkingSession = () => {
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
                 { id: 'other-session' },
             ]);
             vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(true);
@@ -2268,7 +2487,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             expect(result).toEqual({ kind: 'none' });
         });
         it('settles a non-RUNNING session as COMPLETED when its status is not FAILED', async () => {
-            vi.mocked(agentSessionAccessor.findById).mockResolvedValue({
+            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
                 id: 'completed-session',
                 provider: 'CLAUDE',
                 status: SessionStatus.IDLE,
@@ -2278,10 +2497,10 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetActiveSessionId: 'completed-session',
             });
             expect(result).toEqual({ kind: 'settled', outcome: 'COMPLETED' });
-            expect(workspaceAccessor.recordRatchetSessionEnd).toHaveBeenCalledWith('ws-3', 'completed-session', 'COMPLETED');
+            expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith('ws-3', 'completed-session', 'COMPLETED');
         });
         it('settles a FAILED session as DIED', async () => {
-            vi.mocked(agentSessionAccessor.findById).mockResolvedValue({
+            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
                 id: 'failed-session',
                 provider: 'CLAUDE',
                 status: SessionStatus.FAILED,
@@ -2291,27 +2510,63 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetActiveSessionId: 'failed-session',
             });
             expect(result).toEqual({ kind: 'settled', outcome: 'DIED' });
-            expect(workspaceAccessor.recordRatchetSessionEnd).toHaveBeenCalledWith('ws-4', 'failed-session', 'DIED');
+            expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith('ws-4', 'failed-session', 'DIED');
         });
-        it('settles a provider-mismatched session as DIED and stops it', async () => {
-            vi.mocked(agentSessionAccessor.findById).mockResolvedValue({
+        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).mockResolvedValue();
-            const result = await callCheckActiveFixerSession({
+            vi.mocked(mockSessionBridge.stopSession).mockReturnValue(pendingStop);
+            const check = callCheckActiveFixerSession({
                 id: 'ws-5',
                 ratchetActiveSessionId: 'codex-session',
                 defaultSessionProvider: 'WORKSPACE_DEFAULT',
                 ratchetSessionProvider: 'WORKSPACE_DEFAULT',
             });
-            expect(result).toEqual({ kind: 'settled', outcome: 'DIED' });
-            expect(workspaceAccessor.recordRatchetSessionEnd).toHaveBeenCalledWith('ws-5', 'codex-session', 'DIED');
-            expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('codex-session');
+            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('returns the active fixer when the session is working', async () => {
-            vi.mocked(agentSessionAccessor.findById).mockResolvedValue({
+            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
                 id: 'working-session',
                 provider: 'CLAUDE',
                 status: SessionStatus.RUNNING,
@@ -2326,28 +2581,111 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 kind: 'active',
                 action: { type: 'FIXER_ACTIVE', sessionId: 'working-session' },
             });
-            expect(workspaceAccessor.recordRatchetSessionEnd).not.toHaveBeenCalled();
+            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(agentSessionAccessor.findById).mockImplementation(() => new Promise((resolve) => {
+            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(agentSessionAccessor.findById).toHaveBeenCalled());
+            await vi.waitFor(() => expect(mockSessionBridge.findSessionById).toHaveBeenCalled());
             controller.abort(timeoutError);
             finishLookup(null);
             await expect(check).rejects.toBe(timeoutError);
-            expect(workspaceAccessor.recordRatchetSessionEnd).not.toHaveBeenCalled();
+            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');
@@ -2357,11 +2695,15 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 sessionId: 'cancelled-session',
                 promptSent: true,
             });
-            vi.mocked(workspaceAccessor.recordRatchetDispatchIfEnabled).mockImplementation(() => new Promise((resolve) => {
+            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',
@@ -2372,13 +2714,138 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 reviewComments: [],
                 hasMergeConflict: false,
             }, 0, controller.signal, commitSideEffects);
-            await vi.waitFor(() => expect(workspaceAccessor.recordRatchetDispatchIfEnabled).toHaveBeenCalled());
+            await vi.waitFor(() => expect(workspaceRatchetService.recordDispatchIfEnabled).toHaveBeenCalled());
             controller.abort(timeoutError);
             finishRecord(true);
             await expect(trigger).rejects.toBe(timeoutError);
             expect(commitSideEffects).toHaveBeenCalledTimes(1);
-            expect(workspaceAccessor.recordRatchetSessionEnd).not.toHaveBeenCalled();
+            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({
@@ -2386,8 +2853,8 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 sessionId: 'unrecorded-session',
                 promptSent: true,
             });
-            vi.mocked(workspaceAccessor.recordRatchetDispatchIfEnabled).mockRejectedValue(new Error('dispatch record write failed'));
-            vi.mocked(workspaceAccessor.recordRatchetSessionEnd).mockRejectedValue(new Error('dispatch cleanup write failed'));
+            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({
@@ -2402,7 +2869,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             }, 0, new AbortController().signal, commitSideEffects);
             expect(result).toMatchObject({ type: 'ERROR', error: 'dispatch record write failed' });
             expect(commitSideEffects).toHaveBeenCalledTimes(1);
-            expect(workspaceAccessor.recordRatchetSessionEnd).toHaveBeenCalledWith('ws-unrecorded-dispatch', 'unrecorded-session', 'COMPLETED');
+            expect(workspaceRatchetService.recordSessionEnd).toHaveBeenCalledWith('ws-unrecorded-dispatch', 'unrecorded-session', 'COMPLETED');
             expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('unrecorded-session');
         });
         it('handles acquireAndDispatch throwing an error', async () => {
@@ -2413,7 +2880,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.CI_FAILED,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -2436,16 +2903,19 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.CI_FAILED,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
+                ratchetDispatchRetryCount: 2,
             };
             vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
                 status: 'already_active',
                 sessionId: 'existing-session',
             });
-            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            const events = [];
+            ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
+                events.push(event);
+            });
             const result = await unsafeCoerce(ratchetService).triggerFixer(workspace, {
                 ciStatus: CIStatus.FAILURE,
                 prNumber: 21,
@@ -2454,8 +2924,9 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 type: 'FIXER_ACTIVE',
                 sessionId: 'existing-session',
             });
-            expect(workspaceAccessor.adoptRatchetActiveSessionIfEnabled).toHaveBeenCalledWith('ws-already-active', 'existing-session');
-            expect(workspaceAccessor.recordRatchetDispatchIfEnabled).not.toHaveBeenCalled();
+            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 = {
@@ -2465,7 +2936,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.CI_FAILED,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -2474,7 +2945,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 status: 'already_active',
                 sessionId: 'existing-session',
             });
-            vi.mocked(workspaceAccessor.adoptRatchetActiveSessionIfEnabled).mockResolvedValue(false);
+            vi.mocked(workspaceRatchetService.adoptActiveSessionIfEnabled).mockResolvedValue(false);
             vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
             const result = await unsafeCoerce(ratchetService).triggerFixer(workspace, {
                 ciStatus: CIStatus.FAILURE,
@@ -2494,7 +2965,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.CI_FAILED,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -2518,12 +2989,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             ratchetService.removeAllListeners();
         });
         it('emits ratchet_toggled when enabling workspace ratcheting', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue({
+            vi.mocked(workspaceDataService.findById).mockResolvedValue({
                 id: 'ws-enable',
                 ratchetState: RatchetState.CI_FAILED,
                 ratchetActiveSessionId: null,
+                ratchetDispatchOutcome: 'DIED',
+                ratchetDispatchRetryCount: 2,
             });
-            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
             const toggledEvents = [];
             const stateEvents = [];
             ratchetService.on(RATCHET_TOGGLED, (event) => {
@@ -2533,7 +3005,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 stateEvents.push(event);
             });
             await ratchetService.setWorkspaceRatcheting('ws-enable', true);
-            expect(workspaceAccessor.update).toHaveBeenCalledWith('ws-enable', { ratchetEnabled: true });
+            expect(workspaceRatchetService.enable).toHaveBeenCalledWith('ws-enable');
             expect(toggledEvents).toEqual([
                 {
                     workspaceId: 'ws-enable',
@@ -2544,12 +3016,11 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             expect(stateEvents).toHaveLength(0);
         });
         it('emits ratchet_toggled and ratchet_state_changed when disabling non-idle workspace', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue({
+            vi.mocked(workspaceDataService.findById).mockResolvedValue({
                 id: 'ws-disable',
                 ratchetState: RatchetState.CI_RUNNING,
                 ratchetActiveSessionId: null,
             });
-            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
             const toggledEvents = [];
             const stateEvents = [];
             ratchetService.on(RATCHET_TOGGLED, (event) => {
@@ -2559,14 +3030,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 stateEvents.push(event);
             });
             await ratchetService.setWorkspaceRatcheting('ws-disable', false);
-            expect(workspaceAccessor.update).toHaveBeenCalledWith('ws-disable', {
-                ratchetEnabled: false,
-                ratchetState: RatchetState.IDLE,
-                ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            });
+            expect(workspaceRatchetService.disable).toHaveBeenCalledWith('ws-disable');
             expect(stateEvents).toEqual([
                 {
                     workspaceId: 'ws-disable',
@@ -2583,12 +3047,11 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             ]);
         });
         it('stops ratchet workflow sessions found after disabling workspace', async () => {
-            vi.mocked(workspaceAccessor.findById).mockResolvedValue({
+            vi.mocked(workspaceDataService.findById).mockResolvedValue({
                 id: 'ws-disable-raced-session',
                 ratchetState: RatchetState.CI_RUNNING,
                 ratchetActiveSessionId: null,
             });
-            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
             vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
                 {
                     id: 'raced-ratchet-session',
@@ -2612,33 +3075,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         afterEach(() => {
             ratchetService.removeAllListeners();
         });
-        it('emits ratchet_state_changed when disabled workspace state changes', async () => {
-            const workspace = {
-                id: 'ws-disabled-change',
-                prUrl: 'https://github.com/example/repo/pull/30',
-                prNumber: 30,
-                ratchetEnabled: false,
-                ratchetState: RatchetState.CI_FAILED,
-                ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
-                prReviewLastCheckedAt: null,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            };
-            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-            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-disabled-change',
-                fromState: RatchetState.CI_FAILED,
-                toState: RatchetState.IDLE,
-            });
-        });
-        it('does NOT emit when disabled workspace state is already IDLE', async () => {
+        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',
@@ -2646,12 +3083,11 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: false,
                 ratchetState: RatchetState.IDLE,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             };
-            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
             const events = [];
             ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
                 events.push(event);
@@ -2667,7 +3103,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.IDLE,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -2681,8 +3117,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 prState: 'OPEN',
                 prNumber: 32,
             });
-            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
             vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
                 status: 'started',
                 sessionId: 'ratchet-session-32',
@@ -2709,7 +3144,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.CI_FAILED,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -2723,8 +3158,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 prState: 'OPEN',
                 prNumber: 33,
             });
-            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
-            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
             vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
                 status: 'started',
                 sessionId: 'ratchet-session-33',
@@ -2745,13 +3179,12 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: true,
                 ratchetState: RatchetState.CI_FAILED,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
             };
             vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue(null);
-            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
             const events = [];
             ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
                 events.push(event);