factory-factory 0.4.1 → 0.4.2

package/dist/src/backend/services/workspace/resources/workspace.accessor.test.js

@@ -8,6 +8,13 @@ const mockUpdate = vi.fn();
 const mockUpdateMany = vi.fn();
 const mockExecuteRaw = vi.fn();
 const mockTransaction = vi.fn();
+const mockRatchetFindUnique = vi.fn();
+const mockRatchetUpdateMany = vi.fn();
+const mockPrFindUnique = vi.fn();
+const mockPrUpdateMany = vi.fn();
+const mockRunScriptUpdateMany = vi.fn();
+const mockAutoIterationFindMany = vi.fn();
+const mockAutoIterationUpdateMany = vi.fn();
 vi.mock('@/backend/db', () => ({
     prisma: {
         workspace: {
@@ -19,6 +26,21 @@ vi.mock('@/backend/db', () => ({
             update: (...args) => mockUpdate(...args),
             updateMany: (...args) => mockUpdateMany(...args),
         },
+        workspaceRatchet: {
+            findUnique: (...args) => mockRatchetFindUnique(...args),
+            updateMany: (...args) => mockRatchetUpdateMany(...args),
+        },
+        workspacePR: {
+            findUnique: (...args) => mockPrFindUnique(...args),
+            updateMany: (...args) => mockPrUpdateMany(...args),
+        },
+        workspaceRunScript: {
+            updateMany: (...args) => mockRunScriptUpdateMany(...args),
+        },
+        workspaceAutoIteration: {
+            findMany: (...args) => mockAutoIterationFindMany(...args),
+            updateMany: (...args) => mockAutoIterationUpdateMany(...args),
+        },
         $executeRaw: (...args) => mockExecuteRaw(...args),
         $transaction: (...args) => mockTransaction(...args),
     },
@@ -27,6 +49,11 @@ import { workspaceAccessor } from './workspace.accessor.js';
 describe('workspaceAccessor', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        mockUpdateMany.mockReset();
+        mockRatchetUpdateMany.mockReset();
+        mockPrUpdateMany.mockReset();
+        mockRunScriptUpdateMany.mockReset();
+        mockAutoIterationUpdateMany.mockReset();
     });
     describe('create', () => {
         it('passes ratchetEnabled when provided', async () => {
@@ -42,11 +69,15 @@ describe('workspaceAccessor', () => {
                     projectId: 'project-1',
                     name: 'Issue workspace',
                     githubIssueNumber: 12,
-                    ratchetEnabled: false,
+                    ratchet: { create: { enabled: false } },
+                    pr: { create: {} },
+                    runScript: { create: {} },
+                    autoIteration: { create: { mode: undefined, config: undefined } },
                 }),
+                include: { ratchet: true, pr: true, runScript: true, autoIteration: true },
             });
         });
-        it('keeps ratchetEnabled undefined when not provided', async () => {
+        it('leaves the ratchet row on its column default when no preference is given', async () => {
             mockCreate.mockResolvedValue({ id: 'ws-2' });
             await workspaceAccessor.create({
                 projectId: 'project-1',
@@ -56,17 +87,38 @@ describe('workspaceAccessor', () => {
                 data: expect.objectContaining({
                     projectId: 'project-1',
                     name: 'Manual workspace',
-                    ratchetEnabled: undefined,
+                    ratchet: { create: { enabled: undefined } },
+                    pr: { create: {} },
+                    runScript: { create: {} },
+                    autoIteration: { create: { mode: undefined, config: undefined } },
                 }),
+                include: { ratchet: true, pr: true, runScript: true, autoIteration: true },
             });
         });
-    });
-    it('throws for mutually-exclusive status filters in findByProjectIdWithSessions', () => {
-        expect(() => workspaceAccessor.findByProjectIdWithSessions('project-1', {
-            status: 'READY',
-            excludeStatuses: ['FAILED'],
-        })).toThrow('Cannot specify both status and excludeStatuses filters');
-        expect(mockFindMany).not.toHaveBeenCalled();
+        it('always creates the ratchet row, so no workspace can exist without one', async () => {
+            mockCreate.mockResolvedValue({ id: 'ws-3' });
+            await workspaceAccessor.create({ projectId: 'project-1', name: 'Manual workspace' });
+            const [{ data }] = mockCreate.mock.calls[0];
+            expect(data.ratchet).toBeDefined();
+        });
+    });
+    it('excludes statuses in findByProjectIdWithSessions', async () => {
+        mockFindMany.mockResolvedValueOnce([]);
+        await workspaceAccessor.findByProjectIdWithSessions('project-1', {
+            excludeStatuses: ['ARCHIVING', 'ARCHIVED'],
+        });
+        expect(mockFindMany).toHaveBeenCalledWith({
+            where: { projectId: 'project-1', status: { notIn: ['ARCHIVING', 'ARCHIVED'] } },
+            orderBy: { updatedAt: 'desc' },
+            include: {
+                agentSessions: true,
+                terminalSessions: true,
+                ratchet: true,
+                pr: true,
+                runScript: true,
+                autoIteration: true,
+            },
+        });
     });
     it('short-circuits findByIds and findByIdsWithProject for empty id arrays', async () => {
         await expect(workspaceAccessor.findByIds([])).resolves.toEqual([]);
@@ -82,521 +134,261 @@ describe('workspaceAccessor', () => {
         });
         expect(mockFindMany).toHaveBeenNthCalledWith(2, {
             where: { id: { in: ['ws-2'] } },
-            include: { project: true },
+            include: { project: true, pr: true, autoIteration: true },
         });
     });
-    describe('PR discovery scheduling', () => {
-        it('finds a bounded due set with GitHub metadata and reset candidates first', async () => {
-            const dueAt = new Date('2026-07-17T12:00:00.000Z');
-            mockFindMany.mockResolvedValue([]);
-            await workspaceAccessor.findNeedingPRDiscovery(25, dueAt);
-            expect(mockFindMany).toHaveBeenCalledWith({
-                where: {
-                    status: 'READY',
-                    prUrl: null,
-                    branchName: { not: null },
-                    project: {
-                        githubOwner: { not: null },
-                        githubRepo: { not: null },
-                    },
-                    OR: [{ prDiscoveryNextCheckAt: null }, { prDiscoveryNextCheckAt: { lte: dueAt } }],
-                },
-                include: { project: true },
-                orderBy: [{ prDiscoveryNextCheckAt: 'asc' }, { updatedAt: 'desc' }],
-                take: 25,
+    describe('ratchetState projection at the flatten boundary', () => {
+        function row(pr, ratchet = { enabled: true }) {
+            return { id: 'ws-1', ratchet, pr };
+        }
+        it('derives the state from the joined PR row instead of reading a column', async () => {
+            mockFindUnique.mockResolvedValue(row({ state: 'OPEN', ciStatus: 'FAILURE', hasMergeConflict: false, reviewState: null }));
+            await expect(workspaceAccessor.findById('ws-1')).resolves.toMatchObject({
+                ratchetState: 'CI_FAILED',
             });
         });
-        it('uses the current time as the default due threshold', async () => {
-            const now = new Date('2026-07-17T12:00:00.000Z');
-            vi.useFakeTimers();
-            vi.setSystemTime(now);
-            mockFindMany.mockResolvedValue([]);
-            try {
-                await workspaceAccessor.findNeedingPRDiscovery(10);
-            }
-            finally {
-                vi.useRealTimers();
-            }
-            expect(mockFindMany).toHaveBeenCalledWith(expect.objectContaining({
-                where: expect.objectContaining({
-                    OR: [{ prDiscoveryNextCheckAt: null }, { prDiscoveryNextCheckAt: { lte: now } }],
+        it('joins both side tables on the read that projects the state', async () => {
+            mockFindUnique.mockResolvedValue(row({ state: 'OPEN', ciStatus: 'SUCCESS' }));
+            await workspaceAccessor.findById('ws-1');
+            expect(mockFindUnique).toHaveBeenCalledWith(expect.objectContaining({
+                include: expect.objectContaining({
+                    ratchet: true,
+                    pr: true,
+                    runScript: true,
+                    autoIteration: true,
                 }),
             }));
         });
-        it('claims an attempt only while all observed eligibility values still match', async () => {
-            const expectedUpdatedAt = new Date('2026-07-17T11:59:00.000Z');
-            const expectedNextCheckAt = new Date('2026-07-17T11:58:00.000Z');
-            const checkedAt = new Date('2026-07-17T12:00:00.000Z');
-            const nextCheckAt = new Date('2026-07-17T12:06:00.000Z');
-            mockUpdateMany.mockResolvedValue({ count: 1 });
-            await expect(workspaceAccessor.claimPRDiscoveryAttempt('ws-1', {
-                branchName: 'feature/pr-discovery',
-                expectedUpdatedAt,
-                expectedRetryCount: 1,
-                expectedNextCheckAt,
-                checkedAt,
-                nextCheckAt,
-            })).resolves.toBe(true);
-            expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: {
-                    id: 'ws-1',
-                    status: 'READY',
-                    prUrl: null,
-                    branchName: 'feature/pr-discovery',
-                    updatedAt: expectedUpdatedAt,
-                    prDiscoveryRetryCount: 1,
-                    prDiscoveryNextCheckAt: expectedNextCheckAt,
-                },
-                data: {
-                    prDiscoveryLastCheckedAt: checkedAt,
-                    prDiscoveryRetryCount: { increment: 1 },
-                    prDiscoveryNextCheckAt: nextCheckAt,
-                },
+        it('projects IDLE for a disabled workspace whatever the PR says', async () => {
+            mockFindUnique.mockResolvedValue(row({ state: 'OPEN', ciStatus: 'FAILURE', hasMergeConflict: true, reviewState: null }, { enabled: false }));
+            await expect(workspaceAccessor.findById('ws-1')).resolves.toMatchObject({
+                ratchetEnabled: false,
+                ratchetState: 'IDLE',
             });
         });
-        it('guards a claim whose observed next-check timestamp was null', async () => {
-            const expectedUpdatedAt = new Date('2026-07-17T11:59:00.000Z');
-            const checkedAt = new Date('2026-07-17T12:00:00.000Z');
-            const nextCheckAt = new Date('2026-07-17T12:03:00.000Z');
-            mockUpdateMany.mockResolvedValue({ count: 0 });
-            await expect(workspaceAccessor.claimPRDiscoveryAttempt('ws-1', {
-                branchName: 'feature/pr-discovery',
-                expectedUpdatedAt,
-                expectedRetryCount: 0,
-                expectedNextCheckAt: null,
-                checkedAt,
-                nextCheckAt,
-            })).resolves.toBe(false);
-            expect(mockUpdateMany).toHaveBeenCalledWith(expect.objectContaining({
-                where: expect.objectContaining({ prDiscoveryNextCheckAt: null }),
-            }));
+        it('surfaces a merge conflict that only the conflict column records', async () => {
+            mockFindUnique.mockResolvedValue(row({ state: 'OPEN', ciStatus: 'SUCCESS', hasMergeConflict: true, reviewState: null }));
+            await expect(workspaceAccessor.findById('ws-1')).resolves.toMatchObject({
+                prHasMergeConflict: true,
+                ratchetState: 'MERGE_CONFLICT',
+            });
         });
-        it('attaches a discovered PR only while the exact discovery claim remains current', async () => {
-            const checkedAt = new Date('2026-07-17T12:00:00.000Z');
-            const nextCheckAt = new Date('2026-07-17T12:06:00.000Z');
-            const prUpdatedAt = new Date('2026-07-17T12:01:00.000Z');
-            mockUpdateMany.mockResolvedValue({ count: 1 });
-            await expect(workspaceAccessor.attachDiscoveredPRIfClaimMatches('ws-1', 'https://github.com/org/repo/pull/12', {
-                branchName: 'feature/pr-discovery',
-                checkedAt,
-                retryCount: 2,
-                nextCheckAt,
-            }, prUpdatedAt)).resolves.toBe(true);
-            expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: {
-                    id: 'ws-1',
-                    status: 'READY',
-                    prUrl: null,
-                    branchName: 'feature/pr-discovery',
-                    prDiscoveryLastCheckedAt: checkedAt,
-                    prDiscoveryRetryCount: 2,
-                    prDiscoveryNextCheckAt: nextCheckAt,
-                },
-                data: {
-                    prUrl: 'https://github.com/org/repo/pull/12',
-                    prUpdatedAt,
-                },
+        it('falls back to the side-table defaults when a row is missing', async () => {
+            mockFindUnique.mockResolvedValue({ id: 'ws-1', ratchet: null, pr: null });
+            await expect(workspaceAccessor.findById('ws-1')).resolves.toMatchObject({
+                ratchetEnabled: true,
+                prState: 'NONE',
+                ratchetState: 'IDLE',
             });
         });
-        it('updates a discovered PR snapshot only while its URL remains attached', async () => {
-            const prUpdatedAt = new Date('2026-07-17T12:02:00.000Z');
-            mockUpdateMany.mockResolvedValue({ count: 1 });
-            await expect(workspaceAccessor.updatePRSnapshotIfUrlMatches('ws-1', 'https://github.com/org/repo/pull/12', {
-                prNumber: 12,
-                prState: 'OPEN',
-                prReviewState: 'APPROVED',
-                prCiStatus: 'SUCCESS',
-            }, prUpdatedAt)).resolves.toBe(true);
-            expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: {
-                    id: 'ws-1',
-                    prUrl: 'https://github.com/org/repo/pull/12',
+        it('drops the relation objects so callers see only the flat shape', async () => {
+            mockFindUnique.mockResolvedValue(row({ state: 'OPEN', ciStatus: 'PENDING' }));
+            const workspace = await workspaceAccessor.findById('ws-1');
+            expect(workspace).not.toHaveProperty('ratchet');
+            expect(workspace).not.toHaveProperty('pr');
+            expect(workspace).toMatchObject({ ratchetState: 'CI_RUNNING' });
+        });
+    });
+    describe('PR aggregate writes with dispatch reset', () => {
+        function currentColumns(overrides = {}) {
+            return {
+                url: null,
+                number: 41,
+                state: 'CHANGES_REQUESTED',
+                ciStatus: 'FAILURE',
+                reviewState: 'CHANGES_REQUESTED',
+                syncedAt: new Date('2026-07-17T11:59:00.000Z'),
+                ...overrides,
+            };
+        }
+        function currentDispatch(overrides = {}) {
+            return {
+                activeSessionId: null,
+                dispatchSnapshotKey: 'failed:41',
+                dispatchOutcome: 'DIED',
+                dispatchRetryCount: 3,
+                ...overrides,
+            };
+        }
+        function runInTransaction() {
+            mockTransaction.mockImplementation(async (callback) => callback({
+                workspace: {
+                    findUniqueOrThrow: mockFindUnique,
+                    update: mockUpdate,
+                    updateMany: mockUpdateMany,
                 },
-                data: {
-                    prNumber: 12,
-                    prState: 'OPEN',
-                    prReviewState: 'APPROVED',
-                    prCiStatus: 'SUCCESS',
-                    prUpdatedAt,
+                workspaceRatchet: {
+                    findUnique: mockRatchetFindUnique,
+                    updateMany: mockRatchetUpdateMany,
                 },
-            });
-        });
-        it('resets discovery backoff only while the workspace remains eligible', async () => {
-            mockUpdateMany.mockResolvedValue({ count: 1 });
-            await expect(workspaceAccessor.resetPRDiscoveryBackoff('ws-1')).resolves.toBe(true);
-            expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: {
-                    id: 'ws-1',
-                    status: 'READY',
-                    prUrl: null,
-                    branchName: { not: null },
+                workspacePR: {
+                    findUnique: mockPrFindUnique,
+                    updateMany: mockPrUpdateMany,
                 },
+            }));
+        }
+        const prUpdatedAt = new Date('2026-07-17T12:00:00.000Z');
+        const changedObservation = {
+            prNumber: 42,
+            prState: 'OPEN',
+            prCiStatus: 'PENDING',
+            prReviewState: 'CHANGES_REQUESTED',
+            prUpdatedAt,
+        };
+        beforeEach(() => {
+            mockPrFindUnique.mockResolvedValue(currentColumns());
+            mockRatchetFindUnique.mockResolvedValue(currentDispatch());
+            runInTransaction();
+        });
+        it('writes the changed aggregate guarded on the aggregate alone', async () => {
+            mockPrUpdateMany.mockResolvedValue({ count: 1 });
+            mockRatchetUpdateMany.mockResolvedValue({ count: 1 });
+            await expect(workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', changedObservation)).resolves.toEqual({ applied: true, dispatchReset: true });
+            expect(mockPrUpdateMany).toHaveBeenCalledWith({
+                where: { workspaceId: 'ws-1', ...currentColumns() },
                 data: {
-                    prDiscoveryLastCheckedAt: null,
-                    prDiscoveryRetryCount: 0,
-                    prDiscoveryNextCheckAt: null,
+                    number: 42,
+                    state: 'OPEN',
+                    ciStatus: 'PENDING',
+                    reviewState: 'CHANGES_REQUESTED',
+                    syncedAt: prUpdatedAt,
                 },
             });
         });
-    });
-    it('marks workspace as having had sessions with guarded updateMany', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 1 });
-        await workspaceAccessor.markHasHadSessions('ws-1');
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: { id: 'ws-1', hasHadSessions: false },
-            data: { hasHadSessions: true },
-        });
-    });
-    it('records ratchet dispatch only when ratchet is enabled', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 1 });
-        await expect(workspaceAccessor.recordRatchetDispatchIfEnabled('ws-1', {
-            sessionId: 'session-1',
-            snapshotKey: 'snapshot-1',
-            retryCount: 2,
-        })).resolves.toBe(true);
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: { id: 'ws-1', ratchetEnabled: true },
-            data: {
-                ratchetActiveSessionId: 'session-1',
-                ratchetLastCiRunId: 'snapshot-1',
-                ratchetDispatchOutcome: 'RUNNING',
-                ratchetDispatchRetryCount: 2,
-            },
-        });
-    });
-    it('returns false when ratchet dispatch conditional update affects no rows', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 0 });
-        await expect(workspaceAccessor.recordRatchetDispatchIfEnabled('ws-1', {
-            sessionId: 'session-1',
-            snapshotKey: 'snapshot-1',
-            retryCount: 0,
-        })).resolves.toBe(false);
-    });
-    it('adopts an already-running fixer session without touching the dispatch snapshot', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 1 });
-        await expect(workspaceAccessor.adoptRatchetActiveSessionIfEnabled('ws-1', 'session-1')).resolves.toBe(true);
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: { id: 'ws-1', ratchetEnabled: true },
-            data: { ratchetActiveSessionId: 'session-1', ratchetDispatchOutcome: 'RUNNING' },
+        it('leaves the workspace row alone when no branch correction came with it', async () => {
+            mockPrUpdateMany.mockResolvedValue({ count: 1 });
+            mockRatchetUpdateMany.mockResolvedValue({ count: 1 });
+            await workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', changedObservation);
+            expect(mockUpdate).not.toHaveBeenCalled();
+            expect(mockUpdateMany).not.toHaveBeenCalled();
         });
-    });
-    it('settles ratchet session end only when the pointer still matches', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 1 });
-        await expect(workspaceAccessor.recordRatchetSessionEnd('ws-1', 'session-1', 'DIED')).resolves.toBe(true);
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: { id: 'ws-1', ratchetActiveSessionId: 'session-1' },
-            data: { ratchetActiveSessionId: null, ratchetDispatchOutcome: 'DIED' },
+        it('writes a corrected branch name only after the aggregate write holds', async () => {
+            mockPrUpdateMany.mockResolvedValue({ count: 1 });
+            mockRatchetUpdateMany.mockResolvedValue({ count: 1 });
+            await workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', {
+                ...changedObservation,
+                branchName: 'feature/actual-head',
+            });
+            expect(mockUpdate).toHaveBeenCalledWith({
+                where: { id: 'ws-1' },
+                data: { branchName: 'feature/actual-head' },
+            });
         });
-    });
-    it('atomically persists a changed PR aggregate with settled dispatch reset', async () => {
-        const currentUpdatedAt = new Date('2026-07-17T11:59:00.000Z');
-        const prUpdatedAt = new Date('2026-07-17T12:00:00.000Z');
-        mockFindUnique.mockResolvedValue({
-            prUrl: null,
-            prNumber: 41,
-            prState: 'CHANGES_REQUESTED',
-            prCiStatus: 'FAILURE',
-            prReviewState: 'CHANGES_REQUESTED',
-            prUpdatedAt: currentUpdatedAt,
-            ratchetActiveSessionId: null,
-            ratchetLastCiRunId: 'failed:41',
-            ratchetDispatchOutcome: 'DIED',
-            ratchetDispatchRetryCount: 3,
+        it('does not write the branch name when the aggregate write lost its guard', async () => {
+            mockPrUpdateMany.mockResolvedValue({ count: 0 });
+            await expect(workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', {
+                ...changedObservation,
+                branchName: 'feature/actual-head',
+            })).resolves.toEqual({ applied: false, dispatchReset: false });
+            expect(mockUpdate).not.toHaveBeenCalled();
+        });
+        it('resets the settled dispatch guarded on every field it was read with', async () => {
+            mockPrUpdateMany.mockResolvedValue({ count: 1 });
+            mockRatchetUpdateMany.mockResolvedValue({ count: 1 });
+            await workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', changedObservation);
+            expect(mockRatchetUpdateMany).toHaveBeenCalledWith({
+                where: { workspaceId: 'ws-1', ...currentDispatch() },
+                data: { dispatchOutcome: null, dispatchRetryCount: 0 },
+            });
         });
-        mockUpdateMany.mockResolvedValue({ count: 1 });
-        mockTransaction.mockImplementation(async (callback) => callback({
-            workspace: {
-                findUniqueOrThrow: mockFindUnique,
-                update: mockUpdate,
-                updateMany: mockUpdateMany,
-            },
-        }));
-        await expect(workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', {
-            prNumber: 42,
-            prState: 'OPEN',
-            prCiStatus: 'PENDING',
-            prReviewState: 'CHANGES_REQUESTED',
-            prUpdatedAt,
-        })).resolves.toEqual({ applied: true, dispatchReset: true });
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: {
-                id: 'ws-1',
-                prUrl: null,
-                prNumber: 41,
-                prState: 'CHANGES_REQUESTED',
-                prReviewState: 'CHANGES_REQUESTED',
-                prCiStatus: 'FAILURE',
-                prUpdatedAt: currentUpdatedAt,
-                ratchetActiveSessionId: null,
-                ratchetLastCiRunId: 'failed:41',
-                ratchetDispatchOutcome: 'DIED',
-                ratchetDispatchRetryCount: 3,
-            },
-            data: {
+        it('keeps the aggregate write when a newer dispatch wins the reset guard', async () => {
+            mockPrUpdateMany.mockResolvedValue({ count: 1 });
+            mockRatchetUpdateMany.mockResolvedValue({ count: 0 });
+            await expect(workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', changedObservation)).resolves.toEqual({ applied: true, dispatchReset: false });
+            expect(mockPrUpdateMany).toHaveBeenCalledTimes(1);
+        });
+        it('skips the dispatch reset entirely when the aggregate write loses its guard', async () => {
+            mockPrUpdateMany.mockResolvedValue({ count: 0 });
+            await expect(workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', changedObservation)).resolves.toEqual({ applied: false, dispatchReset: false });
+            expect(mockRatchetUpdateMany).not.toHaveBeenCalled();
+        });
+        it('leaves a RUNNING dispatch alone even when the aggregate changed', async () => {
+            mockRatchetFindUnique.mockResolvedValue(currentDispatch({ dispatchOutcome: 'RUNNING' }));
+            mockPrUpdateMany.mockResolvedValue({ count: 1 });
+            await expect(workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', changedObservation)).resolves.toEqual({ applied: true, dispatchReset: false });
+            expect(mockRatchetUpdateMany).not.toHaveBeenCalled();
+        });
+        it('leaves settled dispatch metadata alone for an identical aggregate', async () => {
+            mockPrFindUnique.mockResolvedValue(currentColumns({ url: 'https://github.com/org/repo/pull/42', number: 42 }));
+            mockPrUpdateMany.mockResolvedValue({ count: 1 });
+            await workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', {
+                prUrl: 'https://github.com/org/repo/pull/42',
                 prNumber: 42,
-                prState: 'OPEN',
-                prCiStatus: 'PENDING',
-                prReviewState: 'CHANGES_REQUESTED',
-                prUpdatedAt,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            },
-        });
-        expect(mockUpdate).not.toHaveBeenCalled();
-    });
-    it('preserves a RUNNING dispatch that wins the reset compare-and-swap', async () => {
-        const currentUpdatedAt = new Date('2026-07-17T11:59:00.000Z');
-        const prUpdatedAt = new Date('2026-07-17T12:00:00.000Z');
-        mockFindUnique.mockResolvedValue({
-            prUrl: null,
-            prNumber: 41,
-            prState: 'CHANGES_REQUESTED',
-            prCiStatus: 'FAILURE',
-            prReviewState: 'CHANGES_REQUESTED',
-            prUpdatedAt: currentUpdatedAt,
-            ratchetActiveSessionId: null,
-            ratchetLastCiRunId: 'old-snapshot',
-            ratchetDispatchOutcome: 'DIED',
-            ratchetDispatchRetryCount: 3,
-        });
-        mockUpdateMany.mockResolvedValueOnce({ count: 0 }).mockResolvedValueOnce({ count: 1 });
-        mockTransaction.mockImplementation(async (callback) => callback({
-            workspace: {
-                findUniqueOrThrow: mockFindUnique,
-                update: mockUpdate,
-                updateMany: mockUpdateMany,
-            },
-        }));
-        await expect(workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', {
-            prNumber: 42,
-            prState: 'OPEN',
-            prCiStatus: 'PENDING',
-            prReviewState: 'CHANGES_REQUESTED',
-            prUpdatedAt,
-        })).resolves.toEqual({ applied: true, dispatchReset: false });
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: {
-                id: 'ws-1',
-                prUrl: null,
-                prNumber: 41,
-                prState: 'CHANGES_REQUESTED',
-                prReviewState: 'CHANGES_REQUESTED',
-                prCiStatus: 'FAILURE',
-                prUpdatedAt: currentUpdatedAt,
-                ratchetActiveSessionId: null,
-                ratchetLastCiRunId: 'old-snapshot',
-                ratchetDispatchOutcome: 'DIED',
-                ratchetDispatchRetryCount: 3,
-            },
-            data: expect.objectContaining({
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            }),
-        });
-        expect(mockUpdateMany).toHaveBeenLastCalledWith({
-            where: {
-                id: 'ws-1',
-                prUrl: null,
-                prNumber: 41,
                 prState: 'CHANGES_REQUESTED',
-                prReviewState: 'CHANGES_REQUESTED',
                 prCiStatus: 'FAILURE',
-                prUpdatedAt: currentUpdatedAt,
-            },
-            data: {
-                prNumber: 42,
-                prState: 'OPEN',
-                prCiStatus: 'PENDING',
                 prReviewState: 'CHANGES_REQUESTED',
                 prUpdatedAt,
-            },
+            });
+            expect(mockRatchetUpdateMany).not.toHaveBeenCalled();
         });
-        expect(mockUpdate).not.toHaveBeenCalled();
-    });
-    it('does not overwrite a newer PR aggregate when the reset and fallback guards lose', async () => {
-        const currentUpdatedAt = new Date('2026-07-17T12:00:00.000Z');
-        const observationUpdatedAt = new Date('2026-07-17T12:01:00.000Z');
-        mockFindUnique.mockResolvedValue({
-            prUrl: 'https://github.com/org/repo/pull/41',
-            prNumber: 41,
-            prState: 'CHANGES_REQUESTED',
-            prCiStatus: 'FAILURE',
-            prReviewState: 'CHANGES_REQUESTED',
-            prUpdatedAt: currentUpdatedAt,
-            ratchetActiveSessionId: null,
-            ratchetLastCiRunId: 'old-snapshot',
-            ratchetDispatchOutcome: 'DIED',
-            ratchetDispatchRetryCount: 3,
-        });
-        mockUpdateMany.mockResolvedValue({ count: 0 });
-        mockTransaction.mockImplementation(async (callback) => callback({
-            workspace: {
-                findUniqueOrThrow: mockFindUnique,
-                update: mockUpdate,
-                updateMany: mockUpdateMany,
-            },
-        }));
-        await expect(workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', {
-            prNumber: 42,
-            prState: 'OPEN',
-            prCiStatus: 'PENDING',
-            prReviewState: null,
-            prUpdatedAt: observationUpdatedAt,
-        })).resolves.toEqual({ applied: false, dispatchReset: false });
-        expect(mockUpdateMany).toHaveBeenCalledTimes(2);
-        expect(mockUpdateMany).toHaveBeenLastCalledWith({
-            where: {
-                id: 'ws-1',
-                prUrl: 'https://github.com/org/repo/pull/41',
-                prNumber: 41,
-                prState: 'CHANGES_REQUESTED',
-                prReviewState: 'CHANGES_REQUESTED',
-                prCiStatus: 'FAILURE',
-                prUpdatedAt: currentUpdatedAt,
-            },
-            data: {
-                prNumber: 42,
+        it('refuses an observation whose PR is no longer the one attached', async () => {
+            mockPrFindUnique.mockResolvedValue(currentColumns({ url: 'https://github.com/org/repo/pull/99', number: 99 }));
+            await expect(workspaceAccessor.applyPrObservationWithDispatchReset('ws-1', {
+                expectedPrNumber: 42,
+                prCiStatus: 'SUCCESS',
+                prState: 'MERGED',
+                prReviewState: null,
+                prHasMergeConflict: false,
+                prUpdatedAt,
+            })).resolves.toEqual({ applied: false, dispatchReset: false });
+            expect(mockPrUpdateMany).not.toHaveBeenCalled();
+            expect(mockRatchetUpdateMany).not.toHaveBeenCalled();
+        });
+        it('accepts an observation when the cached PR number is not yet known', async () => {
+            mockPrFindUnique.mockResolvedValue(currentColumns({ url: 'https://github.com/org/repo/pull/42', number: null }));
+            mockPrUpdateMany.mockResolvedValue({ count: 1 });
+            mockRatchetUpdateMany.mockResolvedValue({ count: 1 });
+            await expect(workspaceAccessor.applyPrObservationWithDispatchReset('ws-1', {
+                expectedPrNumber: 42,
+                prCiStatus: 'SUCCESS',
                 prState: 'OPEN',
-                prCiStatus: 'PENDING',
                 prReviewState: null,
-                prUpdatedAt: observationUpdatedAt,
-            },
-        });
-        expect(mockUpdate).not.toHaveBeenCalled();
-    });
-    it('resets settled ownership for a changed direct CI observation', async () => {
-        const currentUpdatedAt = new Date('2026-07-17T11:59:00.000Z');
-        const observedAt = new Date('2026-07-17T12:00:00.000Z');
-        mockFindUnique.mockResolvedValue({
-            prUrl: 'https://github.com/org/repo/pull/42',
-            prNumber: 42,
-            prState: 'OPEN',
-            prCiStatus: 'FAILURE',
-            prReviewState: null,
-            prUpdatedAt: currentUpdatedAt,
-            ratchetActiveSessionId: null,
-            ratchetLastCiRunId: 'failure:42',
-            ratchetDispatchOutcome: 'DIED',
-            ratchetDispatchRetryCount: 3,
-        });
-        mockUpdateMany.mockResolvedValue({ count: 1 });
-        mockTransaction.mockImplementation(async (callback) => callback({
-            workspace: {
-                findUniqueOrThrow: mockFindUnique,
-                update: mockUpdate,
-                updateMany: mockUpdateMany,
-            },
-        }));
-        await expect(workspaceAccessor.applyCIObservationWithDispatchReset('ws-1', {
-            prCiStatus: 'PENDING',
-            prUpdatedAt: observedAt,
-        })).resolves.toEqual({ applied: true, dispatchReset: true });
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: expect.objectContaining({
-                id: 'ws-1',
-                ratchetDispatchOutcome: 'DIED',
-                ratchetDispatchRetryCount: 3,
-            }),
-            data: {
+                prHasMergeConflict: false,
+                prUpdatedAt,
+            })).resolves.toMatchObject({ applied: true });
+        });
+        it('resets settled metadata for a changed direct CI observation', async () => {
+            mockPrFindUnique.mockResolvedValue(currentColumns({ url: 'https://github.com/org/repo/pull/42', number: 42 }));
+            mockPrUpdateMany.mockResolvedValue({ count: 1 });
+            mockRatchetUpdateMany.mockResolvedValue({ count: 1 });
+            await expect(workspaceAccessor.applyPrObservationWithDispatchReset('ws-1', {
+                expectedPrNumber: 42,
                 prCiStatus: 'PENDING',
-                prUpdatedAt: observedAt,
-                ratchetDispatchOutcome: null,
-                ratchetDispatchRetryCount: 0,
-            },
-        });
-    });
-    it('conditionally writes a cached column against the ownership tuple', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 0 });
-        const prUpdatedAt = new Date('2026-07-17T12:00:00.000Z');
-        await expect(workspaceAccessor.updateCachedKanbanColumnIfOwnershipMatches('ws-1', {
-            status: 'READY',
-            prUrl: 'https://github.com/org/repo/pull/42',
-            prState: 'OPEN',
-            prCiStatus: 'PENDING',
-            prUpdatedAt,
-            ratchetEnabled: true,
-            ratchetState: 'CI_RUNNING',
-            ratchetDispatchOutcome: null,
-            ratchetDispatchRetryCount: 0,
-            cachedKanbanColumn: 'WORKING',
-        }, { cachedKanbanColumn: 'WAITING' })).resolves.toBe(false);
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: expect.objectContaining({ status: 'READY', prUpdatedAt }),
-            data: { cachedKanbanColumn: 'WAITING' },
-        });
-    });
-    it('persists an identical PR aggregate without clearing settled dispatch metadata', async () => {
-        const currentUpdatedAt = new Date('2026-07-17T11:59:00.000Z');
-        const prUpdatedAt = new Date('2026-07-17T12:00:00.000Z');
-        mockFindUnique.mockResolvedValue({
-            prUrl: 'https://github.com/org/repo/pull/42',
-            prNumber: 42,
-            prState: 'OPEN',
-            prCiStatus: 'FAILURE',
-            prReviewState: null,
-            prUpdatedAt: currentUpdatedAt,
-            ratchetDispatchOutcome: 'DIED',
-        });
-        mockUpdateMany.mockResolvedValue({ count: 1 });
-        mockTransaction.mockImplementation(async (callback) => callback({
-            workspace: {
-                findUniqueOrThrow: mockFindUnique,
-                update: mockUpdate,
-                updateMany: mockUpdateMany,
-            },
-        }));
-        await workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', {
-            prUrl: 'https://github.com/org/repo/pull/42',
-            prNumber: 42,
-            prState: 'OPEN',
-            prCiStatus: 'FAILURE',
-            prReviewState: null,
-            prUpdatedAt,
-        });
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: {
-                id: 'ws-1',
-                prUrl: 'https://github.com/org/repo/pull/42',
-                prNumber: 42,
                 prState: 'OPEN',
                 prReviewState: null,
-                prCiStatus: 'FAILURE',
-                prUpdatedAt: currentUpdatedAt,
-            },
-            data: {
-                prUrl: 'https://github.com/org/repo/pull/42',
-                prNumber: 42,
-                prState: 'OPEN',
-                prCiStatus: 'FAILURE',
-                prReviewState: null,
+                prHasMergeConflict: false,
                 prUpdatedAt,
-            },
+            })).resolves.toEqual({ applied: true, dispatchReset: true });
+            expect(mockRatchetUpdateMany).toHaveBeenCalledWith({
+                where: { workspaceId: 'ws-1', ...currentDispatch() },
+                data: { dispatchOutcome: null, dispatchRetryCount: 0 },
+            });
         });
