factory-factory 0.4.1 → 0.4.3

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { SERVICE_TIMEOUT_MS } from '../../../../backend/services/constants.js';
+import { SERVICE_THRESHOLDS, 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', () => ({
@@ -12,8 +12,7 @@ vi.mock('@/backend/services/workspace', () => ({
         clearActiveSession: vi.fn(),
         enable: vi.fn(),
         disable: vi.fn(),
-        transitionStateIfEnabled: vi.fn(),
-        settleIdleWhileDisabled: vi.fn(),
+        recordCheckIfEnabled: vi.fn(),
         recordDispatchIfEnabled: vi.fn(),
         adoptActiveSessionIfEnabled: vi.fn(),
         recordSessionEnd: vi.fn(),
@@ -65,30 +64,49 @@ const mockSessionBridge = {
 const mockWorkspaceBridge = {
     findFixerContext: vi.fn(),
     recordSessionEnd: vi.fn(),
+    markDispatchStalled: vi.fn().mockResolvedValue(true),
 };
+const fakeCoordinator = { cooldownActive: false, inFlightSkips: 0 };
 const mockGitHubBridge = {
     extractPRInfo: vi.fn(),
     getPRFullDetails: vi.fn(),
     getReviewComments: vi.fn(),
     getResolvedReviewCommentIds: vi.fn(),
     computeCIStatus: vi.fn(),
+    computePRState: vi.fn(() => 'OPEN'),
     getAuthenticatedUsername: vi.fn(),
     fetchAndComputePRState: vi.fn(),
-    isRecentlyFetched: vi.fn(),
-    isFetchInFlight: vi.fn(),
-    startFetch: vi.fn(() => 41),
-    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({
@@ -97,8 +115,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             snapshot: mockSnapshotBridge,
             workspace: mockWorkspaceBridge,
         });
-        vi.mocked(workspaceRatchetService.transitionStateIfEnabled).mockResolvedValue(true);
-        vi.mocked(workspaceRatchetService.settleIdleWhileDisabled).mockResolvedValue(true);
+        vi.mocked(workspaceRatchetService.recordCheckIfEnabled).mockResolvedValue(true);
         vi.mocked(workspaceRatchetService.recordDispatchIfEnabled).mockResolvedValue(true);
         vi.mocked(workspaceRatchetService.adoptActiveSessionIfEnabled).mockResolvedValue(true);
         vi.mocked(workspaceRatchetService.recordSessionEnd).mockResolvedValue(true);
@@ -147,16 +164,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.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,
+                ratchetDispatchStalled: false,
             },
         ]);
         vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockResolvedValue({
@@ -174,11 +195,13 @@ 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,
@@ -192,70 +215,37 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             action: { type: 'DISABLED', reason: 'Workspace ratcheting disabled' },
             newState: RatchetState.IDLE,
         });
-        expect(workspaceRatchetService.settleIdleWhileDisabled).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(workspaceRatchetService.settleIdleWhileDisabled).mockResolvedValue(true);
         const events = [];
         ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
             events.push(event);
         });
         const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(workspaceRatchetService.settleIdleWhileDisabled).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(workspaceRatchetService.settleIdleWhileDisabled).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 = {
@@ -263,11 +253,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,
@@ -313,11 +305,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,
@@ -346,11 +340,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             snapshotKey: '2026-01-02T00:00:00Z',
             retryCount: 0,
         });
-        const finalUpdatePayload = vi
-            .mocked(workspaceRatchetService.transitionStateIfEnabled)
-            .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 () => {
@@ -359,11 +349,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,
@@ -384,7 +376,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             promptSent: true,
         });
         vi.mocked(workspaceRatchetService.recordDispatchIfEnabled).mockResolvedValue(false);
