factory-factory 0.3.21 → 0.4.1

package/dist/src/backend/orchestration/event-collector.orchestrator.test.js

@@ -1,4 +1,14 @@
+import { EventEmitter } from 'node:events';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((promiseResolve, promiseReject) => {
+        resolve = promiseResolve;
+        reject = promiseReject;
+    });
+    return { promise, resolve, reject };
+}
 function createMockStore() {
     return {
         upsert: vi.fn(),
@@ -10,25 +20,42 @@ function createMockStore() {
 }
 vi.mock('@/backend/services/workspace', () => ({
     WORKSPACE_STATE_CHANGED: 'workspace_state_changed',
-    workspaceStateMachine: { on: vi.fn() },
-    workspaceActivityService: { on: vi.fn(), clearWorkspace: vi.fn() },
+    workspaceStateMachine: { on: vi.fn(), off: vi.fn() },
+    workspaceActivityService: { on: vi.fn(), off: vi.fn(), clearWorkspace: vi.fn() },
+    kanbanStateService: { updateCachedKanbanColumn: vi.fn().mockResolvedValue(undefined) },
+    workspaceDataService: { findRatchetProjection: vi.fn() },
+    workspaceSnapshotStore: {
+        upsert: vi.fn(),
+        getByWorkspaceId: vi.fn(),
+        getAllWorkspaceIds: vi.fn().mockReturnValue([]),
+        remove: vi.fn(),
+    },
     computePendingRequestType: vi.fn().mockReturnValue(null),
 }));
 vi.mock('@/backend/services/github', () => ({
+    PR_DISPATCH_INVALIDATED: 'pr_dispatch_invalidated',
     PR_SNAPSHOT_UPDATED: 'pr_snapshot_updated',
     prSnapshotService: {
         on: vi.fn(),
+        off: vi.fn(),
         refreshWorkspace: vi.fn().mockResolvedValue({ success: false, reason: 'no_pr_url' }),
     },
+    prFetchRegistry: { removeWorkspace: vi.fn() },
 }));
 vi.mock('@/backend/services/ratchet', () => ({
+    RATCHET_DISPATCH_CHANGED: 'ratchet_dispatch_changed',
     RATCHET_STATE_CHANGED: 'ratchet_state_changed',
     RATCHET_TOGGLED: 'ratchet_toggled',
-    ratchetService: { on: vi.fn(), checkWorkspaceById: vi.fn().mockResolvedValue(null) },
+    ratchetService: {
+        on: vi.fn(),
+        off: vi.fn(),
+        checkWorkspaceById: vi.fn().mockResolvedValue(null),
+        markPrClosed: vi.fn().mockResolvedValue(undefined),
+    },
 }));
 vi.mock('@/backend/services/run-script', () => ({
     RUN_SCRIPT_STATUS_CHANGED: 'run_script_status_changed',
-    runScriptStateMachine: { on: vi.fn() },
+    runScriptStateMachine: { on: vi.fn(), off: vi.fn() },
 }));
 vi.mock('@/backend/services/session', () => ({
     sessionDataService: {
@@ -57,14 +84,6 @@ vi.mock('@/backend/services/terminal', () => ({
         destroyWorkspaceTerminals: vi.fn(),
     },
 }));
-vi.mock('@/backend/services/workspace-snapshot-store.service', () => ({
-    workspaceSnapshotStore: {
-        upsert: vi.fn(),
-        getByWorkspaceId: vi.fn(),
-        getAllWorkspaceIds: vi.fn().mockReturnValue([]),
-        remove: vi.fn(),
-    },
-}));
 vi.mock('@/backend/services/logger.service', () => ({
     createLogger: () => ({
         info: vi.fn(),
@@ -73,14 +92,50 @@ vi.mock('@/backend/services/logger.service', () => ({
         error: vi.fn(),
     }),
 }));
-import { prSnapshotService } from '../../backend/services/github/index.js';
+vi.mock('@/backend/services/linear', () => ({
+    linearStateSyncService: { markIssueCompleted: vi.fn() },
+}));
+vi.mock('./linear-config.helper', () => ({
+    getWorkspaceLinearContext: vi.fn().mockResolvedValue(null),
+}));
+import { prFetchRegistry, prSnapshotService } from '../../backend/services/github/index.js';
+import { linearStateSyncService } from '../../backend/services/linear/index.js';
 import { ratchetService } from '../../backend/services/ratchet/index.js';
 import { runScriptStateMachine } from '../../backend/services/run-script/index.js';
 import { chatEventForwarderService, sessionDataService, sessionDomainService, sessionService, } from '../../backend/services/session/index.js';
 import { terminalService } from '../../backend/services/terminal/index.js';
-import { computePendingRequestType, workspaceActivityService, workspaceStateMachine, } from '../../backend/services/workspace/index.js';
-import { workspaceSnapshotStore } from '../../backend/services/workspace-snapshot-store.service.js';
-import { configureEventCollector, EventCoalescer, stopEventCollector, } from './event-collector.orchestrator.js';
+import { computePendingRequestType, kanbanStateService, workspaceActivityService, workspaceDataService, workspaceSnapshotStore, workspaceStateMachine, } from '../../backend/services/workspace/index.js';
+import { createEventCollectorOrchestrator, EventCoalescer, } from './event-collector.orchestrator.js';
+import { getWorkspaceLinearContext } from './linear-config.helper.js';
+let activeEventCollector = null;
+function configureEventCollector() {
+    activeEventCollector?.stop();
+    activeEventCollector = createEventCollectorOrchestrator({
+        chatEventForwarderService,
+        computePendingRequestType,
+        createLogger: () => ({ info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() }),
+        getWorkspaceLinearContext,
+        kanbanStateService,
+        linearStateSyncService,
+        prFetchRegistry,
+        prSnapshotService,
+        ratchetService,
+        runScriptStateMachine,
+        sessionDataService,
+        sessionDomainService,
+        sessionService,
+        terminalService,
+        workspaceActivityService,
+        workspaceSnapshotStore,
+        workspaceStateMachine,
+        workspaceDataService,
+    });
+    activeEventCollector.start();
+}
+function stopEventCollector() {
+    activeEventCollector?.stop();
+    activeEventCollector = null;
+}
 describe('EventCoalescer', () => {
     let mockStore;
     beforeEach(() => {
@@ -96,7 +151,15 @@ describe('EventCoalescer', () => {
         expect(mockStore.upsert).not.toHaveBeenCalled();
         vi.advanceTimersByTime(150);
         expect(mockStore.upsert).toHaveBeenCalledTimes(1);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY' }, 'event:workspace_state_changed');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY' }, 'event:workspace_state_changed', expect.any(Number));
+    });
+    it('cancels a pending update when a workspace is removed', () => {
+        const coalescer = new EventCoalescer(mockStore, 150);
+        coalescer.enqueue('ws-1', { isWorking: true }, 'test');
+        coalescer.removeWorkspace('ws-1');
+        vi.advanceTimersByTime(150);
+        expect(mockStore.remove).toHaveBeenCalledWith('ws-1');
+        expect(mockStore.upsert).not.toHaveBeenCalled();
     });
     it('coalesces rapid-fire events for same workspace into single upsert', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
@@ -108,7 +171,7 @@ describe('EventCoalescer', () => {
         expect(mockStore.upsert).not.toHaveBeenCalled();
         vi.advanceTimersByTime(150);
         expect(mockStore.upsert).toHaveBeenCalledTimes(1);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY', ratchetState: 'CI_RUNNING', isWorking: true }, 'event:workspace_state_changed+event:ratchet_state_changed+event:workspace_active');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY', ratchetState: 'CI_RUNNING', isWorking: true }, 'event:workspace_state_changed+event:ratchet_state_changed+event:workspace_active', expect.any(Number));
     });
     it('produces separate upserts for different workspaces', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
@@ -116,8 +179,8 @@ describe('EventCoalescer', () => {
         coalescer.enqueue('ws-2', { isWorking: true }, 'event:workspace_active');
         vi.advanceTimersByTime(150);
         expect(mockStore.upsert).toHaveBeenCalledTimes(2);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY' }, 'event:workspace_state_changed');
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-2', { isWorking: true }, 'event:workspace_active');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY' }, 'event:workspace_state_changed', expect.any(Number));
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-2', { isWorking: true }, 'event:workspace_active', expect.any(Number));
     });
     it('skips upsert for unknown workspace without projectId', () => {
         mockStore.getByWorkspaceId.mockReturnValue(undefined);
@@ -132,7 +195,7 @@ describe('EventCoalescer', () => {
         coalescer.enqueue('ws-1', { status: 'READY' }, 'event:workspace_state_changed');
         vi.advanceTimersByTime(150);
         expect(mockStore.upsert).toHaveBeenCalledTimes(1);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY' }, 'event:workspace_state_changed');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY' }, 'event:workspace_state_changed', expect.any(Number));
     });
     it('flushAll() flushes all pending updates immediately', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
@@ -148,7 +211,7 @@ describe('EventCoalescer', () => {
         coalescer.enqueue('ws-1', { status: 'READY' }, 'event:workspace_state_changed');
         coalescer.enqueue('ws-1', { ratchetState: 'IDLE' }, 'event:ratchet_state_changed');
         vi.advanceTimersByTime(150);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', expect.any(Object), 'event:workspace_state_changed+event:ratchet_state_changed');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', expect.any(Object), 'event:workspace_state_changed+event:ratchet_state_changed', expect.any(Number));
     });
     it('tracks pendingCount correctly', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
@@ -175,7 +238,7 @@ describe('EventCoalescer', () => {
         coalescer.enqueue('ws-1', { isWorking: true }, 'event:workspace_active', {
             immediate: true,
         });
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { isWorking: true }, 'event:workspace_active');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { isWorking: true }, 'event:workspace_active', expect.any(Number));
         expect(coalescer.pendingCount).toBe(0);
     });
 });
@@ -192,7 +255,7 @@ describe('Event-to-field mapping', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
         coalescer.enqueue('ws-1', { status: 'READY' }, 'event:workspace_state_changed');
         vi.advanceTimersByTime(150);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY' }, 'event:workspace_state_changed');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY' }, 'event:workspace_state_changed', expect.any(Number));
     });
     it('maps PR snapshot to { prNumber, prState, prCiStatus } without prReviewState', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
@@ -207,31 +270,31 @@ describe('Event-to-field mapping', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
         coalescer.enqueue('ws-1', { ratchetState: 'CI_RUNNING' }, 'event:ratchet_state_changed');
         vi.advanceTimersByTime(150);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { ratchetState: 'CI_RUNNING' }, 'event:ratchet_state_changed');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { ratchetState: 'CI_RUNNING' }, 'event:ratchet_state_changed', expect.any(Number));
     });
     it('maps ratchet toggle change to { ratchetEnabled, ratchetState }', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
         coalescer.enqueue('ws-1', { ratchetEnabled: true, ratchetState: 'CI_RUNNING' }, 'event:ratchet_toggled');
         vi.advanceTimersByTime(150);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { ratchetEnabled: true, ratchetState: 'CI_RUNNING' }, 'event:ratchet_toggled');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { ratchetEnabled: true, ratchetState: 'CI_RUNNING' }, 'event:ratchet_toggled', expect.any(Number));
     });
     it('maps run-script status change to { runScriptStatus }', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
         coalescer.enqueue('ws-1', { runScriptStatus: 'RUNNING' }, 'event:run_script_status_changed');
         vi.advanceTimersByTime(150);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { runScriptStatus: 'RUNNING' }, 'event:run_script_status_changed');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { runScriptStatus: 'RUNNING' }, 'event:run_script_status_changed', expect.any(Number));
     });
     it('maps workspace_active to { isWorking: true }', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
         coalescer.enqueue('ws-1', { isWorking: true }, 'event:workspace_active');
         vi.advanceTimersByTime(150);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { isWorking: true }, 'event:workspace_active');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { isWorking: true }, 'event:workspace_active', expect.any(Number));
     });
     it('maps workspace_idle to { isWorking: false }', () => {
         const coalescer = new EventCoalescer(mockStore, 150);
         coalescer.enqueue('ws-1', { isWorking: false }, 'event:workspace_idle');
         vi.advanceTimersByTime(150);
-        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { isWorking: false }, 'event:workspace_idle');
+        expect(mockStore.upsert).toHaveBeenCalledWith('ws-1', { isWorking: false }, 'event:workspace_idle', expect.any(Number));
     });
 });
 describe('configureEventCollector', () => {
@@ -243,12 +306,14 @@ describe('configureEventCollector', () => {
         vi.useRealTimers();
         stopEventCollector();
     });
-    it('registers 10 event listeners on domain singletons', () => {
+    it('registers 12 event listeners on domain singletons', () => {
         configureEventCollector();
         expect(workspaceStateMachine.on).toHaveBeenCalledWith('workspace_state_changed', expect.any(Function));
         expect(prSnapshotService.on).toHaveBeenCalledWith('pr_snapshot_updated', expect.any(Function));
+        expect(prSnapshotService.on).toHaveBeenCalledWith('pr_dispatch_invalidated', expect.any(Function));
         expect(ratchetService.on).toHaveBeenCalledWith('ratchet_state_changed', expect.any(Function));
         expect(ratchetService.on).toHaveBeenCalledWith('ratchet_toggled', expect.any(Function));
+        expect(ratchetService.on).toHaveBeenCalledWith('ratchet_dispatch_changed', expect.any(Function));
         expect(runScriptStateMachine.on).toHaveBeenCalledWith('run_script_status_changed', expect.any(Function));
         expect(workspaceActivityService.on).toHaveBeenCalledWith('workspace_active', expect.any(Function));
         expect(workspaceActivityService.on).toHaveBeenCalledWith('workspace_idle', expect.any(Function));
@@ -272,6 +337,7 @@ describe('configureEventCollector', () => {
         await Promise.resolve();
         expect(workspaceSnapshotStore.remove).toHaveBeenCalledWith('ws-archived');
         expect(workspaceActivityService.clearWorkspace).toHaveBeenCalledWith('ws-archived');
+        expect(prFetchRegistry.removeWorkspace).toHaveBeenCalledWith('ws-archived');
         expect(sessionService.stopWorkspaceSessions).toHaveBeenCalledWith('ws-archived');
         expect(terminalService.destroyWorkspaceTerminals).toHaveBeenCalledWith('ws-archived');
         expect(workspaceSnapshotStore.upsert).not.toHaveBeenCalled();
@@ -285,14 +351,79 @@ describe('configureEventCollector', () => {
             .mocked(workspaceStateMachine.on)
             .mock.calls.find((call) => call[0] === 'workspace_state_changed');
         const handler = onCall[1];
-        handler({ workspaceId: 'ws-1', fromStatus: 'NEW', toStatus: 'READY' });
+        handler({
+            workspaceId: 'ws-1',
+            fromStatus: 'NEW',
+            toStatus: 'READY',
+            workspace: {
+                projectId: 'proj-1',
+                name: 'ws',
+                branchName: null,
+                createdAt: new Date('2026-01-01T00:00:00.000Z'),
+            },
+        });
         expect(workspaceSnapshotStore.upsert).toHaveBeenCalledTimes(1);
-        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY' }, 'event:workspace_state_changed');
+        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', expect.objectContaining({ status: 'READY' }), 'event:workspace_state_changed', expect.any(Number));
+    });
+    it('workspace event with re-read row includes co-updated snapshot fields in the upsert', () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+        });
+        configureEventCollector();
+        const onCall = vi
+            .mocked(workspaceStateMachine.on)
+            .mock.calls.find((call) => call[0] === 'workspace_state_changed');
+        const handler = onCall[1];
+        handler({
+            workspaceId: 'ws-1',
+            fromStatus: 'PROVISIONING',
+            toStatus: 'READY',
+            workspace: {
+                projectId: 'proj-1',
+                name: 'My workspace',
+                branchName: 'feature/test',
+                createdAt: new Date('2026-01-01T00:00:00.000Z'),
+            },
+        });
+        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', {
+            status: 'READY',
+            projectId: 'proj-1',
+            name: 'My workspace',
+            branchName: 'feature/test',
+            createdAt: '2026-01-01T00:00:00.000Z',
+        }, 'event:workspace_state_changed', expect.any(Number));
     });
-    it('ratchet_state_changed is applied immediately', () => {
+    it('workspace event with re-read row seeds a workspace unknown to the store', () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue(undefined);
+        configureEventCollector();
+        const onCall = vi
+            .mocked(workspaceStateMachine.on)
+            .mock.calls.find((call) => call[0] === 'workspace_state_changed');
+        const handler = onCall[1];
+        handler({
+            workspaceId: 'ws-new',
+            fromStatus: 'NEW',
+            toStatus: 'PROVISIONING',
+            workspace: {
+                projectId: 'proj-1',
+                name: 'Fresh workspace',
+                branchName: null,
+                createdAt: new Date('2026-01-01T00:00:00.000Z'),
+            },
+        });
+        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-new', expect.objectContaining({ status: 'PROVISIONING', projectId: 'proj-1' }), 'event:workspace_state_changed', expect.any(Number));
+    });
+    it('ratchet_state_changed projects state authoritatively', async () => {
         vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
             projectId: 'proj-1',
         });
+        vi.mocked(workspaceDataService.findRatchetProjection).mockResolvedValue({
+            status: 'READY',
+            ratchetEnabled: true,
+            ratchetState: 'MERGED',
+            ratchetDispatchOutcome: null,
+            ratchetDispatchRetryCount: 0,
+        });
         configureEventCollector();
         const onCall = vi
             .mocked(ratchetService.on)
@@ -303,7 +434,186 @@ describe('configureEventCollector', () => {
             fromState: 'READY',
             toState: 'MERGED',
         });
-        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { ratchetState: 'MERGED' }, 'event:ratchet_state_changed');
+        await vi.waitFor(() => expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', expect.objectContaining({ ratchetState: 'MERGED' }), 'projection:ratchet_authoritative', expect.any(Number)));
+        expect(kanbanStateService.updateCachedKanbanColumn).toHaveBeenCalledWith('ws-1');
+    });
+    it('ratchet_dispatch_changed publishes authoritative ownership and refreshes the cache', async () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+        });
+        vi.mocked(workspaceDataService.findRatchetProjection).mockResolvedValue({
+            status: 'READY',
+            ratchetEnabled: true,
+            ratchetState: 'CI_FAILED',
+            ratchetDispatchOutcome: 'DIED',
+            ratchetDispatchRetryCount: 3,
+        });
+        configureEventCollector();
+        const handler = vi
+            .mocked(ratchetService.on)
+            .mock.calls.find((call) => call[0] === 'ratchet_dispatch_changed')[1];
+        handler({ workspaceId: 'ws-1' });
+        await vi.waitFor(() => expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', expect.objectContaining({
+            ratchetDispatchOutcome: 'DIED',
+            ratchetDispatchRetryCount: 3,
+        }), 'projection:ratchet_authoritative', expect.any(Number)));
+        expect(kanbanStateService.updateCachedKanbanColumn).toHaveBeenCalledWith('ws-1');
+    });
+    it('projects the direct CI status carried by a dispatch invalidation', () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+        });
+        vi.mocked(workspaceDataService.findRatchetProjection).mockResolvedValue({
+            status: 'READY',
+            ratchetEnabled: true,
+            ratchetState: 'CI_RUNNING',
+            ratchetDispatchOutcome: null,
+            ratchetDispatchRetryCount: 0,
+        });
+        configureEventCollector();
+        const handler = vi
+            .mocked(prSnapshotService.on)
+            .mock.calls.find((call) => call[0] === 'pr_dispatch_invalidated')[1];
+        handler({ workspaceId: 'ws-direct-ci', prCiStatus: 'PENDING' });
+        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-direct-ci', { prCiStatus: 'PENDING' }, 'event:pr_dispatch_invalidated', expect.any(Number));
+    });
+    it('does not recreate an archived snapshot after an in-flight Ratchet projection', async () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+        });
+        const pendingRead = deferred();
+        vi.mocked(workspaceDataService.findRatchetProjection).mockReturnValue(pendingRead.promise);
+        configureEventCollector();
+        const dispatchHandler = vi
+            .mocked(ratchetService.on)
+            .mock.calls.find((call) => call[0] === 'ratchet_dispatch_changed')[1];
+        const workspaceHandler = vi
+            .mocked(workspaceStateMachine.on)
+            .mock.calls.find((call) => call[0] === 'workspace_state_changed')[1];
+        dispatchHandler({ workspaceId: 'ws-archived-race' });
+        await vi.waitFor(() => expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(1));
+        workspaceHandler({
+            workspaceId: 'ws-archived-race',
+            fromStatus: 'READY',
+            toStatus: 'ARCHIVED',
+        });
+        pendingRead.resolve({
+            status: 'READY',
+            ratchetEnabled: true,
+            ratchetState: 'CI_FAILED',
+            ratchetDispatchOutcome: 'DIED',
+            ratchetDispatchRetryCount: 3,
+        });
+        await Promise.resolve();
+        expect(workspaceSnapshotStore.upsert).not.toHaveBeenCalledWith('ws-archived-race', expect.anything(), 'projection:ratchet_authoritative', expect.any(Number));
+    });
+    it('retries a failed authoritative projection without another invalidation', async () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+        });
+        vi.mocked(workspaceDataService.findRatchetProjection)
+            .mockRejectedValueOnce(new Error('read failed'))
+            .mockResolvedValue({
+            status: 'READY',
+            ratchetEnabled: true,
+            ratchetState: 'CI_FAILED',
+            ratchetDispatchOutcome: 'DIED',
+            ratchetDispatchRetryCount: 3,
+        });
+        configureEventCollector();
+        const handler = vi
+            .mocked(ratchetService.on)
+            .mock.calls.find((call) => call[0] === 'ratchet_dispatch_changed')[1];
+        handler({ workspaceId: 'ws-retry' });
+        await vi.waitFor(() => expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(1));
+        await vi.advanceTimersByTimeAsync(1000);
+        await vi.waitFor(() => expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(2));
+        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-retry', expect.objectContaining({ ratchetDispatchOutcome: 'DIED' }), 'projection:ratchet_authoritative', expect.any(Number));
+    });
+    it('backs off materially after a persistent authoritative projection failure', async () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+        });
+        vi.mocked(workspaceDataService.findRatchetProjection).mockRejectedValue(new Error('read failed'));
+        configureEventCollector();
+        const handler = vi
+            .mocked(ratchetService.on)
+            .mock.calls.find((call) => call[0] === 'ratchet_dispatch_changed')[1];
+        handler({ workspaceId: 'ws-persistent-failure' });
+        await vi.waitFor(() => expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(1));
+        await vi.advanceTimersByTimeAsync(999);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(1);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(2);
+        await vi.advanceTimersByTimeAsync(2000);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(3);
+        await vi.advanceTimersByTimeAsync(120_000);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(3);
+    });
+    it('backs off when an invalidation arrives during a failed projection read', async () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+        });
+        const pendingRead = deferred();
+        vi.mocked(workspaceDataService.findRatchetProjection)
+            .mockReturnValueOnce(pendingRead.promise)
+            .mockResolvedValue({
+            status: 'READY',
+            ratchetEnabled: true,
+            ratchetState: 'CI_FAILED',
+            ratchetDispatchOutcome: 'DIED',
+            ratchetDispatchRetryCount: 3,
+        });
+        configureEventCollector();
+        const handler = vi
+            .mocked(ratchetService.on)
+            .mock.calls.find((call) => call[0] === 'ratchet_dispatch_changed')[1];
+        handler({ workspaceId: 'ws-concurrent-invalidation' });
+        await vi.waitFor(() => expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(1));
+        handler({ workspaceId: 'ws-concurrent-invalidation' });
+        pendingRead.reject(new Error('read failed'));
+        await Promise.resolve();
+        await vi.advanceTimersByTimeAsync(999);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(1);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(2);
+    });
+    it('does not reset the projection failure budget for repeated invalidations', async () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+        });
+        vi.mocked(workspaceDataService.findRatchetProjection).mockRejectedValue(new Error('read failed'));
+        configureEventCollector();
+        const handler = vi
+            .mocked(ratchetService.on)
+            .mock.calls.find((call) => call[0] === 'ratchet_dispatch_changed')[1];
+        handler({ workspaceId: 'ws-invalidation-stream' });
+        await vi.waitFor(() => expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(1));
+        handler({ workspaceId: 'ws-invalidation-stream' });
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(2);
+        handler({ workspaceId: 'ws-invalidation-stream' });
+        await vi.advanceTimersByTimeAsync(1999);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(2);
+        await vi.advanceTimersByTimeAsync(1);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(3);
+        await vi.advanceTimersByTimeAsync(120_000);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(3);
+    });
+    it('cancels an authoritative projection retry when stopped', async () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+        });
+        vi.mocked(workspaceDataService.findRatchetProjection).mockRejectedValue(new Error('read failed'));
+        configureEventCollector();
+        const handler = vi
+            .mocked(ratchetService.on)
+            .mock.calls.find((call) => call[0] === 'ratchet_dispatch_changed')[1];
+        handler({ workspaceId: 'ws-stop-retry' });
+        await vi.waitFor(() => expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(1));
+        stopEventCollector();
+        await vi.advanceTimersByTimeAsync(100);
+        expect(workspaceDataService.findRatchetProjection).toHaveBeenCalledTimes(1);
     });
     it('pr_snapshot_updated without prUrl does not overwrite existing prUrl in store', () => {
         vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
@@ -325,7 +635,7 @@ describe('configureEventCollector', () => {
             prNumber: 42,
             prState: 'OPEN',
             prCiStatus: 'SUCCESS',
-        }, 'event:pr_snapshot_updated');
+        }, 'event:pr_snapshot_updated', expect.any(Number));
     });
     it('triggers immediate ratchet recompute when PR identity changes', () => {
         vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
@@ -346,7 +656,84 @@ describe('configureEventCollector', () => {
             prReviewState: null,
             prUrl: 'https://github.com/org/repo/pull/42',
         });
-        expect(ratchetService.checkWorkspaceById).toHaveBeenCalledWith('ws-1');
+        expect(ratchetService.checkWorkspaceById).toHaveBeenCalledWith('ws-1', {
+            bypassPrFetchCooldown: true,
+        });
+    });
+    it.each([
+        'OPEN',
+        'APPROVED',
+        'CHANGES_REQUESTED',
+        'DRAFT',
+    ])('triggers immediate ratchet recompute when a closed PR is reopened as %s', (reopenedState) => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+            prNumber: 42,
+            prUrl: 'https://github.com/org/repo/pull/42',
+            prState: 'CLOSED',
+        });
+        configureEventCollector();
+        const onCall = vi
+            .mocked(prSnapshotService.on)
+            .mock.calls.find((call) => call[0] === 'pr_snapshot_updated');
+        const handler = onCall[1];
+        handler({
+            workspaceId: 'ws-1',
+            prNumber: 42,
+            prState: reopenedState,
+            prCiStatus: 'PENDING',
+            prReviewState: null,
+            prUrl: 'https://github.com/org/repo/pull/42',
+        });
+        expect(ratchetService.checkWorkspaceById).toHaveBeenCalledWith('ws-1', {
+            bypassPrFetchCooldown: true,
+        });
+    });
+    it('settles ratchet state without a recompute when PR is closed', () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+            prNumber: 42,
+            prUrl: 'https://github.com/org/repo/pull/42',
+            prState: 'OPEN',
+        });
+        configureEventCollector();
+        const onCall = vi
+            .mocked(prSnapshotService.on)
+            .mock.calls.find((call) => call[0] === 'pr_snapshot_updated');
+        const handler = onCall[1];
+        handler({
+            workspaceId: 'ws-1',
+            prNumber: 42,
+            prState: 'CLOSED',
+            prCiStatus: 'UNKNOWN',
+            prReviewState: null,
+            prUrl: 'https://github.com/org/repo/pull/42',
+        });
+        expect(ratchetService.checkWorkspaceById).not.toHaveBeenCalled();
+        expect(ratchetService.markPrClosed).toHaveBeenCalledWith('ws-1');
+    });
+    it('re-settles ratchet state when PR stays closed across syncs', () => {
+        vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
+            projectId: 'proj-1',
+            prNumber: 42,
+            prUrl: 'https://github.com/org/repo/pull/42',
+            prState: 'CLOSED',
+        });
+        configureEventCollector();
+        const onCall = vi
+            .mocked(prSnapshotService.on)
+            .mock.calls.find((call) => call[0] === 'pr_snapshot_updated');
+        const handler = onCall[1];
+        handler({
+            workspaceId: 'ws-1',
+            prNumber: 42,
+            prState: 'CLOSED',
+            prCiStatus: 'UNKNOWN',
+            prReviewState: null,
+            prUrl: 'https://github.com/org/repo/pull/42',
+        });
+        expect(ratchetService.checkWorkspaceById).not.toHaveBeenCalled();
+        expect(ratchetService.markPrClosed).toHaveBeenCalledWith('ws-1');
     });
     it('still triggers ratchet recompute when store mutates snapshot during immediate upsert', () => {
         const existingSnapshot = {
@@ -362,6 +749,7 @@ describe('configureEventCollector', () => {
             if (update.prUrl !== undefined) {
                 existingSnapshot.prUrl = update.prUrl;
             }
+            return { accepted: true, changed: true, emitted: true };
         });
         configureEventCollector();
         const onCall = vi
@@ -376,7 +764,9 @@ describe('configureEventCollector', () => {
             prReviewState: null,
             prUrl: 'https://github.com/org/repo/pull/42',
         });
-        expect(ratchetService.checkWorkspaceById).toHaveBeenCalledWith('ws-1');
+        expect(ratchetService.checkWorkspaceById).toHaveBeenCalledWith('ws-1', {
+            bypassPrFetchCooldown: true,
+        });
     });
     it('does not trigger immediate ratchet recompute when PR identity is unchanged', () => {
         vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
@@ -413,7 +803,7 @@ describe('configureEventCollector', () => {
             enabled: true,
             ratchetState: 'CI_RUNNING',
         });
-        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { ratchetEnabled: true, ratchetState: 'CI_RUNNING' }, 'event:ratchet_toggled');
+        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { ratchetEnabled: true, ratchetState: 'CI_RUNNING' }, 'event:ratchet_toggled', expect.any(Number));
     });
     it('stopEventCollector flushes pending and clears coalescer', () => {
         vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
@@ -428,11 +818,17 @@ describe('configureEventCollector', () => {
             workspaceId: 'ws-1',
             fromStatus: 'NEW',
             toStatus: 'READY',
+            workspace: {
+                projectId: 'proj-1',
+                name: 'ws',
+                branchName: null,
+                createdAt: new Date('2026-01-01T00:00:00.000Z'),
+            },
         });
         expect(workspaceSnapshotStore.upsert).toHaveBeenCalledTimes(1);
         stopEventCollector();
         expect(workspaceSnapshotStore.upsert).toHaveBeenCalledTimes(1);
-        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { status: 'READY' }, 'event:workspace_state_changed');
+        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', expect.objectContaining({ status: 'READY' }), 'event:workspace_state_changed', expect.any(Number));
     });
     it('workspace_active enqueues immediate working state and does not refresh session summaries', () => {
         vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
@@ -444,7 +840,7 @@ describe('configureEventCollector', () => {
             .mock.calls.find((call) => call[0] === 'workspace_active');
         const handler = onCall[1];
         handler({ workspaceId: 'ws-1' });
-        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { isWorking: true, hasHadSessions: true }, 'event:workspace_active');
+        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { isWorking: true, hasHadSessions: true }, 'event:workspace_active', expect.any(Number));
         expect(sessionDataService.findAgentSessionsByWorkspaceId).not.toHaveBeenCalled();
     });
     it('workspace_idle enqueues immediate idle state and triggers throttled PR refresh', () => {
@@ -457,7 +853,7 @@ describe('configureEventCollector', () => {
             .mock.calls.find((call) => call[0] === 'workspace_idle');
         const handler = onCall[1];
         handler({ workspaceId: 'ws-1' });
-        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { isWorking: false, hasHadSessions: true }, 'event:workspace_idle');
+        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { isWorking: false, hasHadSessions: true }, 'event:workspace_idle', expect.any(Number));
         expect(prSnapshotService.refreshWorkspace).toHaveBeenCalledWith('ws-1');
         expect(sessionDataService.findAgentSessionsByWorkspaceId).not.toHaveBeenCalled();
     });