-        expect(mockUpdate).not.toHaveBeenCalled();
-    });
-    it('finishes auto-iteration only when the session pointer still matches', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 1 });
-        await expect(workspaceAccessor.finishAutoIterationIfSessionMatches('ws-1', 'session-1', 'STOPPED')).resolves.toBe(true);
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: { id: 'ws-1', autoIterationSessionId: 'session-1' },
-            data: {
-                autoIterationStatus: 'STOPPED',
-                autoIterationSessionId: null,
-            },
+        it('does not reset when the workspace has no ratchet row at all', async () => {
+            mockRatchetFindUnique.mockResolvedValue(null);
+            mockPrUpdateMany.mockResolvedValue({ count: 1 });
+            await expect(workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', changedObservation)).resolves.toEqual({ applied: true, dispatchReset: false });
+            expect(mockRatchetUpdateMany).not.toHaveBeenCalled();
+        });
+        it('reports no write at all when the workspace has no PR row', async () => {
+            mockPrFindUnique.mockResolvedValue(null);
+            await expect(workspaceAccessor.applyPrSnapshotWithDispatchReset('ws-1', changedObservation)).resolves.toEqual({ applied: false, dispatchReset: false });
+            expect(mockPrUpdateMany).not.toHaveBeenCalled();
+            expect(mockRatchetUpdateMany).not.toHaveBeenCalled();
         });
     });