-        vi.mocked(workspaceRatchetService.transitionStateIfEnabled).mockResolvedValue(false);
+        vi.mocked(workspaceRatchetService.recordCheckIfEnabled).mockResolvedValue(false);
         vi.mocked(workspaceDataService.findById).mockResolvedValue({
             id: 'ws-disable-race-dispatch',
             ratchetEnabled: false,
@@ -410,11 +402,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,
@@ -455,11 +449,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,
@@ -484,17 +480,188 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         expect(mockSessionBridge.findSessionsByWorkspaceId).not.toHaveBeenCalled();
         expect(mockSnapshotBridge.recordReviewCheck).not.toHaveBeenCalled();
     });
+    it('marks the dispatch stalled when a settled dispatch achieved nothing', async () => {
+        const workspace = {
+            id: 'ws-1',
+            prUrl: 'https://github.com/example/repo/pull/5',
+            prNumber: 5,
+            prState: 'OPEN',
+            prReviewState: null,
+            prHasMergeConflict: false,
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: null,
+            ratchetDispatchSnapshotKey: '2026-01-02T00:00:00Z',
+            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
+            ratchetDispatchOutcome: 'COMPLETED',
+            ratchetDispatchRetryCount: 0,
+        };
+        vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.FAILURE,
+            snapshotKey: '2026-01-02T00:00:00Z',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 5,
+        });
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
+        await ratchetService.checkWorkspaceById('ws-1');
+        expect(mockWorkspaceBridge.markDispatchStalled).toHaveBeenCalledWith('ws-1', '2026-01-02T00:00:00Z');
+    });
+    it('marks the dispatch stalled when a DIED fixer exhausts its retries', async () => {
+        const workspace = {
+            id: 'ws-1',
+            prUrl: 'https://github.com/example/repo/pull/15',
+            prNumber: 15,
+            prState: 'OPEN',
+            prReviewState: null,
+            prHasMergeConflict: false,
+            prCiStatus: CIStatus.FAILURE,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.CI_FAILED,
+            ratchetActiveSessionId: null,
+            ratchetDispatchSnapshotKey: 'same-snapshot',
+            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
+            ratchetDispatchOutcome: 'DIED',
+            ratchetDispatchRetryCount: SERVICE_THRESHOLDS.ratchetDispatchMaxRetries,
+        };
+        vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.FAILURE,
+            snapshotKey: 'same-snapshot',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 15,
+        });
+        await ratchetService.checkWorkspaceById('ws-1');
+        expect(mockWorkspaceBridge.markDispatchStalled).toHaveBeenCalledWith('ws-1', 'same-snapshot');
+    });
+    it('publishes a dispatch-changed event when the stall flag actually flips', async () => {
+        const workspace = {
+            id: 'ws-1',
+            prUrl: 'https://github.com/example/repo/pull/5',
+            prNumber: 5,
+            prState: 'OPEN',
+            prReviewState: null,
+            prHasMergeConflict: false,
+            prCiStatus: CIStatus.FAILURE,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.CI_FAILED,
+            ratchetActiveSessionId: null,
+            ratchetDispatchSnapshotKey: 'stalled-key',
+            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
+            ratchetDispatchOutcome: 'COMPLETED',
+            ratchetDispatchRetryCount: 0,
+        };
+        vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
+        vi.mocked(mockWorkspaceBridge.markDispatchStalled).mockResolvedValue(true);
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.FAILURE,
+            snapshotKey: 'stalled-key',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 5,
+        });
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
+        const events = [];
+        ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
+            events.push(event);
+        });
+        await ratchetService.checkWorkspaceById('ws-1');
+        expect(events).toEqual([{ workspaceId: 'ws-1' }]);
+    });
+    it('publishes nothing when the stall flag was already set', async () => {
+        const workspace = {
+            id: 'ws-1',
+            prUrl: 'https://github.com/example/repo/pull/5',
+            prNumber: 5,
+            prState: 'OPEN',
+            prReviewState: null,
+            prHasMergeConflict: false,
+            prCiStatus: CIStatus.FAILURE,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.CI_FAILED,
+            ratchetActiveSessionId: null,
+            ratchetDispatchSnapshotKey: 'stalled-key',
+            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
+            ratchetDispatchOutcome: 'COMPLETED',
+            ratchetDispatchRetryCount: 0,
+        };
+        vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
+        vi.mocked(mockWorkspaceBridge.markDispatchStalled).mockResolvedValue(false);
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.FAILURE,
+            snapshotKey: 'stalled-key',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 5,
+        });
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
+        const events = [];
+        ratchetService.on(RATCHET_DISPATCH_CHANGED, (event) => {
+            events.push(event);
+        });
+        await ratchetService.checkWorkspaceById('ws-1');
+        expect(events).toEqual([]);
+    });
+    it('does not mark the dispatch stalled when the PR state has changed', async () => {
+        const workspace = {
+            id: 'ws-1',
+            prUrl: 'https://github.com/example/repo/pull/5',
+            prNumber: 5,
+            prState: 'OPEN',
+            prReviewState: null,
+            prHasMergeConflict: false,
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: null,
+            ratchetDispatchSnapshotKey: 'old-snapshot',
+            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
+            ratchetDispatchOutcome: null,
+            ratchetDispatchRetryCount: 0,
+        };
+        vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(workspace);
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.FAILURE,
+            snapshotKey: '2026-01-02T00:00:00Z',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 5,
+        });
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+            status: 'started',
+            sessionId: 'fresh-session',
+            promptSent: true,
+        });
+        await ratchetService.checkWorkspaceById('ws-1');
+        expect(mockWorkspaceBridge.markDispatchStalled).not.toHaveBeenCalled();
+    });
     it('does not dispatch repeatedly for unchanged CHANGES_REQUESTED state', async () => {
         const workspace = {
             id: 'ws-review-unchanged',
             prUrl: 'https://github.com/example/repo/pull/55',
             prNumber: 55,
             prState: 'OPEN',
+            prReviewState: null,
+            prHasMergeConflict: false,
             prCiStatus: CIStatus.UNKNOWN,
             ratchetEnabled: true,
             ratchetState: RatchetState.REVIEW_PENDING,
             ratchetActiveSessionId: null,
-            ratchetLastCiRunId: 'ci:SUCCESS|changes-requested:1735776000000',
+            ratchetDispatchSnapshotKey: 'ci:SUCCESS|changes-requested:1735776000000',
             prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
             ratchetDispatchOutcome: null,
             ratchetDispatchRetryCount: 0,
@@ -535,11 +702,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
@@ -573,11 +742,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
@@ -639,11 +810,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,
@@ -678,7 +851,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         expect(result).toMatchObject({
             action: { type: 'ERROR', error: 'Failed to deliver initial ratchet prompt' },
         });
-        expect(workspaceRatchetService.clearActiveSession).toHaveBeenCalledWith(workspace.id);
+        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 () => {
@@ -735,11 +908,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,
@@ -771,11 +946,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: 'failed-snapshot',
+            ratchetDispatchSnapshotKey: 'failed-snapshot',
             prReviewLastCheckedAt: recentCheck,
             ratchetDispatchOutcome: 'COMPLETED',
             ratchetDispatchRetryCount: 0,
@@ -821,11 +998,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,
@@ -839,7 +1018,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prState: 'OPEN',
             prNumber: 41,
         });
-        vi.mocked(workspaceRatchetService.transitionStateIfEnabled).mockResolvedValue(false);
+        vi.mocked(workspaceRatchetService.recordCheckIfEnabled).mockResolvedValue(false);
         vi.mocked(workspaceDataService.findById).mockResolvedValue({
             id: 'ws-disable-race-state',
             ratchetEnabled: false,
@@ -857,55 +1036,195 @@ 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,
-        });
-        vi.mocked(workspaceRatchetService.transitionStateIfEnabled).mockResolvedValue(false);
-        vi.mocked(workspaceDataService.findById).mockResolvedValue({
-            id: 'ws-superseded',
-            ratchetEnabled: true,
-            ratchetState: RatchetState.IDLE,
+            cachedPrState: 'CHANGES_REQUESTED',
+            reviewDecision: 'CHANGES_REQUESTED',
+            prNumber: 44,
+            reviewComments: [],
         });
         vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        const events = [];
-        ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-            events.push(event);
+        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('stops live ratchet sessions before persisting a merged PR', async () => {
+        const workspace = {
+            id: 'ws-merged',
+            prUrl: 'https://github.com/example/repo/pull/45',
+            prNumber: 45,
+            prState: 'OPEN',
+            prReviewState: null,
+            prHasMergeConflict: false,
+            prCiStatus: CIStatus.SUCCESS,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: null,
+            ratchetDispatchSnapshotKey: 'merged-snapshot',
+            prReviewLastCheckedAt: null,
+            ratchetDispatchOutcome: null,
+            ratchetDispatchRetryCount: 0,
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: 'merged-snapshot',
+            hasChangesRequested: false,
+            hasMergeConflict: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'MERGED',
+            cachedPrState: 'MERGED',
+            reviewDecision: null,
+            prNumber: 45,
+            reviewComments: [],
         });
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
+            {
+                id: 'ratchet-running',
+                workflow: 'ratchet',
+                status: SessionStatus.RUNNING,
+            },
+            {
+                id: 'ratchet-idle',
+                workflow: 'ratchet',
+                status: SessionStatus.IDLE,
+            },
+            {
+                id: 'ratchet-completed',
+                workflow: 'ratchet',
+                status: SessionStatus.COMPLETED,
+            },
+            {
+                id: 'manual-running',
+                workflow: 'default',
+                status: SessionStatus.RUNNING,
+            },
+        ]);
+        vi.mocked(mockSessionBridge.isSessionRunning).mockImplementation((sessionId) => ['ratchet-running', 'ratchet-idle', 'manual-running'].includes(sessionId));
         const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(workspaceRatchetService.transitionStateIfEnabled).toHaveBeenCalledWith('ws-superseded', RatchetState.CI_RUNNING, expect.objectContaining({ ratchetState: RatchetState.READY }));
+        expect(mockSessionBridge.stopSession).toHaveBeenCalledTimes(2);
+        expect(mockSessionBridge.stopSession).toHaveBeenNthCalledWith(1, 'ratchet-running');
+        expect(mockSessionBridge.stopSession).toHaveBeenNthCalledWith(2, 'ratchet-idle');
+        expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({ workspaceId: 'ws-merged', prState: 'MERGED' }));
+        expect(vi.mocked(mockSessionBridge.stopSession).mock.invocationCallOrder.at(-1)).toBeLessThan(vi.mocked(mockSnapshotBridge.recordPrObservation).mock.invocationCallOrder[0] ?? 0);
         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',
