factory-factory 0.3.21 → 0.4.1

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

@@ -1,24 +1,92 @@
 import { buildWorkspaceSessionSummaries, hasWorkingSessionSummary, } from '../../backend/lib/session-summaries.js';
-import { PR_SNAPSHOT_UPDATED, prSnapshotService, } from '../../backend/services/github/index.js';
-import { linearStateSyncService } from '../../backend/services/linear/index.js';
-import { createLogger } from '../../backend/services/logger.service.js';
-import { RATCHET_STATE_CHANGED, RATCHET_TOGGLED, ratchetService, } from '../../backend/services/ratchet/index.js';
-import { RUN_SCRIPT_STATUS_CHANGED, 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, WORKSPACE_STATE_CHANGED, workspaceActivityService, workspaceStateMachine, } from '../../backend/services/workspace/index.js';
-import { workspaceSnapshotStore, } from '../../backend/services/workspace-snapshot-store.service.js';
-import { getWorkspaceLinearContext } from './linear-config.helper.js';
-const logger = createLogger('event-collector');
+import { SERVICE_LIMITS } from '../../backend/services/constants.js';
+import { PR_DISPATCH_INVALIDATED, PR_SNAPSHOT_UPDATED, } from '../../backend/services/github/index.js';
+import { RATCHET_DISPATCH_CHANGED, RATCHET_STATE_CHANGED, RATCHET_TOGGLED, } from '../../backend/services/ratchet/index.js';
+import { RUN_SCRIPT_STATUS_CHANGED, } from '../../backend/services/run-script/index.js';
+import { WORKSPACE_STATE_CHANGED, } from '../../backend/services/workspace/index.js';
+import { WorkspaceStatus } from '../../shared/core/index.js';
 const DEFAULT_WINDOW_MS = 150;
 const IDLE_PR_REFRESH_COOLDOWN_MS = 30_000;