-    it('clears auto-iteration session only when the expected pointer still matches', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 0 });
-        await expect(workspaceAccessor.clearAutoIterationSessionIfMatches('ws-1', 'session-1')).resolves.toBe(false);
+    it('marks workspace as having had sessions with guarded updateMany', async () => {
+        mockUpdateMany.mockResolvedValue({ count: 1 });
+        await workspaceAccessor.markHasHadSessions('ws-1');
         expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: { id: 'ws-1', autoIterationSessionId: 'session-1' },
-            data: { autoIterationSessionId: null },
+            where: { id: 'ws-1', hasHadSessions: false },
+            data: { hasHadSessions: true },
         });
     });
-    it('selects only the auto-iteration execution context', async () => {
+    it('joins the auto-iteration session onto the workspace execution context', async () => {
         mockFindUnique.mockResolvedValue({
             worktreePath: '/tmp/worktree',
-            autoIterationSessionId: 'session-1',
+            autoIteration: { sessionId: 'session-1' },
         });
         await expect(workspaceAccessor.findAutoIterationExecutionContext('ws-1')).resolves.toEqual({
             worktreePath: '/tmp/worktree',
@@ -604,87 +396,19 @@ describe('workspaceAccessor', () => {
         });
         expect(mockFindUnique).toHaveBeenCalledWith({
             where: { id: 'ws-1' },
-            select: { worktreePath: true, autoIterationSessionId: true },
-        });
-    });
-    it('selects only run-script execution state', async () => {
-        const state = {
-            runScriptStatus: 'RUNNING',
-            runScriptPid: 123,
-            runScriptPort: 3000,
-            runScriptStartedAt: new Date('2026-01-01T00:00:00.000Z'),
-        };
-        mockFindUnique.mockResolvedValue(state);
-        await expect(workspaceAccessor.findRunScriptExecutionState('ws-1')).resolves.toEqual(state);
-        expect(mockFindUnique).toHaveBeenCalledWith({
-            where: { id: 'ws-1' },
-            select: {
-                runScriptStatus: true,
-                runScriptPid: true,
-                runScriptPort: true,
-                runScriptStartedAt: true,
-            },
-        });
-    });
-    it('selects only run-script execution state when requiring a result', async () => {
-        const state = {
-            runScriptStatus: 'RUNNING',
-            runScriptPid: 123,
-            runScriptPort: 3000,
-            runScriptStartedAt: new Date('2026-01-01T00:00:00.000Z'),
-        };
-        mockFindUniqueOrThrow.mockResolvedValue(state);
-        await expect(workspaceAccessor.findRunScriptExecutionStateOrThrow('ws-1')).resolves.toEqual(state);
-        expect(mockFindUniqueOrThrow).toHaveBeenCalledWith({
-            where: { id: 'ws-1' },
-            select: {
-                runScriptStatus: true,
-                runScriptPid: true,
-                runScriptPort: true,
-                runScriptStartedAt: true,
-            },
-        });
-    });
-    it('returns false when ratchet session end conditional update affects no rows', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 0 });
-        await expect(workspaceAccessor.recordRatchetSessionEnd('ws-1', 'session-1', 'COMPLETED')).resolves.toBe(false);
-    });
-    it('transitions ratchet state only when enabled and fromState still matches', async () => {
-        const checkedAt = new Date('2026-01-01T00:00:00.000Z');
-        mockUpdateMany.mockResolvedValue({ count: 1 });
-        await expect(workspaceAccessor.transitionRatchetStateIfEnabled('ws-1', 'CI_RUNNING', {
-            ratchetState: 'CI_FAILED',
-            ratchetLastCheckedAt: checkedAt,
-        })).resolves.toBe(true);
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: { id: 'ws-1', ratchetEnabled: true, ratchetState: 'CI_RUNNING' },
-            data: {
-                ratchetState: 'CI_FAILED',
-                ratchetLastCheckedAt: checkedAt,
-            },
+            select: { worktreePath: true, autoIteration: { select: { sessionId: true } } },
         });
     });