+            newState: RatchetState.MERGED,
+            action: { type: 'COMPLETED' },
+        });
+    });
+    it('does not persist a merged PR when stopping a ratchet session fails', async () => {
+        const workspace = {
+            id: 'ws-merged-stop-failure',
+            prUrl: 'https://github.com/example/repo/pull/46',
+            prNumber: 46,
+            prState: 'OPEN',
+            prReviewState: null,
+            prHasMergeConflict: false,
+            prCiStatus: CIStatus.SUCCESS,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: 'ratchet-running',
+            ratchetDispatchSnapshotKey: 'merged-stop-failure-snapshot',
+            prReviewLastCheckedAt: null,
+            ratchetDispatchOutcome: 'RUNNING',
+            ratchetDispatchRetryCount: 0,
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: 'merged-stop-failure-snapshot',
+            hasChangesRequested: false,
+            hasMergeConflict: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'MERGED',
+            cachedPrState: 'MERGED',
+            reviewDecision: null,
+            prNumber: 46,
+            reviewComments: [],
+        });
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
+            {
+                id: 'ratchet-running',
+                workflow: 'ratchet',
+                status: SessionStatus.RUNNING,
             },
+        ]);
+        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
+        vi.mocked(mockSessionBridge.stopSession).mockRejectedValue(new Error('stop failed'));
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(result).toMatchObject({
+            previousState: RatchetState.READY,
+            newState: RatchetState.READY,
+            action: { type: 'ERROR', error: 'stop failed' },
         });
