factory-factory 0.3.9 → 0.3.11

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

@@ -0,0 +1,1601 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { SERVICE_TIMEOUT_MS } from '../../../../backend/services/constants.js';
+import { CIStatus, RatchetState, SessionStatus } from '../../../../shared/core/index.js';
+import { unsafeCoerce } from '../../../../test-utils/unsafe-coerce.js';
+vi.mock('@/backend/services/workspace', () => ({
+    workspaceAccessor: {
+        findById: vi.fn(),
+        findWithPRsForRatchet: vi.fn(),
+        findForRatchetById: vi.fn(),
+        update: vi.fn(),
+    },
+}));
+vi.mock('@/backend/services/session', () => ({
+    agentSessionAccessor: {
+        findById: vi.fn(),
+        findByWorkspaceId: vi.fn(),
+    },
+}));
+vi.mock('@/backend/services/settings', () => ({
+    userSettingsAccessor: {
+        get: vi.fn(),
+        getDefaultSessionProvider: vi.fn(),
+    },
+}));
+vi.mock('./fixer-session.service', () => ({
+    fixerSessionService: {
+        acquireAndDispatch: vi.fn(),
+    },
+}));
+vi.mock('@/backend/services/logger.service', () => ({
+    createLogger: () => ({
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    }),
+}));
+import { agentSessionAccessor } from '../../../../backend/services/session/index.js';
+import { userSettingsAccessor } from '../../../../backend/services/settings/index.js';
+import { workspaceAccessor } from '../../../../backend/services/workspace/index.js';
+import { fixerSessionService } from './fixer-session.service.js';
+import { RATCHET_STATE_CHANGED, RATCHET_TOGGLED, ratchetService, } from './ratchet.service.js';
+const mockSessionBridge = {
+    isSessionRunning: vi.fn(),
+    isSessionWorking: vi.fn(),
+    stopSession: vi.fn(),
+    startSession: vi.fn(),
+    sendSessionMessage: vi.fn(),
+    injectCommittedUserMessage: vi.fn(),
+};
+const mockGitHubBridge = {
+    extractPRInfo: vi.fn(),
+    getPRFullDetails: vi.fn(),
+    getReviewComments: vi.fn(),
+    computeCIStatus: vi.fn(),
+    getAuthenticatedUsername: vi.fn(),
+    fetchAndComputePRState: vi.fn(),
+};
+const mockSnapshotBridge = {
+    recordCIObservation: vi.fn(),
+    recordCINotification: vi.fn(),
+    recordReviewCheck: vi.fn(),
+};
+describe('ratchet service (state-change + idle dispatch)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        unsafeCoerce(ratchetService).isShuttingDown = false;
+        unsafeCoerce(ratchetService).workspaceCheckTimeoutMs =
+            SERVICE_TIMEOUT_MS.ratchetWorkspaceCheck;
+        unsafeCoerce(ratchetService).reviewPollTrackers.clear();
+        ratchetService.configure({
+            session: mockSessionBridge,
+            github: mockGitHubBridge,
+            snapshot: mockSnapshotBridge,
+        });
+        vi.mocked(mockGitHubBridge.getAuthenticatedUsername).mockResolvedValue(null);
+        vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(false);
+        vi.mocked(userSettingsAccessor.get).mockResolvedValue({
+            id: 'settings-1',
+            userId: 'default',
+            preferredIde: 'cursor',
+            customIdeCommand: null,
+            playSoundOnComplete: true,
+            notificationSoundPath: null,
+            workspaceOrder: null,
+            cachedSlashCommands: null,
+            ratchetEnabled: false,
+            defaultSessionProvider: 'CLAUDE',
+            defaultClaudeModel: 'sonnet',
+            defaultCodexModel: 'default',
+            defaultWorkspacePermissions: 'STRICT',
+            ratchetPermissions: 'YOLO',
+            createdAt: new Date('2026-01-01T00:00:00.000Z'),
+            updatedAt: new Date('2026-01-01T00:00:00.000Z'),
+        });
+        vi.mocked(userSettingsAccessor.getDefaultSessionProvider).mockResolvedValue('CLAUDE');
+    });
+    it('checks workspaces and processes each', async () => {
+        vi.mocked(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue([
+            {
+                id: 'ws-1',
+                prUrl: 'https://github.com/example/repo/pull/1',
+                prNumber: 1,
+                prState: 'OPEN',
+                prCiStatus: CIStatus.UNKNOWN,
+                defaultSessionProvider: 'WORKSPACE_DEFAULT',
+                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
+                ratchetEnabled: true,
+                ratchetState: RatchetState.IDLE,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            },
+        ]);
+        vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockResolvedValue({
+            workspaceId: 'ws-1',
+            previousState: RatchetState.IDLE,
+            newState: RatchetState.IDLE,
+            action: { type: 'WAITING', reason: 'noop' },
+        });
+        const result = await ratchetService.checkAllWorkspaces();
+        expect(result.checked).toBe(1);
+    });
+    it('does not dispatch when workspace ratcheting is disabled', async () => {
+        const workspace = {
+            id: 'ws-disabled',
+            prUrl: 'https://github.com/example/repo/pull/2',
+            prNumber: 2,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: false,
+            ratchetState: RatchetState.IDLE,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: null,
+            prReviewLastCheckedAt: null,
+        };
+        const fetchPRStateSpy = vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState');
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(fetchPRStateSpy).not.toHaveBeenCalled();
+        expect(triggerSpy).not.toHaveBeenCalled();
+        expect(result).toMatchObject({
+            action: { type: 'DISABLED', reason: 'Workspace ratcheting disabled' },
+            newState: RatchetState.IDLE,
+        });
+    });
+    it('does not dispatch when workspace is not idle', async () => {
+        const workspace = {
+            id: 'ws-busy',
+            prUrl: 'https://github.com/example/repo/pull/3',
+            prNumber: 3,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.IDLE,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: null,
+            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: '2026-01-02T00:00:00Z',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: new Date('2026-01-02T00:00:00Z').getTime(),
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 3,
+            reviewComments: [
+                {
+                    author: 'reviewer',
+                    body: 'Please update this',
+                    path: 'src/test.ts',
+                    line: 3,
+                    url: 'https://github.com/example/repo/pull/3#discussion_r1',
+                },
+            ],
+        });
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            {
+                id: 'chat-1',
+                workflow: 'default-followup',
+                status: 'RUNNING',
+            },
+        ]);
+        vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(true);
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(result).toMatchObject({
+            action: {
+                type: 'WAITING',
+                reason: 'Workspace is not idle (active session)',
+            },
+        });
+    });
+    it('dispatches when PR state changed since last ratchet', async () => {
+        const workspace = {
+            id: 'ws-change',
+            prUrl: 'https://github.com/example/repo/pull/4',
+            prNumber: 4,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.IDLE,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: '2026-01-01T00:00:00Z',
+            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.FAILURE,
+            snapshotKey: '2026-01-02T00:00:00Z',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 4,
+        });
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+            status: 'started',
+            sessionId: 'ratchet-session',
+            promptSent: true,
+        });
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(result).toMatchObject({
+            action: { type: 'TRIGGERED_FIXER' },
+        });
+        const finalUpdatePayload = vi.mocked(workspaceAccessor.update).mock.calls.at(-1)?.[1];
+        expect(finalUpdatePayload.ratchetLastCiRunId).toBe('2026-01-02T00:00:00Z');
+        expect(finalUpdatePayload).not.toHaveProperty('prReviewLastCheckedAt');
+        expect(mockSnapshotBridge.recordReviewCheck).toHaveBeenCalledWith('ws-change', expect.any(Date));
+    });
+    it('does dispatch when session is running but idle', async () => {
+        const workspace = {
+            id: 'ws-idle-session',
+            prUrl: 'https://github.com/example/repo/pull/44',
+            prNumber: 44,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.IDLE,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: '2026-01-01T00:00:00Z',
+            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.FAILURE,
+            snapshotKey: '2026-01-02T00:00:00Z',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 44,
+        });
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([
+            {
+                id: 'chat-idle-1',
+                workflow: 'default-followup',
+                status: 'RUNNING',
+            },
+        ]);
+        vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(false);
+        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+            status: 'started',
+            sessionId: 'ratchet-session-idle-ok',
+            promptSent: true,
+        });
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(result).toMatchObject({
+            action: { type: 'TRIGGERED_FIXER', sessionId: 'ratchet-session-idle-ok' },
+        });
+    });
+    it('does not dispatch when PR state unchanged since last dispatch', async () => {
+        const workspace = {
+            id: 'ws-unchanged',
+            prUrl: 'https://github.com/example/repo/pull/5',
+            prNumber: 5,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: '2026-01-02T00:00:00Z',
+            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
+        };
+        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(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(result).toMatchObject({
+            action: {
+                type: 'WAITING',
+                reason: 'PR state unchanged since last ratchet dispatch',
+            },
+        });
+        expect(agentSessionAccessor.findByWorkspaceId).not.toHaveBeenCalled();
+        expect(mockSnapshotBridge.recordReviewCheck).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',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.REVIEW_PENDING,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: 'ci:SUCCESS|changes-requested:1735776000000',
+            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: 'ci:SUCCESS|changes-requested:1735776000000',
+            hasChangesRequested: true,
+            latestReviewActivityAtMs: new Date('2026-01-02T00:00:00Z').getTime(),
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 55,
+            reviewComments: [
+                {
+                    author: 'reviewer',
+                    body: 'Please revise this',
+                    path: 'src/example.ts',
+                    line: 9,
+                    url: 'https://github.com/example/repo/pull/55#discussion_r1',
+                },
+            ],
+        });
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(triggerSpy).not.toHaveBeenCalled();
+        expect(result).toMatchObject({
+            action: {
+                type: 'WAITING',
+                reason: 'PR state unchanged since last ratchet dispatch',
+            },
+        });
+        expect(agentSessionAccessor.findByWorkspaceId).not.toHaveBeenCalled();
+    });
+    it('does not dispatch for CHANGES_REQUESTED when there are no PR review comments', async () => {
+        const workspace = {
+            id: 'ws-review-no-comments',
+            prUrl: 'https://github.com/example/repo/pull/56',
+            prNumber: 56,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.REVIEW_PENDING,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: 'ci:SUCCESS|changes-requested:old',
+            prReviewLastCheckedAt: new Date('2026-01-02T00:00:00Z'),
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: 'ci:SUCCESS|changes-requested:new',
+            hasChangesRequested: true,
+            latestReviewActivityAtMs: new Date('2026-01-03T00:00:00Z').getTime(),
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 56,
+            reviewComments: [],
+        });
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(triggerSpy).not.toHaveBeenCalled();
+        expect(result).toMatchObject({
+            action: {
+                type: 'WAITING',
+                reason: 'No CI failures or PR review comments to address',
+            },
+        });
+    });
+    it('treats closed PR as IDLE and does not dispatch', () => {
+        const state = unsafeCoerce(ratchetService).determineRatchetState({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: '2026-01-02T00:00:00Z',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: null,
+            prState: 'CLOSED',
+            prNumber: 6,
+        });
+        expect(state).toBe(RatchetState.IDLE);
+    });
+    it('handles prompt delivery failure by clearing active session and stopping runner', async () => {
+        const workspace = {
+            id: 'ws-prompt-fail',
+            prUrl: 'https://github.com/example/repo/pull/7',
+            prNumber: 7,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.IDLE,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: null,
+            prReviewLastCheckedAt: null,
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: '2026-01-02T00:00:00Z',
+            hasChangesRequested: true,
+            latestReviewActivityAtMs: new Date('2026-01-02T00:00:00Z').getTime(),
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 7,
+            reviewComments: [
+                {
+                    author: 'reviewer',
+                    body: 'Please fix this',
+                    path: 'src/example.ts',
+                    line: 12,
+                    url: 'https://github.com/example/repo/pull/7#discussion_r1',
+                },
+            ],
+        });
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+            status: 'started',
+            sessionId: 'ratchet-session',
+            promptSent: false,
+        });
+        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
+        vi.mocked(mockSessionBridge.stopSession).mockResolvedValue();
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(result).toMatchObject({
+            action: { type: 'ERROR', error: 'Failed to deliver initial ratchet prompt' },
+        });
+        expect(workspaceAccessor.update).toHaveBeenCalledWith(workspace.id, {
+            ratchetActiveSessionId: null,
+        });
+        expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('ratchet-session');
+    });
+    it('does not dispatch on a clean PR with no new review activity', async () => {
+        const recentCheck = new Date();
+        const workspace = {
+            id: 'ws-clean',
+            prUrl: 'https://github.com/example/repo/pull/8',
+            prNumber: 8,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: '2026-01-01T00:00:00Z',
+            prReviewLastCheckedAt: recentCheck,
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: '2026-01-03T00:00:00Z',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: recentCheck.getTime() - 1000,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 8,
+        });
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        const triggerSpy = vi.spyOn(unsafeCoerce(ratchetService), 'triggerFixer');
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(triggerSpy).not.toHaveBeenCalled();
+        expect(result).toMatchObject({
+            action: {
+                type: 'WAITING',
+                reason: 'PR is clean (green CI and no new review activity)',
+            },
+        });
+    });
+    it('self-heals when review check timestamp is stale with no active session', async () => {
+        const staleCheckedAt = new Date(Date.now() - 15 * 60_000);
+        const workspace = {
+            id: 'ws-stale-check',
+            prUrl: 'https://github.com/example/repo/pull/13',
+            prNumber: 13,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: '2026-01-01T00:00:00Z',
+            prReviewLastCheckedAt: staleCheckedAt,
+        };
+        vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: '2026-01-03T00:00:00Z',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: staleCheckedAt.getTime() - 1000,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 13,
+        });
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+        const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+        expect(result).not.toMatchObject({
+            action: {
+                type: 'WAITING',
+                reason: 'PR is clean (green CI and no new review activity)',
+            },
+        });
+    });
+    it('resets dispatch tracking when ratchet session process is not running', async () => {
+        const workspace = {
+            id: 'ws-stale-active',
+            prUrl: 'https://github.com/example/repo/pull/9',
+            prNumber: 9,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.CI_FAILED,
+            ratchetActiveSessionId: 'ratchet-session',
+            ratchetLastCiRunId: 'previous-snapshot-key',
+            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
+        };
+        vi.mocked(agentSessionAccessor.findById).mockResolvedValue({
+            id: 'ratchet-session',
+            provider: 'CLAUDE',
+            status: SessionStatus.RUNNING,
+        });
+        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(false);
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(mockSnapshotBridge.recordReviewCheck).mockResolvedValue();
+        const action = await unsafeCoerce(ratchetService).getActiveRatchetSession(workspace);
+        expect(action).toBeNull();
+        expect(workspaceAccessor.update).toHaveBeenCalledWith(workspace.id, {
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: null,
+        });
+        expect(mockSnapshotBridge.recordReviewCheck).toHaveBeenCalledWith(workspace.id, null);
+    });
+    it('resets dispatch tracking when ratchet session is not found in database', async () => {
+        const workspace = {
+            id: 'ws-missing-session',
+            prUrl: 'https://github.com/example/repo/pull/12',
+            prNumber: 12,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.CI_FAILED,
+            ratchetActiveSessionId: 'deleted-session',
+            ratchetLastCiRunId: 'previous-snapshot-key',
+            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
+        };
+        vi.mocked(agentSessionAccessor.findById).mockResolvedValue(null);
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        vi.mocked(mockSnapshotBridge.recordReviewCheck).mockResolvedValue();
+        const action = await unsafeCoerce(ratchetService).getActiveRatchetSession(workspace);
+        expect(action).toBeNull();
+        expect(workspaceAccessor.update).toHaveBeenCalledWith(workspace.id, {
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: null,
+        });
+        expect(mockSnapshotBridge.recordReviewCheck).toHaveBeenCalledWith(workspace.id, null);
+    });
+    it('does not reset dispatch tracking when ratchet session completed normally', async () => {
+        const workspace = {
+            id: 'ws-idle-active',
+            prUrl: 'https://github.com/example/repo/pull/11',
+            prNumber: 11,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.CI_FAILED,
+            ratchetActiveSessionId: 'ratchet-session',
+            ratchetLastCiRunId: 'snapshot-key',
+            prReviewLastCheckedAt: new Date('2026-01-01T00:00:00Z'),
+        };
+        vi.mocked(agentSessionAccessor.findById).mockResolvedValue({
+            id: 'ratchet-session',
+            provider: 'CLAUDE',
+            status: SessionStatus.RUNNING,
+        });
+        vi.mocked(mockSessionBridge.isSessionRunning).mockReturnValue(true);
+        vi.mocked(mockSessionBridge.isSessionWorking).mockReturnValue(false);
+        vi.mocked(mockSessionBridge.stopSession).mockResolvedValue();
+        vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+        const action = await unsafeCoerce(ratchetService).getActiveRatchetSession(workspace);
+        expect(action).toBeNull();
+        expect(workspaceAccessor.update).toHaveBeenCalledWith(workspace.id, {
+            ratchetActiveSessionId: null,
+        });
+        expect(mockSessionBridge.stopSession).toHaveBeenCalledWith('ratchet-session');
+        expect(mockSnapshotBridge.recordReviewCheck).not.toHaveBeenCalled();
+    });
+    it('decides to trigger fixer when context is actionable', () => {
+        const decision = unsafeCoerce(ratchetService).decideRatchetAction({
+            workspace: { ratchetEnabled: true },
+            prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.FAILURE },
+            isCleanPrWithNoNewReviewActivity: false,
+            activeRatchetSession: null,
+            hasStateChangedSinceLastDispatch: true,
+            hasOtherActiveSession: false,
+        });
+        expect(decision).toEqual({ type: 'TRIGGER_FIXER' });
+    });
+    it('waits when CI is not in terminal state (PENDING)', () => {
+        const decision = unsafeCoerce(ratchetService).decideRatchetAction({
+            workspace: { ratchetEnabled: true },
+            prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.PENDING },
+            isCleanPrWithNoNewReviewActivity: false,
+            activeRatchetSession: null,
+            hasStateChangedSinceLastDispatch: true,
+            hasOtherActiveSession: false,
+        });
+        expect(decision).toEqual({
+            type: 'RETURN_ACTION',
+            action: { type: 'WAITING', reason: 'Waiting for CI to complete (not in terminal state)' },
+        });
+    });
+    it('waits when CI is not in terminal state (UNKNOWN)', () => {
+        const decision = unsafeCoerce(ratchetService).decideRatchetAction({
+            workspace: { ratchetEnabled: true },
+            prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.UNKNOWN },
+            isCleanPrWithNoNewReviewActivity: false,
+            activeRatchetSession: null,
+            hasStateChangedSinceLastDispatch: true,
+            hasOtherActiveSession: false,
+        });
+        expect(decision).toEqual({
+            type: 'RETURN_ACTION',
+            action: { type: 'WAITING', reason: 'Waiting for CI to complete (not in terminal state)' },
+        });
+    });
+    it('prefers precomputed review-activity diagnostics from decision context', () => {
+        const workspace = {
+            id: 'ws-log-diag',
+            prUrl: 'https://github.com/example/repo/pull/10',
+            prNumber: 10,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: 'prev-snapshot',
+            prReviewLastCheckedAt: null,
+        };
+        const prStateInfo = {
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: 'next-snapshot',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: null,
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 10,
+        };
+        const logContext = unsafeCoerce(ratchetService).buildRatchetingLogContext(workspace, RatchetState.READY, RatchetState.READY, { type: 'WAITING', reason: 'noop' }, prStateInfo, 10, { hasNewReviewActivitySinceLastDispatch: true });
+        expect(logContext.reviewTimestampComparison.hasNewReviewActivitySinceLastDispatch).toBe(true);
+    });
+    it('ignores review activity authored by the authenticated user', () => {
+        const latestActivity = unsafeCoerce(ratchetService).computeLatestReviewActivityAtMs({
+            reviews: [
+                { submittedAt: '2026-01-02T00:00:00Z', author: { login: 'ratchet-bot' } },
+                { submittedAt: '2026-01-01T00:00:00Z', author: { login: 'reviewer' } },
+            ],
+            comments: [{ updatedAt: '2026-01-02T01:00:00Z', author: { login: 'ratchet-bot' } }],
+        }, [{ updatedAt: '2026-01-01T02:00:00Z', author: { login: 'reviewer2' } }], 'ratchet-bot');
+        expect(latestActivity).toBe(new Date('2026-01-01T02:00:00Z').getTime());
+    });
+    describe('determineRatchetState', () => {
+        const callDetermineRatchetState = (pr) => unsafeCoerce(ratchetService).determineRatchetState(pr);
+        it('returns MERGED for merged PR', () => {
+            expect(callDetermineRatchetState({
+                ciStatus: CIStatus.SUCCESS,
+                prState: 'MERGED',
+                hasChangesRequested: false,
+            })).toBe(RatchetState.MERGED);
+        });
+        it('returns IDLE for closed (non-merged) PR', () => {
+            expect(callDetermineRatchetState({
+                ciStatus: CIStatus.SUCCESS,
+                prState: 'CLOSED',
+                hasChangesRequested: false,
+            })).toBe(RatchetState.IDLE);
+        });
+        it('returns CI_RUNNING for PENDING CI on open PR', () => {
+            expect(callDetermineRatchetState({
+                ciStatus: CIStatus.PENDING,
+                prState: 'OPEN',
+                hasChangesRequested: false,
+            })).toBe(RatchetState.CI_RUNNING);
+        });
+        it('returns CI_RUNNING for UNKNOWN CI on open PR', () => {
+            expect(callDetermineRatchetState({
+                ciStatus: CIStatus.UNKNOWN,
+                prState: 'OPEN',
+                hasChangesRequested: false,
+            })).toBe(RatchetState.CI_RUNNING);
+        });
+        it('returns CI_FAILED for FAILURE CI on open PR', () => {
+            expect(callDetermineRatchetState({
+                ciStatus: CIStatus.FAILURE,
+                prState: 'OPEN',
+                hasChangesRequested: false,
+            })).toBe(RatchetState.CI_FAILED);
+        });
+        it('returns REVIEW_PENDING when changes requested on open PR with passing CI', () => {
+            expect(callDetermineRatchetState({
+                ciStatus: CIStatus.SUCCESS,
+                prState: 'OPEN',
+                hasChangesRequested: true,
+            })).toBe(RatchetState.REVIEW_PENDING);
+        });
+        it('returns READY when open PR with passing CI and no changes requested', () => {
+            expect(callDetermineRatchetState({
+                ciStatus: CIStatus.SUCCESS,
+                prState: 'OPEN',
+                hasChangesRequested: false,
+            })).toBe(RatchetState.READY);
+        });
+        it('returns CI_FAILED even when changes are requested if CI is failing', () => {
+            expect(callDetermineRatchetState({
+                ciStatus: CIStatus.FAILURE,
+                prState: 'OPEN',
+                hasChangesRequested: true,
+            })).toBe(RatchetState.CI_FAILED);
+        });
+    });
+    describe('computeDispatchSnapshotKey', () => {
+        const callComputeSnapshotKey = (ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks) => unsafeCoerce(ratchetService).computeDispatchSnapshotKey(ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks);
+        it('includes CI status in key for non-failure states', () => {
+            const key = callComputeSnapshotKey(CIStatus.SUCCESS, false, null, null);
+            expect(key).toContain('ci:SUCCESS');
+            expect(key).toContain('no-changes-requested');
+            expect(key).toContain('none');
+        });
+        it('includes failed check details in key for FAILURE status', () => {
+            const key = callComputeSnapshotKey(CIStatus.FAILURE, false, null, [
+                {
+                    name: 'test',
+                    conclusion: 'FAILURE',
+                    detailsUrl: 'https://github.com/o/r/actions/runs/12345',
+                },
+            ]);
+            expect(key).toContain('ci:FAILURE');
+            expect(key).toContain('test:FAILURE:12345');
+        });
+        it('sorts failed checks for stable key generation', () => {
+            const key = callComputeSnapshotKey(CIStatus.FAILURE, false, null, [
+                {
+                    name: 'ztest',
+                    conclusion: 'FAILURE',
+                    detailsUrl: 'https://github.com/o/r/actions/runs/2',
+                },
+                {
+                    name: 'atest',
+                    conclusion: 'FAILURE',
+                    detailsUrl: 'https://github.com/o/r/actions/runs/1',
+                },
+            ]);
+            expect(key.indexOf('atest')).toBeLessThan(key.indexOf('ztest'));
+        });
+        it('uses unknown for FAILURE with empty check array', () => {
+            const key = callComputeSnapshotKey(CIStatus.FAILURE, false, null, []);
+            expect(key).toContain('ci:FAILURE:unknown');
+        });
+        it('includes review activity timestamp in key', () => {
+            const ts = 1_735_776_000_000;
+            const key = callComputeSnapshotKey(CIStatus.SUCCESS, true, ts, null);
+            expect(key).toContain(`changes-requested:${ts}`);
+        });
+    });
+    describe('computeLatestReviewActivityAtMs edge cases', () => {
+        const callCompute = (prDetails, reviewComments, authenticatedUsername) => unsafeCoerce(ratchetService).computeLatestReviewActivityAtMs(prDetails, reviewComments, authenticatedUsername);
+        it('returns null when there are no reviews or comments', () => {
+            expect(callCompute({ reviews: [], comments: [] }, [], null)).toBeNull();
+        });
+        it('returns null when all activity is from the authenticated user', () => {
+            expect(callCompute({
+                reviews: [{ submittedAt: '2026-01-01T00:00:00Z', author: { login: 'me' } }],
+                comments: [{ updatedAt: '2026-01-02T00:00:00Z', author: { login: 'me' } }],
+            }, [{ updatedAt: '2026-01-03T00:00:00Z', author: { login: 'me' } }], 'me')).toBeNull();
+        });
+        it('does not filter when authenticatedUsername is null', () => {
+            const result = callCompute({
+                reviews: [{ submittedAt: '2026-01-01T00:00:00Z', author: { login: 'bot' } }],
+                comments: [],
+            }, [], null);
+            expect(result).toBe(new Date('2026-01-01T00:00:00Z').getTime());
+        });
+        it('ignores reviews that have null submittedAt', () => {
+            const result = callCompute({
+                reviews: [{ submittedAt: null, author: { login: 'reviewer' } }],
+                comments: [{ updatedAt: '2026-01-02T00:00:00Z', author: { login: 'commenter' } }],
+            }, [], null);
+            expect(result).toBe(new Date('2026-01-02T00:00:00Z').getTime());
+        });
+        it('returns the latest timestamp across all sources', () => {
+            const result = callCompute({
+                reviews: [{ submittedAt: '2026-01-01T00:00:00Z', author: { login: 'a' } }],
+                comments: [{ updatedAt: '2026-01-03T00:00:00Z', author: { login: 'b' } }],
+            }, [{ updatedAt: '2026-01-02T00:00:00Z', author: { login: 'c' } }], null);
+            expect(result).toBe(new Date('2026-01-03T00:00:00Z').getTime());
+        });
+    });
+    describe('processWorkspace error handling', () => {
+        it('returns ERROR action when fetchPRState returns null', async () => {
+            const workspace = {
+                id: 'ws-fetch-err',
+                prUrl: 'https://github.com/example/repo/pull/99',
+                prNumber: 99,
+                ratchetEnabled: true,
+                ratchetState: RatchetState.IDLE,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue(null);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+            expect(result).toMatchObject({
+                action: { type: 'ERROR', error: 'Failed to fetch PR state' },
+                newState: RatchetState.IDLE,
+            });
+        });
+        it('returns WAITING when shutting down', async () => {
+            unsafeCoerce(ratchetService).isShuttingDown = true;
+            const workspace = {
+                id: 'ws-shutdown',
+                prUrl: 'https://github.com/example/repo/pull/1',
+                prNumber: 1,
+                ratchetEnabled: true,
+                ratchetState: RatchetState.CI_FAILED,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+            expect(result).toMatchObject({
+                action: { type: 'WAITING', reason: 'Shutting down' },
+                previousState: RatchetState.CI_FAILED,
+                newState: RatchetState.CI_FAILED,
+            });
+        });
+        it('returns ERROR and preserves state when processWorkspace throws', async () => {
+            const workspace = {
+                id: 'ws-throw',
+                prUrl: 'https://github.com/example/repo/pull/50',
+                prNumber: 50,
+                ratchetEnabled: true,
+                ratchetState: RatchetState.CI_FAILED,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockRejectedValue(new Error('Unexpected explosion'));
+            const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+            expect(result).toMatchObject({
+                action: { type: 'ERROR', error: 'Unexpected explosion' },
+                previousState: RatchetState.CI_FAILED,
+                newState: RatchetState.CI_FAILED,
+            });
+        });
+    });
+    describe('checkAllWorkspaces', () => {
+        it('returns zero counts when shutting down', async () => {
+            unsafeCoerce(ratchetService).isShuttingDown = true;
+            const result = await ratchetService.checkAllWorkspaces();
+            expect(result).toEqual({ checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] });
+        });
+        it('returns zero counts when no workspaces have PRs', async () => {
+            vi.mocked(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue([]);
+            const result = await ratchetService.checkAllWorkspaces();
+            expect(result).toEqual({ checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] });
+        });
+        it('returns an error result when one workspace check times out', async () => {
+            unsafeCoerce(ratchetService).workspaceCheckTimeoutMs = 5;
+            vi.mocked(workspaceAccessor.findWithPRsForRatchet).mockResolvedValue([
+                {
+                    id: 'ws-timeout',
+                    prUrl: 'https://github.com/example/repo/pull/1',
+                    prNumber: 1,
+                    prState: 'OPEN',
+                    prCiStatus: CIStatus.FAILURE,
+                    defaultSessionProvider: 'WORKSPACE_DEFAULT',
+                    ratchetSessionProvider: 'WORKSPACE_DEFAULT',
+                    ratchetEnabled: true,
+                    ratchetState: RatchetState.IDLE,
+                    ratchetActiveSessionId: null,
+                    ratchetLastCiRunId: null,
+                    prReviewLastCheckedAt: null,
+                },
+                {
+                    id: 'ws-fast',
+                    prUrl: 'https://github.com/example/repo/pull/2',
+                    prNumber: 2,
+                    prState: 'OPEN',
+                    prCiStatus: CIStatus.SUCCESS,
+                    defaultSessionProvider: 'WORKSPACE_DEFAULT',
+                    ratchetSessionProvider: 'WORKSPACE_DEFAULT',
+                    ratchetEnabled: true,
+                    ratchetState: RatchetState.CI_RUNNING,
+                    ratchetActiveSessionId: null,
+                    ratchetLastCiRunId: null,
+                    prReviewLastCheckedAt: null,
+                },
+            ]);
+            vi.spyOn(unsafeCoerce(ratchetService), 'processWorkspace').mockImplementation((workspace) => {
+                if (workspace.id === 'ws-timeout') {
+                    return new Promise(() => {
+                    });
+                }
+                return Promise.resolve({
+                    workspaceId: workspace.id,
+                    previousState: RatchetState.CI_RUNNING,
+                    newState: RatchetState.CI_RUNNING,
+                    action: { type: 'WAITING', reason: 'noop' },
+                });
+            });
+            const result = await ratchetService.checkAllWorkspaces();
+            expect(result.checked).toBe(2);
+            expect(result.results).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    workspaceId: 'ws-timeout',
+                    action: expect.objectContaining({
+                        type: 'ERROR',
+                        error: expect.stringContaining('timed out'),
+                    }),
+                }),
+                expect.objectContaining({
+                    workspaceId: 'ws-fast',
+                    action: { type: 'WAITING', reason: 'noop' },
+                }),
+            ]));
+        });
+    });
+    describe('shutdown behavior', () => {
+        it('stops immediately while monitor loop is sleeping', async () => {
+            vi.useFakeTimers();
+            vi.spyOn(ratchetService, 'checkAllWorkspaces').mockResolvedValue({
+                checked: 0,
+                stateChanges: 0,
+                actionsTriggered: 0,
+                results: [],
+            });
+            ratchetService.start();
+            await Promise.resolve();
+            await Promise.resolve();
+            await expect(ratchetService.stop()).resolves.toBeUndefined();
+            vi.useRealTimers();
+        });
+    });
+    describe('checkWorkspaceById', () => {
+        it('returns null when shutting down', async () => {
+            unsafeCoerce(ratchetService).isShuttingDown = true;
+            const result = await ratchetService.checkWorkspaceById('ws-1');
+            expect(result).toBeNull();
+        });
+        it('returns null when workspace not found', async () => {
+            unsafeCoerce(ratchetService).isShuttingDown = false;
+            vi.mocked(workspaceAccessor.findForRatchetById).mockResolvedValue(null);
+            const result = await ratchetService.checkWorkspaceById('ws-nonexistent');
+            expect(result).toBeNull();
+        });
+        it('deduplicates concurrent checks for the same workspace', async () => {
+            unsafeCoerce(ratchetService).isShuttingDown = false;
+            const workspace = {
+                id: 'ws-1',
+                prUrl: 'https://github.com/example/repo/pull/1',
+                prNumber: 1,
+                prState: 'OPEN',
+                prCiStatus: CIStatus.UNKNOWN,
+                defaultSessionProvider: 'WORKSPACE_DEFAULT',
+                ratchetSessionProvider: 'WORKSPACE_DEFAULT',
+                ratchetEnabled: true,
+                ratchetState: RatchetState.IDLE,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            vi.mocked(workspaceAccessor.findForRatchetById).mockResolvedValue(workspace);
+            let releaseCheck;
+            const checkBarrier = new Promise((resolve) => {
+                releaseCheck = () => resolve();
+            });
+            const result = {
+                workspaceId: 'ws-1',
+                previousState: RatchetState.IDLE,
+                newState: RatchetState.IDLE,
+                action: { type: 'WAITING', reason: 'noop' },
+            };
+            const processWorkspaceSpy = vi
+                .spyOn(unsafeCoerce(ratchetService), 'processWorkspace')
+                .mockImplementation(async () => {
+                await checkBarrier;
+                return result;
+            });
+            const first = ratchetService.checkWorkspaceById('ws-1');
+            const second = ratchetService.checkWorkspaceById('ws-1');
+            await Promise.resolve();
+            expect(processWorkspaceSpy).toHaveBeenCalledTimes(1);
+            releaseCheck();
+            const [firstResult, secondResult] = await Promise.all([first, second]);
+            expect(firstResult).toEqual(result);
+            expect(secondResult).toEqual(result);
+            expect(processWorkspaceSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('decideRatchetAction edge cases', () => {
+        const callDecide = (context) => unsafeCoerce(ratchetService).decideRatchetAction(context);
+        it('returns COMPLETED for merged PR', () => {
+            expect(callDecide({
+                workspace: { ratchetEnabled: true },
+                prStateInfo: { prState: 'MERGED', ciStatus: CIStatus.SUCCESS },
+                isCleanPrWithNoNewReviewActivity: false,
+                activeRatchetSession: null,
+                hasStateChangedSinceLastDispatch: true,
+                hasOtherActiveSession: false,
+            })).toEqual({ type: 'RETURN_ACTION', action: { type: 'COMPLETED' } });
+        });
+        it('returns WAITING for non-open PR', () => {
+            const result = callDecide({
+                workspace: { ratchetEnabled: true },
+                prStateInfo: { prState: 'CLOSED', ciStatus: CIStatus.SUCCESS },
+                isCleanPrWithNoNewReviewActivity: false,
+                activeRatchetSession: null,
+                hasStateChangedSinceLastDispatch: true,
+                hasOtherActiveSession: false,
+            });
+            expect(result.action?.reason).toBe('PR is not open');
+        });
+        it('returns active session when one exists', () => {
+            const activeSession = { type: 'FIXER_ACTIVE', sessionId: 's-1' };
+            const result = callDecide({
+                workspace: { ratchetEnabled: true },
+                prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.FAILURE },
+                isCleanPrWithNoNewReviewActivity: false,
+                activeRatchetSession: activeSession,
+                hasStateChangedSinceLastDispatch: true,
+                hasOtherActiveSession: false,
+            });
+            expect(result.action).toEqual(activeSession);
+        });
+        it('returns WAITING when other active session blocks dispatch', () => {
+            const result = callDecide({
+                workspace: { ratchetEnabled: true },
+                prStateInfo: { prState: 'OPEN', ciStatus: CIStatus.FAILURE },
+                isCleanPrWithNoNewReviewActivity: false,
+                activeRatchetSession: null,
+                hasStateChangedSinceLastDispatch: true,
+                hasOtherActiveSession: true,
+            });
+            expect(result.action?.reason).toBe('Workspace is not idle (active session)');
+        });
+        it('returns WAITING when there are no CI failures or PR review comments', () => {
+            const result = callDecide({
+                workspace: { ratchetEnabled: true },
+                prStateInfo: {
+                    prState: 'OPEN',
+                    ciStatus: CIStatus.SUCCESS,
+                    reviewComments: [],
+                },
+                isCleanPrWithNoNewReviewActivity: false,
+                activeRatchetSession: null,
+                hasStateChangedSinceLastDispatch: true,
+                hasOtherActiveSession: false,
+            });
+            expect(result.action?.reason).toBe('No CI failures or PR review comments to address');
+        });
+    });
+    describe('getActiveRatchetSession edge cases', () => {
+        const callGetActiveRatchetSession = (workspace) => unsafeCoerce(ratchetService).getActiveRatchetSession(workspace);
+        it('returns null when ratchetActiveSessionId is null', async () => {
+            const result = await callGetActiveRatchetSession({
+                id: 'ws-1',
+                ratchetActiveSessionId: null,
+            });
+            expect(result).toBeNull();
+        });
+        it('returns null and resets dispatch tracking when session DB record is missing', async () => {
+            vi.mocked(agentSessionAccessor.findById).mockResolvedValue(null);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(mockSnapshotBridge.recordReviewCheck).mockResolvedValue();
+            const result = await callGetActiveRatchetSession({
+                id: 'ws-2',
+                ratchetActiveSessionId: 'gone-session',
+            });
+            expect(result).toBeNull();
+            expect(workspaceAccessor.update).toHaveBeenCalledWith('ws-2', {
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+            });
+            expect(mockSnapshotBridge.recordReviewCheck).toHaveBeenCalledWith('ws-2', null);
+        });
+        it('returns null and resets dispatch tracking when session is not RUNNING', async () => {
+            vi.mocked(agentSessionAccessor.findById).mockResolvedValue({
+                id: 'completed-session',
+                provider: 'CLAUDE',
+                status: SessionStatus.IDLE,
+            });
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(mockSnapshotBridge.recordReviewCheck).mockResolvedValue();
+            const result = await callGetActiveRatchetSession({
+                id: 'ws-3',
+                ratchetActiveSessionId: 'completed-session',
+            });
+            expect(result).toBeNull();
+            expect(workspaceAccessor.update).toHaveBeenCalledWith('ws-3', {
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+            });
+            expect(mockSnapshotBridge.recordReviewCheck).toHaveBeenCalledWith('ws-3', null);
+        });
+    });
+    describe('review comment polling', () => {
+        const cleanWorkspace = {
+            id: 'ws-poll',
+            prUrl: 'https://github.com/example/repo/pull/100',
+            prNumber: 100,
+            prState: 'OPEN',
+            prCiStatus: CIStatus.UNKNOWN,
+            ratchetEnabled: true,
+            ratchetState: RatchetState.READY,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: 'old-snapshot',
+            prReviewLastCheckedAt: new Date(),
+        };
+        const cleanPrState = {
+            ciStatus: CIStatus.SUCCESS,
+            snapshotKey: 'new-snapshot',
+            hasChangesRequested: false,
+            latestReviewActivityAtMs: new Date('2026-01-01T00:00:00Z').getTime(),
+            statusCheckRollup: null,
+            prState: 'OPEN',
+            prNumber: 100,
+            reviewComments: [],
+        };
+        const prStateWithComments = {
+            ...cleanPrState,
+            snapshotKey: 'snapshot-with-comments',
+            hasChangesRequested: true,
+            latestReviewActivityAtMs: new Date('2026-01-03T00:00:00Z').getTime(),
+            reviewComments: [
+                {
+                    author: 'reviewer',
+                    body: 'Please update this line',
+                    path: 'src/file.ts',
+                    line: 21,
+                    url: 'https://github.com/example/repo/pull/100#discussion_r2',
+                },
+            ],
+        };
+        const getTrackers = () => unsafeCoerce(ratchetService).reviewPollTrackers;
+        const callProcessWorkspace = (workspace) => unsafeCoerce(ratchetService).processWorkspace(workspace);
+        it('creates tracker when PR is first seen as clean with state change', async () => {
+            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue(cleanPrState);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            const result = await callProcessWorkspace(cleanWorkspace);
+            expect(result.action.type).toBe('WAITING');
+            expect(getTrackers().has('ws-poll')).toBe(true);
+            expect(getTrackers().get('ws-poll')?.snapshotKey).toBe('new-snapshot');
+            expect(getTrackers().get('ws-poll')?.pollCount).toBe(0);
+        });
+        it('creates tracker even when state has not changed (continuous polling)', async () => {
+            const workspace = { ...cleanWorkspace, ratchetLastCiRunId: 'new-snapshot' };
+            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue(cleanPrState);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            await callProcessWorkspace(workspace);
+            expect(getTrackers().has('ws-poll')).toBe(true);
+            expect(getTrackers().get('ws-poll')?.pollCount).toBe(0);
+        });
+        it('skips re-poll when not enough time has elapsed', async () => {
+            getTrackers().set('ws-poll', {
+                snapshotKey: 'new-snapshot',
+                lastPolledAt: Date.now(),
+                pollCount: 0,
+            });
+            const fetchSpy = vi
+                .spyOn(unsafeCoerce(ratchetService), 'fetchPRState')
+                .mockResolvedValue(cleanPrState);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            await callProcessWorkspace(cleanWorkspace);
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+            expect(getTrackers().get('ws-poll')?.pollCount).toBe(0);
+        });
+        it('re-polls and finds comments when time has elapsed', async () => {
+            getTrackers().set('ws-poll', {
+                snapshotKey: 'new-snapshot',
+                lastPolledAt: Date.now() - 3 * 60_000,
+                pollCount: 0,
+            });
+            const fetchSpy = vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState');
+            fetchSpy.mockResolvedValueOnce(cleanPrState);
+            fetchSpy.mockResolvedValueOnce(prStateWithComments);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+                status: 'started',
+                sessionId: 'ratchet-poll-session',
+                promptSent: true,
+            });
+            const result = await callProcessWorkspace(cleanWorkspace);
+            expect(fetchSpy).toHaveBeenCalledTimes(2);
+            expect(result.action.type).toBe('TRIGGERED_FIXER');
+            expect(getTrackers().has('ws-poll')).toBe(false);
+        });
+        it('increments pollCount when re-poll still finds clean PR', async () => {
+            getTrackers().set('ws-poll', {
+                snapshotKey: 'new-snapshot',
+                lastPolledAt: Date.now() - 3 * 60_000,
+                pollCount: 0,
+            });
+            const fetchSpy = vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState');
+            fetchSpy.mockResolvedValue(cleanPrState);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            await callProcessWorkspace(cleanWorkspace);
+            expect(fetchSpy).toHaveBeenCalledTimes(2);
+            expect(getTrackers().get('ws-poll')?.pollCount).toBe(1);
+        });
+        it('continues polling after many cycles without exhausting', async () => {
+            getTrackers().set('ws-poll', {
+                snapshotKey: 'new-snapshot',
+                lastPolledAt: Date.now() - 3 * 60_000,
+                pollCount: 50,
+            });
+            const fetchSpy = vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState');
+            fetchSpy.mockResolvedValue(cleanPrState);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            await callProcessWorkspace(cleanWorkspace);
+            expect(fetchSpy).toHaveBeenCalledTimes(2);
+            expect(getTrackers().get('ws-poll')?.pollCount).toBe(51);
+        });
+        it('resets tracker when snapshotKey changes', async () => {
+            getTrackers().set('ws-poll', {
+                snapshotKey: 'different-snapshot',
+                lastPolledAt: Date.now() - 10 * 60_000,
+                pollCount: 3,
+            });
+            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue(cleanPrState);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            await callProcessWorkspace(cleanWorkspace);
+            const tracker = getTrackers().get('ws-poll');
+            expect(tracker?.snapshotKey).toBe('new-snapshot');
+            expect(tracker?.pollCount).toBe(0);
+        });
+        it('cleans up tracker when decision is not clean PR', async () => {
+            getTrackers().set('ws-poll', {
+                snapshotKey: 'new-snapshot',
+                lastPolledAt: Date.now(),
+                pollCount: 1,
+            });
+            const failedPrState = {
+                ...cleanPrState,
+                ciStatus: CIStatus.FAILURE,
+                snapshotKey: 'failed-snapshot',
+            };
+            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue(failedPrState);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+                status: 'started',
+                sessionId: 'fixer',
+                promptSent: true,
+            });
+            await callProcessWorkspace(cleanWorkspace);
+            expect(getTrackers().has('ws-poll')).toBe(false);
+        });
+        it('continues to next cycle when fetchPRState returns null during re-poll', async () => {
+            getTrackers().set('ws-poll', {
+                snapshotKey: 'new-snapshot',
+                lastPolledAt: Date.now() - 3 * 60_000,
+                pollCount: 0,
+            });
+            const fetchSpy = vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState');
+            fetchSpy.mockResolvedValueOnce(cleanPrState);
+            fetchSpy.mockResolvedValueOnce(null);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            const result = await callProcessWorkspace(cleanWorkspace);
+            expect(result.action.type).toBe('WAITING');
+            expect(getTrackers().get('ws-poll')?.pollCount).toBe(0);
+        });
+        it('skips re-poll when shutting down', async () => {
+            getTrackers().set('ws-poll', {
+                snapshotKey: 'new-snapshot',
+                lastPolledAt: Date.now() - 3 * 60_000,
+                pollCount: 0,
+            });
+            unsafeCoerce(ratchetService).isShuttingDown = false;
+            const fetchSpy = vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState');
+            fetchSpy.mockResolvedValueOnce(cleanPrState);
+            fetchSpy.mockResolvedValueOnce(cleanPrState);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            const handlePollSpy = vi.spyOn(unsafeCoerce(ratchetService), 'handleReviewCommentPoll');
+            handlePollSpy.mockImplementationOnce(async (...args) => {
+                unsafeCoerce(ratchetService).isShuttingDown = true;
+                handlePollSpy.mockRestore();
+                return await unsafeCoerce(ratchetService).handleReviewCommentPoll(...args);
+            });
+            const result = await callProcessWorkspace(cleanWorkspace);
+            expect(result.action.type).toBe('WAITING');
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('triggerFixer error handling', () => {
+        it('handles acquireAndDispatch throwing an error', async () => {
+            const workspace = {
+                id: 'ws-trigger-fail',
+                prUrl: 'https://github.com/example/repo/pull/20',
+                prNumber: 20,
+                ratchetEnabled: true,
+                ratchetState: RatchetState.CI_FAILED,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            vi.mocked(fixerSessionService.acquireAndDispatch).mockRejectedValue(new Error('Session creation failed'));
+            const result = await unsafeCoerce(ratchetService).triggerFixer(workspace, {
+                ciStatus: CIStatus.FAILURE,
+                prNumber: 20,
+            });
+            expect(result).toMatchObject({
+                type: 'ERROR',
+                error: 'Session creation failed',
+            });
+        });
+        it('handles already_active result from acquireAndDispatch', async () => {
+            const workspace = {
+                id: 'ws-already-active',
+                prUrl: 'https://github.com/example/repo/pull/21',
+                prNumber: 21,
+                ratchetEnabled: true,
+                ratchetState: RatchetState.CI_FAILED,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+                status: 'already_active',
+                sessionId: 'existing-session',
+            });
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            const result = await unsafeCoerce(ratchetService).triggerFixer(workspace, {
+                ciStatus: CIStatus.FAILURE,
+                prNumber: 21,
+            });
+            expect(result).toMatchObject({
+                type: 'FIXER_ACTIVE',
+                sessionId: 'existing-session',
+            });
+        });
+        it('handles skipped result from acquireAndDispatch', async () => {
+            const workspace = {
+                id: 'ws-skipped',
+                prUrl: 'https://github.com/example/repo/pull/22',
+                prNumber: 22,
+                ratchetEnabled: true,
+                ratchetState: RatchetState.CI_FAILED,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+                status: 'skipped',
+                reason: 'No worktree path',
+            });
+            const result = await unsafeCoerce(ratchetService).triggerFixer(workspace, {
+                ciStatus: CIStatus.FAILURE,
+                prNumber: 22,
+            });
+            expect(result).toMatchObject({
+                type: 'ERROR',
+                error: 'No worktree path',
+            });
+        });
+    });
+    describe('workspace ratchet toggle events', () => {
+        afterEach(() => {
+            ratchetService.removeAllListeners();
+        });
+        it('emits ratchet_toggled when enabling workspace ratcheting', async () => {
+            vi.mocked(workspaceAccessor.findById).mockResolvedValue({
+                id: 'ws-enable',
+                ratchetState: RatchetState.CI_FAILED,
+                ratchetActiveSessionId: null,
+            });
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            const toggledEvents = [];
+            const stateEvents = [];
+            ratchetService.on(RATCHET_TOGGLED, (event) => {
+                toggledEvents.push(event);
+            });
+            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
+                stateEvents.push(event);
+            });
+            await ratchetService.setWorkspaceRatcheting('ws-enable', true);
+            expect(workspaceAccessor.update).toHaveBeenCalledWith('ws-enable', { ratchetEnabled: true });
+            expect(toggledEvents).toEqual([
+                {
+                    workspaceId: 'ws-enable',
+                    enabled: true,
+                    ratchetState: RatchetState.CI_FAILED,
+                },
+            ]);
+            expect(stateEvents).toHaveLength(0);
+        });
+        it('emits ratchet_toggled and ratchet_state_changed when disabling non-idle workspace', async () => {
+            vi.mocked(workspaceAccessor.findById).mockResolvedValue({
+                id: 'ws-disable',
+                ratchetState: RatchetState.CI_RUNNING,
+                ratchetActiveSessionId: null,
+            });
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            const toggledEvents = [];
+            const stateEvents = [];
+            ratchetService.on(RATCHET_TOGGLED, (event) => {
+                toggledEvents.push(event);
+            });
+            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
+                stateEvents.push(event);
+            });
+            await ratchetService.setWorkspaceRatcheting('ws-disable', false);
+            expect(workspaceAccessor.update).toHaveBeenCalledWith('ws-disable', {
+                ratchetEnabled: false,
+                ratchetState: RatchetState.IDLE,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+            });
+            expect(stateEvents).toEqual([
+                {
+                    workspaceId: 'ws-disable',
+                    fromState: RatchetState.CI_RUNNING,
+                    toState: RatchetState.IDLE,
+                },
+            ]);
+            expect(toggledEvents).toEqual([
+                {
+                    workspaceId: 'ws-disable',
+                    enabled: false,
+                    ratchetState: RatchetState.IDLE,
+                },
+            ]);
+        });
+    });
+    describe('event emission', () => {
+        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,
+            };
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            const events = [];
+            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
+                events.push(event);
+            });
+            await unsafeCoerce(ratchetService).processWorkspace(workspace);
+            expect(events).toHaveLength(1);
+            expect(events[0]).toEqual({
+                workspaceId: 'ws-disabled-change',
+                fromState: RatchetState.CI_FAILED,
+                toState: RatchetState.IDLE,
+            });
+        });
+        it('does NOT emit when disabled workspace state is already IDLE', async () => {
+            const workspace = {
+                id: 'ws-disabled-idle',
+                prUrl: 'https://github.com/example/repo/pull/31',
+                prNumber: 31,
+                ratchetEnabled: false,
+                ratchetState: RatchetState.IDLE,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            const events = [];
+            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
+                events.push(event);
+            });
+            await unsafeCoerce(ratchetService).processWorkspace(workspace);
+            expect(events).toHaveLength(0);
+        });
+        it('emits ratchet_state_changed on main path when state changes', async () => {
+            const workspace = {
+                id: 'ws-state-change',
+                prUrl: 'https://github.com/example/repo/pull/32',
+                prNumber: 32,
+                ratchetEnabled: true,
+                ratchetState: RatchetState.IDLE,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+                ciStatus: CIStatus.FAILURE,
+                snapshotKey: 'new-snapshot-key',
+                hasChangesRequested: false,
+                latestReviewActivityAtMs: null,
+                statusCheckRollup: null,
+                prState: 'OPEN',
+                prNumber: 32,
+            });
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+                status: 'started',
+                sessionId: 'ratchet-session-32',
+                promptSent: true,
+            });
+            const events = [];
+            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
+                events.push(event);
+            });
+            await unsafeCoerce(ratchetService).processWorkspace(workspace);
+            expect(events).toHaveLength(1);
+            expect(events[0]).toEqual({
+                workspaceId: 'ws-state-change',
+                fromState: RatchetState.IDLE,
+                toState: RatchetState.CI_FAILED,
+                prCiStatus: CIStatus.FAILURE,
+            });
+        });
+        it('does NOT emit when main path state unchanged', async () => {
+            const workspace = {
+                id: 'ws-no-change',
+                prUrl: 'https://github.com/example/repo/pull/33',
+                prNumber: 33,
+                ratchetEnabled: true,
+                ratchetState: RatchetState.CI_FAILED,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue({
+                ciStatus: CIStatus.FAILURE,
+                snapshotKey: 'new-snapshot-key',
+                hasChangesRequested: false,
+                latestReviewActivityAtMs: null,
+                statusCheckRollup: null,
+                prState: 'OPEN',
+                prNumber: 33,
+            });
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            vi.mocked(agentSessionAccessor.findByWorkspaceId).mockResolvedValue([]);
+            vi.mocked(fixerSessionService.acquireAndDispatch).mockResolvedValue({
+                status: 'started',
+                sessionId: 'ratchet-session-33',
+                promptSent: true,
+            });
+            const events = [];
+            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
+                events.push(event);
+            });
+            await unsafeCoerce(ratchetService).processWorkspace(workspace);
+            expect(events).toHaveLength(0);
+        });
+        it('does NOT emit on error path', async () => {
+            const workspace = {
+                id: 'ws-error',
+                prUrl: 'https://github.com/example/repo/pull/34',
+                prNumber: 34,
+                ratchetEnabled: true,
+                ratchetState: RatchetState.CI_FAILED,
+                ratchetActiveSessionId: null,
+                ratchetLastCiRunId: null,
+                prReviewLastCheckedAt: null,
+            };
+            vi.spyOn(unsafeCoerce(ratchetService), 'fetchPRState').mockResolvedValue(null);
+            vi.mocked(workspaceAccessor.update).mockResolvedValue({});
+            const events = [];
+            ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
+                events.push(event);
+            });
+            const result = await unsafeCoerce(ratchetService).processWorkspace(workspace);
+            expect(result).toMatchObject({
+                action: { type: 'ERROR' },
+            });
+            expect(events).toHaveLength(0);
+        });
+    });
+});
+//# sourceMappingURL=ratchet.service.test.js.map