factory-factory 0.4.8 → 0.4.10

package/dist/src/backend/services/github/service/pr-snapshot.service.test.js

@@ -1,641 +1,107 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-function deferred() {
-    let resolve;
-    const promise = new Promise((promiseResolve) => {
-        resolve = promiseResolve;
-    });
-    return { promise, resolve };
-}
-const mockFindById = vi.fn();
-const mockUpdate = vi.fn();
-const mockApplyPrSnapshotWithDispatchReset = vi.fn();
-const mockApplyPrObservationWithDispatchReset = vi.fn();
-const mockAttachDiscoveredPRIfClaimMatches = vi.fn();
-const mockUpdatePRSnapshotIfUrlMatches = vi.fn();
-const mockFetchAndComputePRState = vi.fn();
-vi.mock('@/backend/services/workspace', () => ({
-    workspaceDataService: {
-        findById: (...args) => mockFindById(...args),
-    },
-    workspacePrSnapshotService: {
-        record: (...args) => mockUpdate(...args),
-        applyPrSnapshotWithDispatchReset: (...args) => mockApplyPrSnapshotWithDispatchReset(...args),
-        applyPrObservationWithDispatchReset: (...args) => mockApplyPrObservationWithDispatchReset(...args),
-        attachDiscoveredPRIfClaimMatches: (...args) => mockAttachDiscoveredPRIfClaimMatches(...args),
-        updatePRSnapshotIfUrlMatches: (...args) => mockUpdatePRSnapshotIfUrlMatches(...args),
-    },
-}));
-vi.mock('./github-cli.service', () => ({
-    githubCLIService: {
-        fetchAndComputePRState: (...args) => mockFetchAndComputePRState(...args),
-    },
-}));
-vi.mock('@/backend/services/logger.service', () => ({
-    createLogger: () => ({
-        info: vi.fn(),
-        debug: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-    }),
-}));
-import { PR_SNAPSHOT_UPDATED, PR_URL_ATTACHED, prSnapshotService, } from './pr-snapshot.service.js';
-describe('PRSnapshotService', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockApplyPrSnapshotWithDispatchReset.mockResolvedValue({
-            applied: true,
-            dispatchReset: false,
-        });
-        mockApplyPrObservationWithDispatchReset.mockResolvedValue({
-            applied: true,
-            dispatchReset: false,
-        });
-        mockUpdatePRSnapshotIfUrlMatches.mockResolvedValue(true);
-        prSnapshotService.configure({
-            workspace: {
-                findPRContext: (...args) => mockFindById(...args),
-                recordSnapshot: (...args) => mockUpdate(...args),
-                applyPrSnapshotWithDispatchReset: (...args) => mockApplyPrSnapshotWithDispatchReset(...args),
-                applyPrObservationWithDispatchReset: (...args) => mockApplyPrObservationWithDispatchReset(...args),
-                attachDiscoveredPRIfClaimMatches: (...args) => mockAttachDiscoveredPRIfClaimMatches(...args),
-                updatePRSnapshotIfUrlMatches: (...args) => mockUpdatePRSnapshotIfUrlMatches(...args),
-            },
-        });
-    });
-    describe('attachAndRefreshPR', () => {
-        it('returns workspace_not_found when workspace does not exist', async () => {
-            mockFindById.mockResolvedValue(null);
-            const listener = vi.fn();
-            prSnapshotService.on(PR_URL_ATTACHED, listener);
-            const result = await prSnapshotService.attachAndRefreshPR('w1', 'https://github.com/org/repo/pull/1');
-            prSnapshotService.off(PR_URL_ATTACHED, listener);
-            expect(result).toEqual({ success: false, reason: 'workspace_not_found' });
-            expect(mockUpdate).not.toHaveBeenCalled();
-            expect(listener).not.toHaveBeenCalled();
-        });
-        it('publishes the attached PR URL even when snapshot fetch fails', async () => {
-            mockFindById.mockResolvedValue({ id: 'w1', prUrl: null });
-            mockFetchAndComputePRState.mockResolvedValue(null);
-            const listener = vi.fn();
-            prSnapshotService.on(PR_URL_ATTACHED, listener);
-            const result = await prSnapshotService.attachAndRefreshPR('w1', 'https://github.com/org/repo/pull/1');
-            prSnapshotService.off(PR_URL_ATTACHED, listener);
-            expect(result).toEqual({ success: false, reason: 'fetch_failed' });
-            expect(mockUpdate).toHaveBeenCalledWith('w1', {
-                prUrl: 'https://github.com/org/repo/pull/1',
-                prUpdatedAt: expect.any(Date),
-            });
-            expect(listener).toHaveBeenCalledOnce();
-            expect(listener).toHaveBeenCalledWith({
-                workspaceId: 'w1',
-                prUrl: 'https://github.com/org/repo/pull/1',
-            });
-        });
-        it('attaches PR URL and persists the full snapshot', async () => {
-            mockFindById.mockResolvedValue({ id: 'w1', prUrl: null });
-            mockFetchAndComputePRState.mockResolvedValue({
-                prNumber: 123,
-                prState: 'OPEN',
-                prReviewState: 'APPROVED',
-                prCiStatus: 'SUCCESS',
-            });
-            const result = await prSnapshotService.attachAndRefreshPR('w1', 'https://github.com/org/repo/pull/123');
-            expect(result).toEqual({
-                success: true,
-                snapshot: {
-                    prNumber: 123,
-                    prState: 'OPEN',
-                    prReviewState: 'APPROVED',
-                    prCiStatus: 'SUCCESS',
-                },
-            });
-            expect(mockApplyPrSnapshotWithDispatchReset).toHaveBeenCalledWith('w1', {
-                prNumber: 123,
-                prState: 'OPEN',
-                prReviewState: 'APPROVED',
-                prCiStatus: 'SUCCESS',
-                prUrl: 'https://github.com/org/repo/pull/123',
-                prUpdatedAt: expect.any(Date),
-            });
-        });
-        it('handles errors gracefully', async () => {
-            mockFindById.mockRejectedValue(new Error('Database error'));
-            const result = await prSnapshotService.attachAndRefreshPR('w1', 'https://github.com/org/repo/pull/1');
-            expect(result).toEqual({ success: false, reason: 'error' });
-        });
+import { beforeEach, expect, it, vi } from 'vitest';
+import { PR_URL_ATTACHED, prSnapshotService } from './pr-snapshot.service.js';
+const url = 'https://github.com/org/repo/pull/1';
+const row = {
+    id: 'p',
+    workspaceId: 'w',
+    url,
+    revision: 0,
+    number: 1,
+    state: 'OPEN',
+    reviewState: null,
+    ciStatus: 'PENDING',
+};
+const bridge = {
+    listPRs: vi.fn(),
+    findPR: vi.fn(),
+    attachPR: vi.fn(),
+    detachPR: vi.fn(),
+    attachDiscoveredPRsIfClaimMatches: vi.fn(),
+    findPRContext: vi.fn(),
+    recordSnapshot: vi.fn(),
+    applyPrSnapshotWithDispatchReset: vi.fn(),
+    applyPrObservationWithDispatchReset: vi.fn(),
+    attachDiscoveredPRIfClaimMatches: vi.fn(),
+    updatePRSnapshotIfUrlMatches: vi.fn(),
+};
+const observe = vi.fn();
+beforeEach(() => {
+    vi.clearAllMocks();
+    prSnapshotService.removeAllListeners();
+    prSnapshotService.configure({ workspace: bridge, observe });
+    bridge.findPRContext.mockResolvedValue({ branchName: 'branch', prUrl: url });
+    bridge.findPR.mockResolvedValue(row);
+    bridge.listPRs.mockResolvedValue([row]);
+    bridge.attachPR.mockResolvedValue({ prId: 'p', created: true, reattached: false });
+    observe.mockResolvedValue(true);
+});
+it('rejects attachment for a missing workspace', async () => {
+    bridge.findPRContext.mockResolvedValue(null);
+    expect(await prSnapshotService.attachAndRefreshPR('w', url)).toEqual({
+        success: false,
+        reason: 'workspace_not_found',
     });
-    describe('attachDiscoveredPRAndRefresh', () => {
-        const claim = {
-            branchName: 'feature/pr-discovery',
-            checkedAt: new Date('2026-07-17T12:00:00.000Z'),
-            retryCount: 2,
-            nextCheckAt: new Date('2026-07-17T12:06:00.000Z'),
-        };
-        it('does not attach or fetch when activity invalidated the discovery claim', async () => {
-            mockAttachDiscoveredPRIfClaimMatches.mockResolvedValue(false);
-            const listener = vi.fn();
-            prSnapshotService.on(PR_URL_ATTACHED, listener);
-            await expect(prSnapshotService.attachDiscoveredPRAndRefresh('w1', 'https://github.com/org/repo/pull/1', claim)).resolves.toEqual({ success: false, reason: 'claim_stale' });
-            prSnapshotService.off(PR_URL_ATTACHED, listener);
-            expect(mockAttachDiscoveredPRIfClaimMatches).toHaveBeenCalledWith('w1', 'https://github.com/org/repo/pull/1', claim, expect.any(Date));
-            expect(mockFetchAndComputePRState).not.toHaveBeenCalled();
-            expect(mockUpdate).not.toHaveBeenCalled();
-            expect(listener).not.toHaveBeenCalled();
-        });
-        it('refreshes the snapshot without correcting a newer branch after guarded attachment', async () => {
-            mockAttachDiscoveredPRIfClaimMatches.mockResolvedValue(true);
-            mockFetchAndComputePRState.mockResolvedValue({
-                prNumber: 123,
-                prState: 'OPEN',
-                prReviewState: 'APPROVED',
-                prCiStatus: 'SUCCESS',
-                headRefName: 'feature/pr-discovery',
-            });
-            await expect(prSnapshotService.attachDiscoveredPRAndRefresh('w1', 'https://github.com/org/repo/pull/123', claim)).resolves.toEqual({
-                success: true,
-                snapshot: {
-                    prNumber: 123,
-                    prState: 'OPEN',
-                    prReviewState: 'APPROVED',
-                    prCiStatus: 'SUCCESS',
-                },
-            });
-            expect(mockUpdatePRSnapshotIfUrlMatches).toHaveBeenCalledWith('w1', 'https://github.com/org/repo/pull/123', {
-                prNumber: 123,
-                prState: 'OPEN',
-                prReviewState: 'APPROVED',
-                prCiStatus: 'SUCCESS',
-            }, expect.any(Date));
-            expect(mockUpdate).not.toHaveBeenCalled();
-        });
-        it('drops a fetched snapshot when the attached PR URL changed during the fetch', async () => {
-            mockAttachDiscoveredPRIfClaimMatches.mockResolvedValue(true);
-            mockFetchAndComputePRState.mockResolvedValue({
-                prNumber: 123,
-                prState: 'OPEN',
-                prReviewState: 'APPROVED',
-                prCiStatus: 'SUCCESS',
-                headRefName: 'feature/pr-discovery',
-            });
-            mockUpdatePRSnapshotIfUrlMatches.mockResolvedValue(false);
-            const listener = vi.fn();
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, listener);
-            await expect(prSnapshotService.attachDiscoveredPRAndRefresh('w1', 'https://github.com/org/repo/pull/123', claim)).resolves.toEqual({ success: false, reason: 'claim_stale' });
-            expect(mockUpdatePRSnapshotIfUrlMatches).toHaveBeenCalledWith('w1', 'https://github.com/org/repo/pull/123', {
-                prNumber: 123,
-                prState: 'OPEN',
-                prReviewState: 'APPROVED',
-                prCiStatus: 'SUCCESS',
-            }, expect.any(Date));
-            expect(mockUpdate).not.toHaveBeenCalled();
-            expect(listener).not.toHaveBeenCalled();
-            prSnapshotService.off(PR_SNAPSHOT_UPDATED, listener);
-        });
-        it('keeps the guarded PR attachment when snapshot fetch fails', async () => {
-            mockAttachDiscoveredPRIfClaimMatches.mockResolvedValue(true);
-            mockFetchAndComputePRState.mockResolvedValue(null);
-            const listener = vi.fn();
-            prSnapshotService.on(PR_URL_ATTACHED, listener);
-            await expect(prSnapshotService.attachDiscoveredPRAndRefresh('w1', 'https://github.com/org/repo/pull/1', claim)).resolves.toEqual({ success: false, reason: 'fetch_failed' });
-            prSnapshotService.off(PR_URL_ATTACHED, listener);
-            expect(listener).toHaveBeenCalledOnce();
-            expect(listener).toHaveBeenCalledWith({
-                workspaceId: 'w1',
-                prUrl: 'https://github.com/org/repo/pull/1',
-            });
-        });
+    expect(bridge.attachPR).not.toHaveBeenCalled();
+});
+it('keeps an attachment visible when the subsequent observation fails', async () => {
+    observe.mockResolvedValue(false);
+    const listener = vi.fn();
+    prSnapshotService.on(PR_URL_ATTACHED, listener);
+    expect(await prSnapshotService.attachAndRefreshPR('w', url)).toMatchObject({
+        success: false,
+        prId: 'p',
     });
-    describe('refreshWorkspace', () => {
-        it('returns workspace_not_found when workspace does not exist', async () => {
-            mockFindById.mockResolvedValue(null);
-            const result = await prSnapshotService.refreshWorkspace('w1');
-            expect(result).toEqual({ success: false, reason: 'workspace_not_found' });
-        });
-        it('returns no_pr_url when workspace has no PR URL', async () => {
-            mockFindById.mockResolvedValue({ id: 'w1', prUrl: null });
-            const result = await prSnapshotService.refreshWorkspace('w1');
-            expect(result).toEqual({ success: false, reason: 'no_pr_url' });
-        });
-        it('returns fetch_failed when GitHub snapshot is unavailable', async () => {
-            mockFindById.mockResolvedValue({ id: 'w1', prUrl: 'https://github.com/org/repo/pull/1' });
-            mockFetchAndComputePRState.mockResolvedValue(null);
-            const result = await prSnapshotService.refreshWorkspace('w1');
-            expect(result).toEqual({ success: false, reason: 'fetch_failed' });
-        });
-        it('persists the PR snapshot', async () => {
-            mockFetchAndComputePRState.mockResolvedValue({
-                prNumber: 123,
-                prState: 'OPEN',
-                prReviewState: 'APPROVED',
-                prCiStatus: 'SUCCESS',
-            });
-            const result = await prSnapshotService.refreshWorkspace('w1', 'https://github.com/org/repo/pull/123');
-            expect(result).toEqual({
-                success: true,
-                snapshot: {
-                    prNumber: 123,
-                    prState: 'OPEN',
-                    prReviewState: 'APPROVED',
-                    prCiStatus: 'SUCCESS',
-                },
-            });
-            expect(mockApplyPrSnapshotWithDispatchReset).toHaveBeenCalledWith('w1', {
-                prNumber: 123,
-                prState: 'OPEN',
-                prReviewState: 'APPROVED',
-                prCiStatus: 'SUCCESS',
-                prUpdatedAt: expect.any(Date),
-            });
-        });
-        it('applies snapshot directly through shared write path', async () => {
-            await prSnapshotService.applySnapshot('w2', {
-                prNumber: 50,
-                prState: 'MERGED',
-                prReviewState: null,
-                prCiStatus: 'SUCCESS',
-            });
-            expect(mockApplyPrSnapshotWithDispatchReset).toHaveBeenCalledWith('w2', {
-                prNumber: 50,
-                prState: 'MERGED',
-                prReviewState: null,
-                prCiStatus: 'SUCCESS',
-                prUpdatedAt: expect.any(Date),
-            });
-        });
-        it('applies newer direct CI observations after an older delayed PR refresh', async () => {
-            mockFindById.mockResolvedValue({
-                id: 'w-ordered',
-                prUrl: 'https://github.com/org/repo/pull/123',
-            });
-            const pendingFetch = deferred();
-            mockFetchAndComputePRState.mockReturnValue(pendingFetch.promise);
-            const refresh = prSnapshotService.refreshWorkspace('w-ordered');
-            await vi.waitFor(() => expect(mockFetchAndComputePRState).toHaveBeenCalledTimes(1));
-            const directObservation = prSnapshotService.recordPrObservation('w-ordered', {
-                prUrl: 'https://github.com/org/repo/pull/1',
-                prNumber: 1,
-                ciStatus: 'FAILURE',
-                prState: 'OPEN',
-                reviewState: null,
-                hasMergeConflict: false,
-                observedAt: new Date('2026-07-17T12:01:00.000Z'),
-            });
-            await Promise.resolve();
-            expect(mockApplyPrObservationWithDispatchReset).not.toHaveBeenCalled();
-            pendingFetch.resolve({
-                prNumber: 123,
-                prState: 'OPEN',
-                prReviewState: null,
-                prCiStatus: 'SUCCESS',
-            });
-            await Promise.all([refresh, directObservation]);
-            expect(mockApplyPrSnapshotWithDispatchReset.mock.invocationCallOrder[0]).toBeLessThan(mockApplyPrObservationWithDispatchReset.mock.invocationCallOrder[0]);
-        });
+    expect(listener).toHaveBeenCalledWith({ workspaceId: 'w', prId: 'p', prUrl: url });
+});
+it('routes manual refresh through the same full observation pipeline', async () => {
+    expect(await prSnapshotService.refreshPR({ workspaceId: 'w', prId: 'p' })).toMatchObject({
+        success: true,
     });
-    describe('recordPrObservation', () => {
-        it('does not clear failure timestamp when failedAt is omitted', async () => {
-            const observedAt = new Date('2026-02-11T00:00:00Z');
-            await prSnapshotService.recordPrObservation('w-ci-1', {
-                prUrl: 'https://github.com/org/repo/pull/1',
-                prNumber: 1,
-                ciStatus: 'SUCCESS',
-                prState: 'OPEN',
-                reviewState: null,
-                hasMergeConflict: false,
-                observedAt,
-            });
-            expect(mockApplyPrObservationWithDispatchReset).toHaveBeenCalledWith('w-ci-1', {
-                expectedPrUrl: 'https://github.com/org/repo/pull/1',
-                expectedPrNumber: 1,
-                prCiStatus: 'SUCCESS',
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prUpdatedAt: observedAt,
-            });
-        });
-        it('does not clear failure timestamp when failedAt is undefined', async () => {
-            const observedAt = new Date('2026-02-11T01:00:00Z');
-            await prSnapshotService.recordPrObservation('w-ci-2', {
-                prUrl: 'https://github.com/org/repo/pull/1',
-                prNumber: 1,
-                ciStatus: 'SUCCESS',
-                prState: 'OPEN',
-                reviewState: null,
-                hasMergeConflict: false,
-                failedAt: undefined,
-                observedAt,
-            });
-            expect(mockApplyPrObservationWithDispatchReset).toHaveBeenCalledWith('w-ci-2', {
-                expectedPrUrl: 'https://github.com/org/repo/pull/1',
-                expectedPrNumber: 1,
-                prCiStatus: 'SUCCESS',
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prUpdatedAt: observedAt,
-            });
-        });
-        it('clears failure timestamp when failedAt is null', async () => {
-            const observedAt = new Date('2026-02-11T02:00:00Z');
-            await prSnapshotService.recordPrObservation('w-ci-3', {
-                prUrl: 'https://github.com/org/repo/pull/1',
-                prNumber: 1,
-                ciStatus: 'SUCCESS',
-                prState: 'OPEN',
-                reviewState: null,
-                hasMergeConflict: false,
-                failedAt: null,
-                observedAt,
-            });
-            expect(mockApplyPrObservationWithDispatchReset).toHaveBeenCalledWith('w-ci-3', {
-                expectedPrUrl: 'https://github.com/org/repo/pull/1',
-                expectedPrNumber: 1,
-                prCiStatus: 'SUCCESS',
-                prState: 'OPEN',
-                prReviewState: null,
-                prHasMergeConflict: false,
-                prCiFailedAt: null,
-                prUpdatedAt: observedAt,
-            });
-        });
+    expect(observe).toHaveBeenCalledExactlyOnceWith({ workspaceId: 'w', prId: 'p' }, { force: true });
+    expect(bridge.applyPrSnapshotWithDispatchReset).not.toHaveBeenCalled();
+});
+it('refreshes every explicit association and reports a sibling failure', async () => {
+    bridge.listPRs.mockResolvedValue([row, { ...row, id: 'p2' }]);
+    observe.mockResolvedValueOnce(false).mockResolvedValueOnce(true);
+    expect(await prSnapshotService.refreshWorkspace('w')).toMatchObject({ success: false });
+    expect(observe).toHaveBeenCalledTimes(2);
+});
+it('does not attach discovery results when their claim is stale', async () => {
+    bridge.attachDiscoveredPRsIfClaimMatches.mockResolvedValue([]);
+    expect(await prSnapshotService.attachDiscoveredPRAndRefresh('w', url, {
+        branchName: 'branch',
+        githubOwner: 'org',
+        githubRepo: 'repo',
+        checkedAt: new Date(),
+        retryCount: 1,
+        nextCheckAt: new Date(),
+    })).toEqual({ success: false, reason: 'claim_stale' });
+    expect(observe).not.toHaveBeenCalled();
+});
+it('detaches only the explicit target', async () => {
+    bridge.detachPR.mockResolvedValue({ removed: true, dispatchReleased: false });
+    expect(await prSnapshotService.detachPR({ workspaceId: 'w', prId: 'p' })).toEqual({
+        removed: true,
+        dispatchReleased: false,
     });
-    describe('event emission', () => {
-        afterEach(() => {
-            prSnapshotService.removeAllListeners();
-        });
-        it('publishes a snapshot update for a ratchet observation that reset a dispatch', async () => {
-            mockApplyPrObservationWithDispatchReset.mockResolvedValue({
-                applied: true,
-                dispatchReset: true,
-            });
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => events.push(event));
-            await prSnapshotService.recordPrObservation('ws-exhausted', {
-                prUrl: 'https://github.com/org/repo/pull/1',
-                prNumber: 1,
-                ciStatus: 'PENDING',
-                prState: 'OPEN',
-                reviewState: null,
-                hasMergeConflict: false,
-                observedAt: new Date('2026-07-17T12:00:00.000Z'),
-            });
-            expect(events).toEqual([
-                {
-                    workspaceId: 'ws-exhausted',
-                    prNumber: 1,
-                    prState: 'OPEN',
-                    prCiStatus: 'PENDING',
-                    prReviewState: null,
-                    ratchetDispatchChanged: true,
-                },
-            ]);
-        });
-        it('publishes a snapshot update even when no dispatch was reset', async () => {
-            mockApplyPrObservationWithDispatchReset.mockResolvedValue({
-                applied: true,
-                dispatchReset: false,
-            });
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => events.push(event));
-            await prSnapshotService.recordPrObservation('ws-merged', {
-                prUrl: 'https://github.com/org/repo/pull/2',
-                prNumber: 2,
-                ciStatus: 'SUCCESS',
-                prState: 'MERGED',
-                reviewState: null,
-                hasMergeConflict: false,
-                observedAt: new Date('2026-07-17T12:00:00.000Z'),
-            });
-            expect(events).toEqual([
-                {
-                    workspaceId: 'ws-merged',
-                    prNumber: 2,
-                    prState: 'MERGED',
-                    prCiStatus: 'SUCCESS',
-                    prReviewState: null,
-                },
-            ]);
-        });
-        it('omits prUrl so a ratchet observation is never read as a PR switch', async () => {
-            mockApplyPrObservationWithDispatchReset.mockResolvedValue({
-                applied: true,
-                dispatchReset: false,
-            });
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => events.push(event));
-            await prSnapshotService.recordPrObservation('ws-same-pr', {
-                prUrl: 'https://github.com/org/repo/pull/3',
-                prNumber: 3,
-                ciStatus: 'SUCCESS',
-                prState: 'OPEN',
-                reviewState: null,
-                hasMergeConflict: false,
-            });
-            expect(events[0]).not.toHaveProperty('prUrl');
-        });
-        it('publishes nothing for a ratchet observation rejected by the guard', async () => {
-            mockApplyPrObservationWithDispatchReset.mockResolvedValue({
-                applied: false,
-                dispatchReset: false,
-            });
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => events.push(event));
-            await prSnapshotService.recordPrObservation('ws-stale-ci', {
-                prUrl: 'https://github.com/org/repo/pull/1',
-                prNumber: 1,
-                ciStatus: 'SUCCESS',
-                prState: 'OPEN',
-                reviewState: null,
-                hasMergeConflict: false,
-                observedAt: new Date('2026-07-17T12:01:00.000Z'),
-            });
-            expect(events).toEqual([]);
-        });
-        it('emits pr_snapshot_updated after successful applySnapshot', async () => {
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => {
-                events.push(event);
-            });
-            await prSnapshotService.applySnapshot('ws-1', {
-                prNumber: 42,
-                prState: 'OPEN',
-                prCiStatus: 'SUCCESS',
-                prReviewState: null,
-            }, {
-                eventPrUrl: 'https://github.com/org/repo/pull/42',
-            });
-            expect(events).toHaveLength(1);
-            expect(events[0]).toEqual({
-                workspaceId: 'ws-1',
-                prUrl: 'https://github.com/org/repo/pull/42',
-                prNumber: 42,
-                prState: 'OPEN',
-                prCiStatus: 'SUCCESS',
-                prReviewState: null,
-            });
-        });
-        it('publishes an authoritative dispatch reset after the PR aggregate changes', async () => {
-            mockApplyPrSnapshotWithDispatchReset.mockResolvedValue({
-                applied: true,
-                dispatchReset: true,
-            });
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => {
-                events.push(event);
-            });
-            await prSnapshotService.applySnapshot('ws-exhausted', {
-                prNumber: 42,
-                prState: 'OPEN',
-                prCiStatus: 'PENDING',
-                prReviewState: 'CHANGES_REQUESTED',
-            });
-            expect(mockApplyPrSnapshotWithDispatchReset).toHaveBeenCalledWith('ws-exhausted', expect.objectContaining({
-                prNumber: 42,
-                prState: 'OPEN',
-                prCiStatus: 'PENDING',
-                prReviewState: 'CHANGES_REQUESTED',
-                prUpdatedAt: expect.any(Date),
-            }));
-            expect(events[0]).toMatchObject({ ratchetDispatchChanged: true });
-        });
-        it('does not publish from a PR snapshot rejected by the aggregate guard', async () => {
-            mockApplyPrSnapshotWithDispatchReset.mockResolvedValue({
-                applied: false,
-                dispatchReset: false,
-            });
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => {
-                events.push(event);
-            });
-            await prSnapshotService.applySnapshot('ws-stale', {
-                prNumber: 41,
-                prState: 'OPEN',
-                prCiStatus: 'SUCCESS',
-                prReviewState: null,
-            });
-            expect(events).toEqual([]);
-        });
-        it('does not publish a dispatch reset for an identical PR aggregate refresh', async () => {
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => {
-                events.push(event);
-            });
-            await prSnapshotService.applySnapshot('ws-identical', {
-                prNumber: 42,
-                prState: 'CHANGES_REQUESTED',
-                prCiStatus: 'FAILURE',
-                prReviewState: 'CHANGES_REQUESTED',
-            });
-            expect(events[0]).not.toHaveProperty('ratchetDispatchChanged');
-        });
-        it('does not include prUrl in event when applySnapshot is called without prUrl options', async () => {
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => {
-                events.push(event);
-            });
-            await prSnapshotService.applySnapshot('ws-plain', {
-                prNumber: 11,
-                prState: 'OPEN',
-                prCiStatus: 'SUCCESS',
-                prReviewState: null,
-            });
-            expect(events).toHaveLength(1);
-            expect(events[0]).toMatchObject({
-                workspaceId: 'ws-plain',
-                prNumber: 11,
-                prState: 'OPEN',
-                prCiStatus: 'SUCCESS',
-                prReviewState: null,
-            });
-            expect(events[0]).not.toHaveProperty('prUrl');
-        });
-        it('emits pr_snapshot_updated on refreshWorkspace when snapshot succeeds', async () => {
-            mockFindById.mockResolvedValue({
-                id: 'ws-2',
-                prUrl: 'https://github.com/org/repo/pull/10',
-            });
-            mockFetchAndComputePRState.mockResolvedValue({
-                prNumber: 10,
-                prState: 'OPEN',
-                prReviewState: 'APPROVED',
-                prCiStatus: 'FAILURE',
-            });
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => {
-                events.push(event);
-            });
-            const result = await prSnapshotService.refreshWorkspace('ws-2');
-            expect(result).toEqual({
-                success: true,
-                snapshot: {
-                    prNumber: 10,
-                    prState: 'OPEN',
-                    prReviewState: 'APPROVED',
-                    prCiStatus: 'FAILURE',
-                },
-            });
-            expect(events).toHaveLength(1);
-            expect(events[0]).toEqual({
-                workspaceId: 'ws-2',
-                prUrl: 'https://github.com/org/repo/pull/10',
-                prNumber: 10,
-                prState: 'OPEN',
-                prCiStatus: 'FAILURE',
-                prReviewState: 'APPROVED',
-            });
-        });
-        it('does NOT emit on refreshWorkspace when workspace not found', async () => {
-            mockFindById.mockResolvedValue(null);
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => {
-                events.push(event);
-            });
-            await prSnapshotService.refreshWorkspace('ws-missing');
-            expect(events).toHaveLength(0);
-        });
-        it('does NOT emit on refreshWorkspace when no prUrl', async () => {
-            mockFindById.mockResolvedValue({ id: 'ws-no-pr', prUrl: null });
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => {
-                events.push(event);
-            });
-            const result = await prSnapshotService.refreshWorkspace('ws-no-pr');
-            expect(result).toEqual({ success: false, reason: 'no_pr_url' });
-            expect(events).toHaveLength(0);
-        });
-        it('emits event on attachAndRefreshPR', async () => {
-            mockFindById.mockResolvedValueOnce({ id: 'ws-attach', prUrl: null });
-            mockFetchAndComputePRState.mockResolvedValue({
-                prNumber: 77,
-                prState: 'OPEN',
-                prReviewState: null,
-                prCiStatus: 'PENDING',
-            });
-            const events = [];
-            prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => {
-                events.push(event);
-            });
-            const result = await prSnapshotService.attachAndRefreshPR('ws-attach', 'https://github.com/org/repo/pull/77');
-            expect(result).toEqual({
-                success: true,
-                snapshot: {
-                    prNumber: 77,
-                    prState: 'OPEN',
-                    prReviewState: null,
-                    prCiStatus: 'PENDING',
-                },
-            });
-            expect(events).toHaveLength(1);
-            expect(events[0]).toEqual({
-                workspaceId: 'ws-attach',
-                prUrl: 'https://github.com/org/repo/pull/77',
-                prNumber: 77,
-                prState: 'OPEN',
-                prCiStatus: 'PENDING',
-                prReviewState: null,
-            });
-        });
+    expect(bridge.detachPR).toHaveBeenCalledExactlyOnceWith({ workspaceId: 'w', prId: 'p' });
+});
+it('returns an error result when listing associations fails', async () => {
+    bridge.listPRs.mockRejectedValueOnce(new Error('database unavailable'));
+    await expect(prSnapshotService.refreshWorkspace('w')).resolves.toEqual({
+        success: false,
+        reason: 'error',
     });
 });
+it('returns an error result when a discovery attachment fails', async () => {
+    bridge.attachDiscoveredPRsIfClaimMatches.mockRejectedValueOnce(new Error('database unavailable'));
+    await expect(prSnapshotService.attachDiscoveredPRAndRefresh('w', url, {
+        branchName: 'branch',
+        githubOwner: 'org',
+        githubRepo: 'repo',
+        checkedAt: new Date(),
+        retryCount: 1,
+        nextCheckAt: new Date(),
+    })).resolves.toEqual({ success: false, reason: 'error' });
+});
 //# sourceMappingURL=pr-snapshot.service.test.js.map