@@ -504,7 +900,7 @@ describe('configureEventCollector', () => {
                     sessionId: 's-1',
                 }),
             ]),
-        }), expect.stringContaining('event:session_activity_changed'));
+        }), expect.stringContaining('event:session_activity_changed'), expect.any(Number));
     });
     it('runtime_changed refreshes session summaries for the session workspace', async () => {
         vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
@@ -540,7 +936,7 @@ describe('configureEventCollector', () => {
                     sessionId: 's-1',
                 }),
             ]),
-        }), expect.stringContaining('event:session_runtime_changed'));
+        }), expect.stringContaining('event:session_runtime_changed'), expect.any(Number));
     });
     it('pending_request_changed refreshes pendingRequestType', async () => {
         vi.mocked(workspaceSnapshotStore.getByWorkspaceId).mockReturnValue({
@@ -570,8 +966,71 @@ describe('configureEventCollector', () => {
         await Promise.resolve();
         vi.advanceTimersByTime(150);
         expect(computePendingRequestType).toHaveBeenCalledWith(['s-1'], expect.any(Map));
-        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { pendingRequestType: 'permission_request' }, 'event:pending_request_changed');
+        expect(workspaceSnapshotStore.upsert).toHaveBeenCalledWith('ws-1', { pendingRequestType: 'permission_request' }, 'event:pending_request_changed', expect.any(Number));
         expect(chatEventForwarderService.getAllPendingRequests).toHaveBeenCalledTimes(1);
     });
 });
+describe('per-graph event collector lifecycle', () => {
+    function createSource() {
+        return new EventEmitter();
+    }
+    function createDependencies(store) {
+        return {
+            chatEventForwarderService,
+            computePendingRequestType,
+            createLogger: () => ({ info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() }),
+            getWorkspaceLinearContext: vi.fn().mockResolvedValue(null),
+            linearStateSyncService: { markIssueCompleted: vi.fn() },
+            prSnapshotService: Object.assign(createSource(), {
+                refreshWorkspace: vi.fn().mockResolvedValue({ success: false, reason: 'no_pr_url' }),
+            }),
+            ratchetService: Object.assign(createSource(), {
+                checkWorkspaceById: vi.fn().mockResolvedValue(null),
+                markPrClosed: vi.fn().mockResolvedValue(undefined),
+            }),
+            runScriptStateMachine: createSource(),
+            sessionDataService,
+            sessionDomainService: createSource(),
+            sessionService,
+            terminalService,
+            workspaceActivityService: Object.assign(createSource(), { clearWorkspace: vi.fn() }),
+            workspaceSnapshotStore: Object.assign(store, { getAllWorkspaceIds: vi.fn(() => []) }),
+            workspaceStateMachine: createSource(),
+        };
+    }
+    it('keeps event sources, stores, and listeners isolated between graphs', () => {
+        const firstStore = createMockStore();
+        const secondStore = createMockStore();
+        const firstDependencies = createDependencies(firstStore);
+        const secondDependencies = createDependencies(secondStore);
+        const first = createEventCollectorOrchestrator(firstDependencies);
+        const second = createEventCollectorOrchestrator(secondDependencies);
+        first.start();
+        second.start();
+        firstDependencies.workspaceActivityService.emit('workspace_active', { workspaceId: 'first' });
+        expect(firstStore.upsert).toHaveBeenCalledWith('first', { isWorking: true, hasHadSessions: true }, 'event:workspace_active', expect.any(Number));
+        expect(secondStore.upsert).not.toHaveBeenCalled();
+        first.stop();
+        expect(firstDependencies.workspaceActivityService.listenerCount('workspace_active')).toBe(0);
+        expect(secondDependencies.workspaceActivityService.listenerCount('workspace_active')).toBe(1);
+        second.stop();
+    });
+    it('detaches every listener and can start-stop-restart without duplicates', () => {
+        const store = createMockStore();
+        const dependencies = createDependencies(store);
+        const collector = createEventCollectorOrchestrator(dependencies);
+        collector.start();
+        collector.start();
+        expect(dependencies.workspaceActivityService.listenerCount('workspace_active')).toBe(1);
+        expect(dependencies.sessionDomainService.listenerCount('runtime_changed')).toBe(1);
+        collector.stop();
+        collector.stop();
+        expect(dependencies.workspaceActivityService.listenerCount('workspace_active')).toBe(0);
+        expect(dependencies.sessionDomainService.listenerCount('runtime_changed')).toBe(0);
+        collector.start();
+        dependencies.workspaceActivityService.emit('workspace_active', { workspaceId: 'restart' });
+        expect(store.upsert).toHaveBeenCalledTimes(1);
+        collector.stop();
+    });
+});
 //# sourceMappingURL=event-collector.orchestrator.test.js.map