-    it('returns false when ratchet state transition loses the compare-and-swap', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 0 });
-        await expect(workspaceAccessor.transitionRatchetStateIfEnabled('ws-1', 'CI_RUNNING', {
-            ratchetState: 'READY',
-            ratchetLastCheckedAt: new Date('2026-01-01T00:00:00.000Z'),
-        })).resolves.toBe(false);
-    });
-    it('settles ratchet state to IDLE only while disabled and fromState still matches', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 1 });
-        await expect(workspaceAccessor.settleRatchetIdleWhileDisabled('ws-1', 'CI_FAILED')).resolves.toBe(true);
-        expect(mockUpdateMany).toHaveBeenCalledWith({
-            where: { id: 'ws-1', ratchetEnabled: false, ratchetState: 'CI_FAILED' },
-            data: {
-                ratchetState: 'IDLE',
-                ratchetLastCheckedAt: expect.any(Date),
-            },
+    it('reads a missing auto-iteration row as a null session rather than throwing', async () => {
+        mockFindUnique.mockResolvedValue({ worktreePath: '/tmp/worktree', autoIteration: null });
+        await expect(workspaceAccessor.findAutoIterationExecutionContext('ws-1')).resolves.toEqual({
+            worktreePath: '/tmp/worktree',
+            autoIterationSessionId: null,
         });
     });
-    it('returns false when the disabled-settle compare-and-swap affects no rows', async () => {
-        mockUpdateMany.mockResolvedValue({ count: 0 });
-        await expect(workspaceAccessor.settleRatchetIdleWhileDisabled('ws-1', 'CI_FAILED')).resolves.toBe(false);
+    it('returns null when the workspace itself is missing', async () => {
+        mockFindUnique.mockResolvedValue(null);
+        await expect(workspaceAccessor.findAutoIterationExecutionContext('gone')).resolves.toBeNull();
     });
     it('appends init output and skips existence check when update succeeds', async () => {
         mockExecuteRaw.mockResolvedValue(1);
@@ -706,40 +430,6 @@ describe('workspaceAccessor', () => {
         mockFindUnique.mockResolvedValue({ id: 'ws-1' });
         await expect(workspaceAccessor.appendInitOutput('ws-1', 'line')).resolves.toBeUndefined();
     });
-    describe('resetStaleRunScriptStatuses', () => {
-        it('returns empty array and skips update when no stale workspaces exist', async () => {
-            mockFindMany.mockResolvedValue([]);
-            const result = await workspaceAccessor.resetStaleRunScriptStatuses();
-            expect(result).toEqual([]);
-            expect(mockUpdateMany).not.toHaveBeenCalled();
-        });
-        it('resets STARTING and STOPPING workspaces to IDLE and returns affected records', async () => {
-            const stale = [
-                { id: 'ws-1', runScriptStatus: 'STARTING' },
-                { id: 'ws-2', runScriptStatus: 'STOPPING' },
-            ];
-            mockFindMany.mockResolvedValue(stale);
-            mockUpdateMany.mockResolvedValue({ count: 2 });
-            const result = await workspaceAccessor.resetStaleRunScriptStatuses();
-            expect(result).toEqual(stale);
-            expect(mockFindMany).toHaveBeenCalledWith({
-                where: { runScriptStatus: { in: ['STARTING', 'STOPPING'] } },
-                select: { id: true, runScriptStatus: true },
-            });
-            expect(mockUpdateMany).toHaveBeenCalledWith({
-                where: {
-                    id: { in: ['ws-1', 'ws-2'] },
-                    runScriptStatus: { in: ['STARTING', 'STOPPING'] },
-                },
-                data: {
-                    runScriptStatus: 'IDLE',
-                    runScriptPid: null,
-                    runScriptPort: null,
-                    runScriptStartedAt: null,
-                },
-            });
-        });
-    });
     describe('findStaleArchivingWithProject', () => {
         beforeEach(() => {
             vi.useFakeTimers();
@@ -758,13 +448,13 @@ describe('workspaceAccessor', () => {
             };
             mockFindMany.mockResolvedValue([staleWorkspace]);
             const result = await workspaceAccessor.findStaleArchivingWithProject();
-            expect(result).toEqual([staleWorkspace]);
+            expect(result).toEqual([expect.objectContaining(staleWorkspace)]);
             expect(mockFindMany).toHaveBeenCalledWith({
                 where: {
                     status: 'ARCHIVING',
                     updatedAt: { lt: expect.any(Date) },
                 },
-                include: { project: true },
+                include: { project: true, pr: true, autoIteration: true },
                 orderBy: { updatedAt: 'asc' },
             });
             const callArgs = mockFindMany.mock.calls[0][0];
@@ -776,32 +466,5 @@ describe('workspaceAccessor', () => {
             expect(result).toEqual([]);
         });
     });
-    it('finds one ratchet candidate by id with READY and PR filters', async () => {
-        mockFindFirst.mockResolvedValue({ id: 'ws-1', prUrl: 'https://github.com/org/repo/pull/1' });
-        await workspaceAccessor.findForRatchetById('ws-1');
-        expect(mockFindFirst).toHaveBeenCalledWith({
-            where: {
-                id: 'ws-1',
-                status: 'READY',
-                prUrl: { not: null },
-            },
-            select: {
-                id: true,
-                prUrl: true,
-                prNumber: true,
-                prState: true,
-                prCiStatus: true,
-                defaultSessionProvider: true,
-                ratchetSessionProvider: true,
-                ratchetEnabled: true,
-                ratchetState: true,
-                ratchetActiveSessionId: true,
-                ratchetLastCiRunId: true,
-                ratchetDispatchOutcome: true,
-                ratchetDispatchRetryCount: true,
-                prReviewLastCheckedAt: true,
-            },
-        });
-    });
 });
 //# sourceMappingURL=workspace.accessor.test.js.map