-const defaultSessionServices = {
-    chatEventForwarderService,
-    sessionDataService,
-    sessionDomainService,
-    sessionService,
-    terminalService,
-};
+const PROJECTION_RETRY_BASE_MS = 1000;
+const MAX_PROJECTION_READ_ATTEMPTS = 3;
+let lastCoalescerTimestamp = 0;
+function nextCoalescerTimestamp() {
+    const timestamp = Math.max(Date.now(), lastCoalescerTimestamp + 1);
+    lastCoalescerTimestamp = timestamp;
+    return timestamp;
+}
+function refreshCachedKanbanColumn(state, workspaceId) {
+    void state.dependencies.kanbanStateService
+        .updateCachedKanbanColumn(workspaceId)
+        .catch((error) => {
+        state.logger.warn('Failed to refresh cached kanban column after Ratchet change', {
+            workspaceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+async function projectAuthoritativeRatchetState(state, coalescer, workspaceId, isActive) {
+    try {
+        const workspace = await state.dependencies.workspaceDataService.findRatchetProjection(workspaceId);
+        if (!(workspace && isActive()) ||
+            workspace.status === WorkspaceStatus.ARCHIVING ||
+            workspace.status === WorkspaceStatus.ARCHIVED) {
+            return true;
+        }
+        coalescer.enqueue(workspaceId, {
+            ratchetEnabled: workspace.ratchetEnabled,
+            ratchetState: workspace.ratchetState,
+            ratchetDispatchOutcome: workspace.ratchetDispatchOutcome,
+            ratchetDispatchRetryCount: workspace.ratchetDispatchRetryCount,
+        }, 'projection:ratchet_authoritative', { immediate: true });
+        return true;
+    }
+    catch (error) {
+        state.logger.warn('Failed to refresh authoritative Ratchet snapshot projection', {
+            workspaceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}
+function getNewerProjectionRevision(refresh, target) {
+    return refresh.revision > target ? refresh.revision : null;
+}
+async function runRatchetProjectionRefresh(params) {
+    const { state, coalescer, workspaceId, refresh, refreshes, isActive, waitForRetry } = params;
+    let targetRevision = refresh.revision;
+    let failedAttempts = 0;
+    try {
+        while (isActive()) {
+            const succeeded = await projectAuthoritativeRatchetState(state, coalescer, workspaceId, isActive);
+            const newerRevision = getNewerProjectionRevision(refresh, targetRevision);
+            if (succeeded) {
+                if (newerRevision === null) {
+                    break;
+                }
+                targetRevision = newerRevision;
+                failedAttempts = 0;
+                continue;
+            }
+            failedAttempts += 1;
+            if (newerRevision !== null) {
+                targetRevision = newerRevision;
+            }
+            if (!isActive()) {
+                break;
+            }
+            if (failedAttempts >= MAX_PROJECTION_READ_ATTEMPTS) {
+                break;
+            }
+            await waitForRetry(Math.max(failedAttempts - 1, 0));
+        }
+    }
+    finally {
+        if (refreshes.get(workspaceId) === refresh) {
+            refreshes.delete(workspaceId);
+        }
+    }
+}
 function shouldRefreshRatchetForPrSwitch(previousSnapshot, event) {
     if (!previousSnapshot) {
         return false;
@@ -32,15 +100,18 @@ function shouldRefreshRatchetForPrSwitch(previousSnapshot, event) {
         event.prUrl !== undefined &&
         event.prUrl !== null &&
         previousSnapshot.prUrl !== event.prUrl;
-    return prNumberChanged || prUrlChanged;
+    const prReopened = previousSnapshot.prState === 'CLOSED' && event.prState !== 'CLOSED';
+    return prNumberChanged || prUrlChanged || prReopened;
 }
 export class EventCoalescer {
     store;
     windowMs;
+    logger;
     pending = new Map();
-    constructor(store, windowMs = DEFAULT_WINDOW_MS) {
+    constructor(store, windowMs = DEFAULT_WINDOW_MS, logger) {
         this.store = store;
         this.windowMs = windowMs;
+        this.logger = logger;
     }
     enqueue(workspaceId, fields, source, options) {
         let pending = this.pending.get(workspaceId);
@@ -73,14 +144,14 @@ export class EventCoalescer {
         this.pending.delete(workspaceId);
         const existing = this.store.getByWorkspaceId(workspaceId);
         if (!(existing || pending.fields.projectId)) {
-            logger.debug('Skipping upsert for unknown workspace (awaiting reconciliation)', {
+            this.logger?.debug('Skipping upsert for unknown workspace (awaiting reconciliation)', {
                 workspaceId,
                 sources: [...pending.sources],
             });
             return;
         }
         const source = [...pending.sources].join('+');
-        this.store.upsert(workspaceId, pending.fields, source);
+        this.store.upsert(workspaceId, pending.fields, source, nextCoalescerTimestamp());
     }
     flushAll() {
         for (const [workspaceId, pending] of this.pending) {
@@ -89,38 +160,62 @@ export class EventCoalescer {
             }
             const existing = this.store.getByWorkspaceId(workspaceId);
             if (!(existing || pending.fields.projectId)) {
-                logger.debug('Skipping upsert for unknown workspace during flushAll', {
+                this.logger?.debug('Skipping upsert for unknown workspace during flushAll', {
                     workspaceId,
                     sources: [...pending.sources],
                 });
                 continue;
             }
             const source = [...pending.sources].join('+');
-            this.store.upsert(workspaceId, pending.fields, source);
+            this.store.upsert(workspaceId, pending.fields, source, nextCoalescerTimestamp());
         }
         this.pending.clear();
     }
+    removeWorkspace(workspaceId) {
+        const pending = this.pending.get(workspaceId);
+        if (pending?.timer) {
+            clearTimeout(pending.timer);
+        }
+        this.pending.delete(workspaceId);
+        this.store.remove(workspaceId);
+    }
     get pendingCount() {
         return this.pending.size;
     }
 }
 class EventCollectorState {
+    dependencies;
+    logger;
     activeCoalescer = null;
-    pendingRequestChangedHandler = null;
-    runtimeChangedHandler = null;
-    eventCollectorSessionServices = defaultSessionServices;
-    listenerSessionDomainService = null;
+    lastIdlePrRefreshByWorkspace = new Map();
+    teardownListeners = [];
+    stopRatchetProjection = null;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.logger = dependencies.createLogger('event-collector');
+    }
+}
+function removeWorkspaceWithState(state, workspaceId) {
+    if (state.activeCoalescer) {
+        state.activeCoalescer.removeWorkspace(workspaceId);
+    }
+    else {
+        state.dependencies.workspaceSnapshotStore.remove(workspaceId);
+    }
+    state.lastIdlePrRefreshByWorkspace.delete(workspaceId);
+    state.dependencies.workspaceActivityService.clearWorkspace(workspaceId);
+    state.dependencies.prFetchRegistry.removeWorkspace(workspaceId);
 }
 async function refreshWorkspaceSessionSummaries(state, coalescer, workspaceId, source, options) {
     try {
         if (state.activeCoalescer !== coalescer) {
             return;
         }
-        const sessions = await state.eventCollectorSessionServices.sessionDataService.findAgentSessionsByWorkspaceId(workspaceId);
+        const sessions = await state.dependencies.sessionDataService.findAgentSessionsByWorkspaceId(workspaceId);
         if (state.activeCoalescer !== coalescer) {
             return;
         }
-        const sessionSummaries = buildWorkspaceSessionSummaries(sessions, (sessionId) => state.eventCollectorSessionServices.sessionService.getRuntimeSnapshot(sessionId));
+        const sessionSummaries = buildWorkspaceSessionSummaries(sessions, (sessionId) => state.dependencies.sessionService.getRuntimeSnapshot(sessionId));
         coalescer.enqueue(workspaceId, {
             sessionSummaries,
             ...(sessionSummaries.length > 0 ? { hasHadSessions: true } : {}),
@@ -130,7 +225,7 @@ async function refreshWorkspaceSessionSummaries(state, coalescer, workspaceId, s
         }, source);
     }
     catch (error) {
-        logger.warn('Failed to refresh workspace session summaries', {
+        state.logger.warn('Failed to refresh workspace session summaries', {
             workspaceId,
             error: error instanceof Error ? error.message : String(error),
         });
@@ -141,19 +236,19 @@ async function refreshWorkspacePendingRequestType(state, coalescer, sessionId, s
         if (state.activeCoalescer !== coalescer) {
             return;
         }
-        const session = await state.eventCollectorSessionServices.sessionDataService.findAgentSessionById(sessionId);
+        const session = await state.dependencies.sessionDataService.findAgentSessionById(sessionId);
         if (!session || state.activeCoalescer !== coalescer) {
             return;
         }
-        const sessions = await state.eventCollectorSessionServices.sessionDataService.findAgentSessionsByWorkspaceId(session.workspaceId);
+        const sessions = await state.dependencies.sessionDataService.findAgentSessionsByWorkspaceId(session.workspaceId);
         if (state.activeCoalescer !== coalescer) {
             return;
         }
-        const pendingRequestType = computePendingRequestType(sessions.map((s) => s.id), state.eventCollectorSessionServices.chatEventForwarderService.getAllPendingRequests());
+        const pendingRequestType = state.dependencies.computePendingRequestType(sessions.map((s) => s.id), state.dependencies.chatEventForwarderService.getAllPendingRequests());
         coalescer.enqueue(session.workspaceId, { pendingRequestType }, source);
     }
     catch (error) {
-        logger.warn('Failed to refresh workspace pending request type', {
+        state.logger.warn('Failed to refresh workspace pending request type', {
             sessionId,
             error: error instanceof Error ? error.message : String(error),
         });
@@ -164,7 +259,7 @@ async function refreshWorkspaceSessionSummariesForSession(state, coalescer, sess
         if (state.activeCoalescer !== coalescer) {
             return;
         }
-        const session = await state.eventCollectorSessionServices.sessionDataService.findAgentSessionById(sessionId);
+        const session = await state.dependencies.sessionDataService.findAgentSessionById(sessionId);
         if (!session || state.activeCoalescer !== coalescer) {
             return;
         }
@@ -173,86 +268,145 @@ async function refreshWorkspaceSessionSummariesForSession(state, coalescer, sess
         });
     }
     catch (error) {
-        logger.warn('Failed to refresh workspace session summaries from runtime change', {
+        state.logger.warn('Failed to refresh workspace session summaries from runtime change', {
             sessionId,
             error: error instanceof Error ? error.message : String(error),
         });
     }
 }
-async function handleLinearIssueCompletedOnMerge(workspaceId) {
+function buildWorkspaceStateChangeFields(event) {
+    return {
+        status: event.toStatus,
+        projectId: event.workspace.projectId,
+        name: event.workspace.name,
+        branchName: event.workspace.branchName,
+        createdAt: event.workspace.createdAt.toISOString(),
+    };
+}
+async function handleLinearIssueCompletedOnMerge(state, workspaceId) {
     try {
-        const ctx = await getWorkspaceLinearContext(workspaceId);
+        const ctx = await state.dependencies.getWorkspaceLinearContext(workspaceId);
         if (!ctx) {
             return;
         }
-        await linearStateSyncService.markIssueCompleted(ctx.apiKey, ctx.linearIssueId);
-        logger.info('Marked Linear issue as completed on PR merge', {
+        await state.dependencies.linearStateSyncService.markIssueCompleted(ctx.apiKey, ctx.linearIssueId);
+        state.logger.info('Marked Linear issue as completed on PR merge', {
             workspaceId,
             linearIssueId: ctx.linearIssueId,
         });
     }
     catch (error) {
-        logger.warn('Failed to mark Linear issue as completed on PR merge', {
+        state.logger.warn('Failed to mark Linear issue as completed on PR merge', {
             workspaceId,
             error: error instanceof Error ? error.message : String(error),
         });
     }
 }
-function configureEventCollectorWithState(state, services = {}) {
-    const previousSessionDomainService = state.listenerSessionDomainService ?? state.eventCollectorSessionServices.sessionDomainService;
-    if (state.pendingRequestChangedHandler) {
-        previousSessionDomainService.off('pending_request_changed', state.pendingRequestChangedHandler);
-        state.pendingRequestChangedHandler = null;
-    }
-    if (state.runtimeChangedHandler) {
-        previousSessionDomainService.off('runtime_changed', state.runtimeChangedHandler);
-        state.runtimeChangedHandler = null;
+function startEventCollectorWithState(state) {
+    if (state.activeCoalescer) {
+        return;
     }
-    state.eventCollectorSessionServices = {
-        ...defaultSessionServices,
-        ...services,
-    };
-    const coalescer = new EventCoalescer(workspaceSnapshotStore);
+    const dependencies = state.dependencies;
+    const coalescer = new EventCoalescer(dependencies.workspaceSnapshotStore, DEFAULT_WINDOW_MS, state.logger);
     state.activeCoalescer = coalescer;
-    const lastIdlePrRefreshByWorkspace = new Map();
+    const ratchetProjectionRefreshes = new Map();
+    const archivedProjectionWorkspaceIds = new Set();
+    let projectionActive = true;
+    const projectionRetryWaiters = new Set();
+    state.stopRatchetProjection = () => {
+        projectionActive = false;
+        for (const waiter of projectionRetryWaiters) {
+            clearTimeout(waiter.timer);
+            waiter.resolve();
+        }
+        projectionRetryWaiters.clear();
+        ratchetProjectionRefreshes.clear();
+        archivedProjectionWorkspaceIds.clear();
+    };
+    const waitForProjectionRetry = (attempt) => new Promise((resolve) => {
+        if (!projectionActive || state.activeCoalescer !== coalescer) {
+            resolve();
+            return;
+        }
+        const waiter = {
+            timer: setTimeout(() => {
+                projectionRetryWaiters.delete(waiter);
+                resolve();
+            }, PROJECTION_RETRY_BASE_MS * 2 ** attempt),
+            resolve,
+        };
+        projectionRetryWaiters.add(waiter);
+    });
+    const requestAuthoritativeRatchetProjection = (workspaceId) => {
+        if (archivedProjectionWorkspaceIds.has(workspaceId)) {
+            return;
+        }
+        const existing = ratchetProjectionRefreshes.get(workspaceId);
+        if (existing) {
+            existing.revision += 1;
+            return;
+        }
+        const refresh = { revision: 1 };
+        ratchetProjectionRefreshes.set(workspaceId, refresh);
+        void runRatchetProjectionRefresh({
+            state,
+            coalescer,
+            workspaceId,
+            refresh,
+            refreshes: ratchetProjectionRefreshes,
+            isActive: () => projectionActive &&
+                state.activeCoalescer === coalescer &&
+                !archivedProjectionWorkspaceIds.has(workspaceId),
+            waitForRetry: waitForProjectionRetry,
+        });
+    };
+    state.lastIdlePrRefreshByWorkspace.clear();
     const refreshPrSnapshotOnIdle = (workspaceId) => {
         const now = Date.now();
-        const lastRefresh = lastIdlePrRefreshByWorkspace.get(workspaceId) ?? 0;
+        const lastRefresh = state.lastIdlePrRefreshByWorkspace.get(workspaceId) ?? 0;
         if (now - lastRefresh < IDLE_PR_REFRESH_COOLDOWN_MS) {
             return;
         }
-        lastIdlePrRefreshByWorkspace.set(workspaceId, now);
-        void prSnapshotService
+        if (!state.lastIdlePrRefreshByWorkspace.has(workspaceId) &&
+            state.lastIdlePrRefreshByWorkspace.size >= SERVICE_LIMITS.workspaceScopedCacheMaxEntries) {
+            const oldestWorkspaceId = state.lastIdlePrRefreshByWorkspace.keys().next().value;
+            if (oldestWorkspaceId !== undefined) {
+                state.lastIdlePrRefreshByWorkspace.delete(oldestWorkspaceId);
+            }
+        }
+        state.lastIdlePrRefreshByWorkspace.set(workspaceId, now);
+        void dependencies.prSnapshotService
             .refreshWorkspace(workspaceId)
             .then((result) => {
             if (result.success || result.reason === 'no_pr_url') {
                 return;
             }
-            logger.debug('Idle PR snapshot refresh did not return fresh data', {
+            state.logger.debug('Idle PR snapshot refresh did not return fresh data', {
                 workspaceId,
                 reason: result.reason,
             });
         })
             .catch((error) => {
-            logger.debug('Idle PR snapshot refresh failed', {
+            state.logger.debug('Idle PR snapshot refresh failed', {
                 workspaceId,
                 error: error instanceof Error ? error.message : String(error),
             });
         });
     };
-    workspaceStateMachine.on(WORKSPACE_STATE_CHANGED, (event) => {
+    const workspaceStateChangedHandler = (event) => {
         if (event.toStatus === 'ARCHIVED') {
-            workspaceSnapshotStore.remove(event.workspaceId);
-            workspaceActivityService.clearWorkspace(event.workspaceId);
+            archivedProjectionWorkspaceIds.add(event.workspaceId);
+            ratchetProjectionRefreshes.delete(event.workspaceId);
+            removeWorkspaceWithState(state, event.workspaceId);
             void Promise.allSettled([
-                state.eventCollectorSessionServices.sessionService.stopWorkspaceSessions(event.workspaceId),
+                dependencies.sessionService.stopWorkspaceSessions(event.workspaceId),
                 Promise.resolve().then(() => {
-                    state.eventCollectorSessionServices.terminalService.destroyWorkspaceTerminals(event.workspaceId);
+                    dependencies.terminalService.destroyWorkspaceTerminals(event.workspaceId);
                 }),
             ]).then((results) => {
                 const cleanupErrors = results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
                 if (cleanupErrors.length > 0) {
-                    logger.warn('Failed to cleanup archived workspace resources from state change event', {
+                    state.logger.warn('Failed to cleanup archived workspace resources from state change event', {
                         workspaceId: event.workspaceId,
                         errors: cleanupErrors.map((error) => error instanceof Error ? error.message : String(error)),
                     });
@@ -260,10 +414,13 @@ function configureEventCollectorWithState(state, services = {}) {
             });
             return;
         }
-        coalescer.enqueue(event.workspaceId, { status: event.toStatus }, 'event:workspace_state_changed', { immediate: true });
-    });
-    prSnapshotService.on(PR_SNAPSHOT_UPDATED, (event) => {
-        const previousSnapshot = workspaceSnapshotStore.getByWorkspaceId(event.workspaceId);
+        archivedProjectionWorkspaceIds.delete(event.workspaceId);
+        coalescer.enqueue(event.workspaceId, buildWorkspaceStateChangeFields(event), 'event:workspace_state_changed', { immediate: true });
+    };
+    dependencies.workspaceStateMachine.on(WORKSPACE_STATE_CHANGED, workspaceStateChangedHandler);
+    state.teardownListeners.push(() => dependencies.workspaceStateMachine.off(WORKSPACE_STATE_CHANGED, workspaceStateChangedHandler));
+    const prSnapshotUpdatedHandler = (event) => {
+        const previousSnapshot = dependencies.workspaceSnapshotStore.getByWorkspaceId(event.workspaceId);
         const shouldRefreshRatchet = shouldRefreshRatchetForPrSwitch(previousSnapshot, event);
         const snapshotUpdate = {
             ...(event.prUrl !== undefined ? { prUrl: event.prUrl } : {}),
@@ -274,90 +431,129 @@ function configureEventCollectorWithState(state, services = {}) {
         coalescer.enqueue(event.workspaceId, snapshotUpdate, 'event:pr_snapshot_updated', {
             immediate: true,
         });
+        if (event.ratchetDispatchChanged) {
+            requestAuthoritativeRatchetProjection(event.workspaceId);
+        }
         if (shouldRefreshRatchet) {
-            void ratchetService.checkWorkspaceById(event.workspaceId).catch((error) => {
-                logger.warn('Failed immediate ratchet refresh after PR switch', {
+            void dependencies.ratchetService
+                .checkWorkspaceById(event.workspaceId, { bypassPrFetchCooldown: true })
+                .catch((error) => {
+                state.logger.warn('Failed immediate ratchet refresh after PR switch', {
+                    workspaceId: event.workspaceId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        }
+        if (event.prState === 'CLOSED') {
+            void dependencies.ratchetService.markPrClosed(event.workspaceId).catch((error) => {
+                state.logger.warn('Failed to reset ratchet state for closed PR', {
                     workspaceId: event.workspaceId,
                     error: error instanceof Error ? error.message : String(error),
                 });
             });
         }
         if (event.prState === 'MERGED') {
-            void handleLinearIssueCompletedOnMerge(event.workspaceId);
+            void handleLinearIssueCompletedOnMerge(state, event.workspaceId);
         }
-    });
-    ratchetService.on(RATCHET_STATE_CHANGED, (event) => {
-        coalescer.enqueue(event.workspaceId, {
-            ratchetState: event.toState,
-            ...(event.prCiStatus !== undefined ? { prCiStatus: event.prCiStatus } : {}),
-        }, 'event:ratchet_state_changed', { immediate: true });
-    });
-    ratchetService.on(RATCHET_TOGGLED, (event) => {
+    };
+    dependencies.prSnapshotService.on(PR_SNAPSHOT_UPDATED, prSnapshotUpdatedHandler);
+    state.teardownListeners.push(() => dependencies.prSnapshotService.off(PR_SNAPSHOT_UPDATED, prSnapshotUpdatedHandler));
+    const prDispatchInvalidatedHandler = (event) => {
+        coalescer.enqueue(event.workspaceId, { prCiStatus: event.prCiStatus }, 'event:pr_dispatch_invalidated', { immediate: true });
+        requestAuthoritativeRatchetProjection(event.workspaceId);
+        refreshCachedKanbanColumn(state, event.workspaceId);
+    };
+    dependencies.prSnapshotService.on(PR_DISPATCH_INVALIDATED, prDispatchInvalidatedHandler);
+    state.teardownListeners.push(() => dependencies.prSnapshotService.off(PR_DISPATCH_INVALIDATED, prDispatchInvalidatedHandler));
+    const ratchetStateChangedHandler = (event) => {
+        if (event.prCiStatus !== undefined) {
+            coalescer.enqueue(event.workspaceId, { prCiStatus: event.prCiStatus }, 'event:ratchet_state_changed', { immediate: true });
+        }
+        requestAuthoritativeRatchetProjection(event.workspaceId);
+        refreshCachedKanbanColumn(state, event.workspaceId);
+    };
+    dependencies.ratchetService.on(RATCHET_STATE_CHANGED, ratchetStateChangedHandler);
+    state.teardownListeners.push(() => dependencies.ratchetService.off(RATCHET_STATE_CHANGED, ratchetStateChangedHandler));
+    const ratchetToggledHandler = (event) => {
         coalescer.enqueue(event.workspaceId, { ratchetEnabled: event.enabled, ratchetState: event.ratchetState }, 'event:ratchet_toggled', { immediate: true });
-    });
-    runScriptStateMachine.on(RUN_SCRIPT_STATUS_CHANGED, (event) => {
+        requestAuthoritativeRatchetProjection(event.workspaceId);
+        refreshCachedKanbanColumn(state, event.workspaceId);
+    };
+    dependencies.ratchetService.on(RATCHET_TOGGLED, ratchetToggledHandler);
+    state.teardownListeners.push(() => dependencies.ratchetService.off(RATCHET_TOGGLED, ratchetToggledHandler));
+    const ratchetDispatchChangedHandler = (event) => {
+        requestAuthoritativeRatchetProjection(event.workspaceId);
+        refreshCachedKanbanColumn(state, event.workspaceId);
+    };
+    dependencies.ratchetService.on(RATCHET_DISPATCH_CHANGED, ratchetDispatchChangedHandler);
+    state.teardownListeners.push(() => dependencies.ratchetService.off(RATCHET_DISPATCH_CHANGED, ratchetDispatchChangedHandler));
+    const runScriptStatusChangedHandler = (event) => {
         coalescer.enqueue(event.workspaceId, { runScriptStatus: event.toStatus }, 'event:run_script_status_changed');
-    });
-    workspaceActivityService.on('workspace_active', ({ workspaceId }) => {
+    };
+    dependencies.runScriptStateMachine.on(RUN_SCRIPT_STATUS_CHANGED, runScriptStatusChangedHandler);
+    state.teardownListeners.push(() => dependencies.runScriptStateMachine.off(RUN_SCRIPT_STATUS_CHANGED, runScriptStatusChangedHandler));
+    const workspaceActiveHandler = ({ workspaceId }) => {
         coalescer.enqueue(workspaceId, { isWorking: true, hasHadSessions: true }, 'event:workspace_active', { immediate: true });
-    });
-    workspaceActivityService.on('workspace_idle', ({ workspaceId }) => {
+    };
+    dependencies.workspaceActivityService.on('workspace_active', workspaceActiveHandler);
+    state.teardownListeners.push(() => dependencies.workspaceActivityService.off('workspace_active', workspaceActiveHandler));
+    const workspaceIdleHandler = ({ workspaceId }) => {
         coalescer.enqueue(workspaceId, { isWorking: false, hasHadSessions: true }, 'event:workspace_idle', { immediate: true });
         refreshPrSnapshotOnIdle(workspaceId);
-    });
-    workspaceActivityService.on('session_activity_changed', ({ workspaceId }) => {
+    };
+    dependencies.workspaceActivityService.on('workspace_idle', workspaceIdleHandler);
+    state.teardownListeners.push(() => dependencies.workspaceActivityService.off('workspace_idle', workspaceIdleHandler));
+    const sessionActivityChangedHandler = ({ workspaceId, }) => {
         void refreshWorkspaceSessionSummaries(state, coalescer, workspaceId, 'event:session_activity_changed', { includeWorking: true });
-    });
-    for (const workspaceId of workspaceSnapshotStore.getAllWorkspaceIds()) {
+    };
+    dependencies.workspaceActivityService.on('session_activity_changed', sessionActivityChangedHandler);
+    state.teardownListeners.push(() => dependencies.workspaceActivityService.off('session_activity_changed', sessionActivityChangedHandler));
+    for (const workspaceId of dependencies.workspaceSnapshotStore.getAllWorkspaceIds()) {
         void refreshWorkspaceSessionSummaries(state, coalescer, workspaceId, 'event:collector_startup', {
             includeWorking: true,
         });
     }
-    state.pendingRequestChangedHandler = ({ sessionId }) => {
+    const pendingRequestChangedHandler = ({ sessionId }) => {
         void refreshWorkspacePendingRequestType(state, coalescer, sessionId, 'event:pending_request_changed');
     };
-    state.eventCollectorSessionServices.sessionDomainService.on('pending_request_changed', state.pendingRequestChangedHandler);
-    state.runtimeChangedHandler = ({ sessionId }) => {
+    dependencies.sessionDomainService.on('pending_request_changed', pendingRequestChangedHandler);
+    state.teardownListeners.push(() => dependencies.sessionDomainService.off('pending_request_changed', pendingRequestChangedHandler));
+    const runtimeChangedHandler = ({ sessionId }) => {
         void refreshWorkspaceSessionSummariesForSession(state, coalescer, sessionId, 'event:session_runtime_changed');
     };
-    state.eventCollectorSessionServices.sessionDomainService.on('runtime_changed', state.runtimeChangedHandler);
-    state.listenerSessionDomainService = state.eventCollectorSessionServices.sessionDomainService;
-    logger.info('Event collector configured with 10 event subscriptions');
+    dependencies.sessionDomainService.on('runtime_changed', runtimeChangedHandler);
+    state.teardownListeners.push(() => dependencies.sessionDomainService.off('runtime_changed', runtimeChangedHandler));
+    state.logger.info('Event collector started with 12 event subscriptions');
 }
 function stopEventCollectorWithState(state) {
-    const sessionDomainService = state.listenerSessionDomainService ?? state.eventCollectorSessionServices.sessionDomainService;
-    if (state.pendingRequestChangedHandler) {
-        sessionDomainService.off('pending_request_changed', state.pendingRequestChangedHandler);
-        state.pendingRequestChangedHandler = null;
+    for (const teardown of state.teardownListeners.splice(0).reverse()) {
+        teardown();
     }
-    if (state.runtimeChangedHandler) {
-        sessionDomainService.off('runtime_changed', state.runtimeChangedHandler);
-        state.runtimeChangedHandler = null;
-    }
-    state.listenerSessionDomainService = null;
+    state.stopRatchetProjection?.();
+    state.stopRatchetProjection = null;
     if (state.activeCoalescer) {
         state.activeCoalescer.flushAll();
         state.activeCoalescer = null;
-        logger.info('Event collector stopped');
+        state.lastIdlePrRefreshByWorkspace.clear();
+        state.logger.info('Event collector stopped');
     }
 }
 export class EventCollectorOrchestrator {
-    state = new EventCollectorState();
-    configure(services = {}) {
-        configureEventCollectorWithState(this.state, services);
+    state;
+    constructor(dependencies) {
+        this.state = new EventCollectorState(dependencies);
+    }
+    start() {
+        startEventCollectorWithState(this.state);
     }
     stop() {
         stopEventCollectorWithState(this.state);
     }
+    removeWorkspace(workspaceId) {
+        removeWorkspaceWithState(this.state, workspaceId);
+    }
 }
-export function createEventCollectorOrchestrator() {
-    return new EventCollectorOrchestrator();
-}
-const defaultEventCollectorOrchestrator = createEventCollectorOrchestrator();
-export function configureEventCollector(services = {}) {
-    defaultEventCollectorOrchestrator.configure(services);
-}
-export function stopEventCollector() {
-    defaultEventCollectorOrchestrator.stop();
+export function createEventCollectorOrchestrator(dependencies) {
+    return new EventCollectorOrchestrator(dependencies);
 }
 //# sourceMappingURL=event-collector.orchestrator.js.map