factory-factory 0.4.2 → 0.4.4

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', () => ({
@@ -64,6 +64,7 @@ const mockSessionBridge = {
 const mockWorkspaceBridge = {
     findFixerContext: vi.fn(),
     recordSessionEnd: vi.fn(),
+    markDispatchStalled: vi.fn().mockResolvedValue(true),
 };
 const fakeCoordinator = { cooldownActive: false, inFlightSkips: 0 };
 const mockGitHubBridge = {
@@ -176,6 +177,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
                 prReviewLastCheckedAt: null,
                 ratchetDispatchOutcome: null,
                 ratchetDispatchRetryCount: 0,
+                ratchetDispatchStalled: false,
             },
         ]);
         vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockResolvedValue({
@@ -478,6 +480,175 @@ 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',
@@ -899,13 +1070,14 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         await unsafeCoerce(ratchetService).processWorkspace(workspace);
         expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({
             workspaceId: 'ws-observation',
+            prUrl: 'https://github.com/example/repo/pull/44',
             prState: 'CHANGES_REQUESTED',
             reviewState: 'CHANGES_REQUESTED',
             ciStatus: CIStatus.SUCCESS,
             hasMergeConflict: false,
         }));
     });
-    it('persists a merge observed by the check even when CI status is unchanged', async () => {
+    it('stops live ratchet sessions before persisting a merged PR', async () => {
         const workspace = {
             id: 'ws-merged',
             prUrl: 'https://github.com/example/repo/pull/45',
@@ -935,9 +1107,91 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             prNumber: 45,
             reviewComments: [],
         });
-        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([]);
-        await unsafeCoerce(ratchetService).processWorkspace(workspace);
-        expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({ workspaceId: 'ws-merged', prState: 'MERGED' }));
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
+            {
+                id: 'ratchet-running',
+                workflow: 'ratchet',
+                status: SessionStatus.RUNNING,
+            },
+            {
+                id: 'ratchet-idle',
+                workflow: 'ratchet',
+                status: SessionStatus.IDLE,
+            },
+            {
+                id: 'ratchet-completed',
+                workflow: 'ratchet',
+                status: SessionStatus.COMPLETED,
+            },
+            {
+                id: 'manual-running',
+                workflow: 'default',
+                status: SessionStatus.RUNNING,
+            },
+        ]);
+        vi.mocked(mockSessionBridge.isSessionRunning).mockImplementation((sessionId) => ['ratchet-running', 'ratchet-idle', 'manual-running'].includes(sessionId));
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(mockSessionBridge.stopSession).toHaveBeenCalledTimes(2);
+        expect(mockSessionBridge.stopSession).toHaveBeenNthCalledWith(1, 'ratchet-running');
+        expect(mockSessionBridge.stopSession).toHaveBeenNthCalledWith(2, 'ratchet-idle');
+        expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({
+            workspaceId: 'ws-merged',
+            prUrl: 'https://github.com/example/repo/pull/45',
+            prState: 'MERGED',
+        }));
+        expect(vi.mocked(mockSessionBridge.stopSession).mock.invocationCallOrder.at(-1)).toBeLessThan(vi.mocked(mockSnapshotBridge.recordPrObservation).mock.invocationCallOrder[0] ?? 0);
+        expect(result).toMatchObject({
+            newState: RatchetState.MERGED,
+            action: { type: 'COMPLETED' },
+        });
+    });
+    it('does not persist a merged PR when stopping a ratchet session fails', async () => {
+        const workspace = {
+            id: 'ws-merged-stop-failure',
+            prUrl: 'https://github.com/example/repo/pull/46',
+            prNumber: 46,
+            prState: 'OPEN',
+            prReviewState: null,
+            prHasMergeConflict: false,
+            prCiStatus: CIStatus.SUCCESS,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: 'ratchet-running',
+            ratchetDispatchSnapshotKey: 'merged-stop-failure-snapshot',
+            prReviewLastCheckedAt: null,
+            ratchetDispatchOutcome: 'RUNNING',
+            ratchetDispatchRetryCount: 0,
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: 'merged-stop-failure-snapshot',
+            hasChangesRequested: false,
+            hasMergeConflict: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'MERGED',
+            cachedPrState: 'MERGED',
+            reviewDecision: null,
+            prNumber: 46,
+            reviewComments: [],
+        });
+        vi.mocked(mockSessionBridge.findSessionsByWorkspaceId).mockResolvedValue([
+            {
+                id: 'ratchet-running',
+                workflow: 'ratchet',
+                status: SessionStatus.RUNNING,
+            },
+        ]);
+        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
+        vi.mocked(mockSessionBridge.stopSession).mockRejectedValue(new Error('stop failed'));
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(result).toMatchObject({
+            previousState: RatchetState.READY,
+            newState: RatchetState.READY,
+            action: { type: 'ERROR', error: 'stop failed' },
+        });
+        expect(workspaceRatchetService.recordCheckIfEnabled).not.toHaveBeenCalled();
+        expect(mockSnapshotBridge.recordPrObservation).not.toHaveBeenCalled();
     });
     it('persists a newly observed merge conflict even when CI status is unchanged', async () => {
         const workspace = {
@@ -973,6 +1227,7 @@ describe('ratchet service (state-change + idle dispatch)', () => {
         await unsafeCoerce(ratchetService).processWorkspace(workspace);
         expect(mockSnapshotBridge.recordPrObservation).toHaveBeenCalledWith(expect.objectContaining({
             workspaceId: 'ws-conflict',
+            prUrl: 'https://github.com/example/repo/pull/43',
             ciStatus: CIStatus.SUCCESS,
             hasMergeConflict: true,
         }));
@@ -2565,6 +2820,30 @@ describe('ratchet service (state-change + idle dispatch)', () => {
             finishStop();
             await pendingStop;
         });
+        it('stops completed session even when abort fires after settlement', async () => {
+            const controller = new AbortController();
+            const timeoutError = new Error('Workspace check timed out');
+            vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
+                id: 'completed-session',
+                provider: 'CLAUDE',
+                status: SessionStatus.RUNNING,
+            });
+            vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
+            vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(false);
+            vi.mocked(mockSessionBridge.stopSession).mockResolvedValue();
+            vi.mocked(mockWorkspaceBridge.recordSessionEnd).mockImplementation(() => {
+                controller.abort(timeoutError);
+                return Promise.resolve(true);
+            });
+            const check = unsafeCoerce(ratchetService).checkActiveFixerSession({
+                id: 'ws-completed-aborted-after-settlement',
+                ratchetActiveSessionId: 'completed-session',
+                defaultSessionProvider: 'CLAUDE',
+                ratchetSessionProvider: 'CLAUDE',
+            }, controller.signal);
+            await expect(check).rejects.toBe(timeoutError);
+            expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('completed-session');
+        });
         it('returns the active fixer when the session is working', async () => {
             vi.mocked(mockSessionBridge.findSessionById).mockResolvedValue({
                 id: 'working-session',