-        expect(events).toHaveLength(0);
-        expect(mockSnapshotBridge.recordCIObservation).not.toHaveBeenCalled();
-        expect(mockSnapshotBridge.recordReviewCheck).not.toHaveBeenCalled();
+        expect(workspaceRatchetService.recordCheckIfEnabled).not.toHaveBeenCalled();
+        expect(mockSnapshotBridge.recordPrObservation).not.toHaveBeenCalled();
+    });
+    it('persists a newly observed merge conflict even when CI status is unchanged', async () => {
+        const workspace = {
+            id: 'ws-conflict',
+            prUrl: 'https://github.com/example/repo/pull/43',
+            prNumber: 43,
+            prState: 'OPEN',
+            prReviewState: null,
+            prHasMergeConflict: false,
+            prCiStatus: CIStatus.SUCCESS,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: null,
+            ratchetDispatchSnapshotKey: 'conflict-snapshot',
+            prReviewLastCheckedAt: null,
+            ratchetDispatchOutcome: null,
+            ratchetDispatchRetryCount: 0,
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: 'conflict-snapshot',
+            hasChangesRequested: false,
+            hasMergeConflict: true,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            cachedPrState: 'OPEN',
+            reviewDecision: null,
+            prNumber: 43,
+            reviewComments: [],
+        });
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
+        await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({
+            workspaceId: 'ws-conflict',
+            ciStatus: CIStatus.SUCCESS,
+            hasMergeConflict: true,
+        }));
     });
     it('redispatches with an incremented retry count when the previous fixer died', async () => {
         const workspace = {
@@ -913,11 +1232,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,
@@ -954,11 +1275,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,
@@ -1000,11 +1323,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,
@@ -1033,11 +1358,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,
@@ -1069,11 +1396,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,
@@ -1106,11 +1435,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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,
-            ratchetLastCiRunId: previousSnapshotKey,
+            ratchetDispatchSnapshotKey: previousSnapshotKey,
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'COMPLETED',
             ratchetDispatchRetryCount: 2,
@@ -1147,11 +1478,13 @@ 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_FAILED,
             ratchetActiveSessionId: 'ratchet-session',
-            ratchetLastCiRunId: 'previous-snapshot-key',
+            ratchetDispatchSnapshotKey: 'previous-snapshot-key',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'RUNNING',
             ratchetDispatchRetryCount: 0,
@@ -1172,11 +1505,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: 'deleted-session',
-            ratchetLastCiRunId: 'previous-snapshot-key',
+            ratchetDispatchSnapshotKey: 'previous-snapshot-key',
             prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
             ratchetDispatchOutcome: 'RUNNING',
             ratchetDispatchRetryCount: 0,
@@ -1197,11 +1532,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,
@@ -1222,11 +1559,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,
@@ -1257,11 +1596,13 @@ 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,
@@ -1327,11 +1668,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,
@@ -1543,7 +1886,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,
@@ -1563,7 +1906,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,
@@ -1577,7 +1920,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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',
@@ -1585,7 +1928,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,
@@ -1605,7 +1948,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,
@@ -1621,7 +1964,7 @@ 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: [] });
         });
@@ -1636,11 +1979,13 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -1665,7 +2010,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,
@@ -1681,7 +2026,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,
@@ -1723,13 +2068,15 @@ 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,
@@ -1796,13 +2143,15 @@ 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,
@@ -1852,98 +2201,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(workspaceDataService.findById).mockResolvedValue({
-                id: 'ws-closed',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-            });
-            vi.mocked(workspaceRatchetService.transitionStateIfEnabled).mockResolvedValue(true);
-            const stateEvents = [];
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                stateEvents.push(event);
-            });
-            await ratchetService.markPrClosed('ws-closed');
-            expect(workspaceRatchetService.transitionStateIfEnabled).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(workspaceDataService.findById)
-                .mockResolvedValueOnce({
-                id: 'ws-closed',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-            })
-                .mockResolvedValueOnce({
-                id: 'ws-closed',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_RUNNING,
-            });
-            vi.mocked(workspaceRatchetService.transitionStateIfEnabled)
-                .mockResolvedValueOnce(false)
-                .mockResolvedValueOnce(true);
-            const stateEvents = [];
-            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-                stateEvents.push(event);
-            });
-            await ratchetService.markPrClosed('ws-closed');
-            expect(workspaceRatchetService.transitionStateIfEnabled).toHaveBeenNthCalledWith(1, 'ws-closed', RatchetState.CI_FAILED, expect.objectContaining({ ratchetState: RatchetState.IDLE }));
-            expect(workspaceRatchetService.transitionStateIfEnabled).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(workspaceDataService.findById).mockResolvedValue({
-                id: 'ws-closed',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.IDLE,
-            });
-            await ratchetService.markPrClosed('ws-closed');
-            expect(workspaceRatchetService.transitionStateIfEnabled).not.toHaveBeenCalled();
-        });
-        it('does not emit when ratcheting was disabled concurrently', async () => {
-            vi.mocked(workspaceDataService.findById)
-                .mockResolvedValueOnce({
-                id: 'ws-closed',
-                ratchetEnabled: true,
-                ratchetState: RatchetState.CI_FAILED,
-            })
-                .mockResolvedValueOnce({
-                id: 'ws-closed',
-                ratchetEnabled: false,
-                ratchetState: RatchetState.IDLE,
-            });
-            vi.mocked(workspaceRatchetService.transitionStateIfEnabled).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(workspaceDataService.findById).mockResolvedValue(null);
-            await ratchetService.markPrClosed('ws-missing');
-            expect(workspaceRatchetService.transitionStateIfEnabled).not.toHaveBeenCalled();
-        });
         it('does not continue to side effects after a timed-out await completes', async () => {
             unsafeCoerce(ratchetService).workspaceCheckTimeoutMs = 5;
             const workspace = {
@@ -1951,13 +2212,15 @@ 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,
@@ -1987,17 +2250,17 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             releaseFetch();
             await new Promise((resolve) => setTimeout(resolve, 0));
             expect(finishSpy).not.toHaveBeenCalled();
-            expect(workspaceRatchetService.transitionStateIfEnabled).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;
+            setRatchetShuttingDown(false);
             vi.mocked(workspaceRatchetService.findCandidateById).mockResolvedValue(null);
             const result = await ratchetService.checkWorkspaceById('ws-nonexistent');
             expect(result).toBeNull();
@@ -2008,11 +2271,13 @@ 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,
@@ -2023,7 +2288,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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();
@@ -2034,13 +2299,15 @@ 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,
@@ -2051,8 +2318,9 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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',
@@ -2077,13 +2345,15 @@ 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,
@@ -2094,8 +2364,9 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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',
@@ -2120,11 +2391,13 @@ 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,
@@ -2135,28 +2408,30 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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,
@@ -2486,22 +2761,58 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             expect(result).toEqual({ kind: 'settled', outcome: 'DIED' });
             expect(mockWorkspaceBridge.recordSessionEnd).toHaveBeenCalledWith('ws-4', 'failed-session', 'DIED');
         });
-        it('settles a provider-mismatched session as DIED and stops it', async () => {
+        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' });
+            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');
-            expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('codex-session');
+            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(mockSessionBridge.findSessionById).mockResolvedValue({
@@ -2703,6 +3014,10 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 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',
@@ -2716,6 +3031,10 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             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({
@@ -2726,6 +3045,10 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             });
             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',
@@ -2738,6 +3061,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             }, 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();
@@ -2805,7 +3129,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,
@@ -2828,7 +3152,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: 2,
@@ -2861,7 +3185,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,
@@ -2890,7 +3214,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,
@@ -3000,32 +3324,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,
-            };
-            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',
@@ -3033,7 +3332,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 ratchetEnabled: false,
                 ratchetState: RatchetState.IDLE,
                 ratchetActiveSessionId: null,
-                ratchetLastCiRunId: null,
+                ratchetDispatchSnapshotKey: null,
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
@@ -3053,7 +3352,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,
@@ -3094,7 +3393,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,
@@ -3129,7 +3428,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,