factory-factory 0.4.9 → 0.4.10

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

@@ -1,604 +1,213 @@
 import { EventEmitter } from 'node:events';
 import pLimit from 'p-limit';
-import { toError } from '../../../lib/error-utils.js';
-import { SERVICE_INTERVAL_MS, SERVICE_THRESHOLDS, SERVICE_TIMEOUT_MS, } from '../../constants.js';
+import { SERVICE_INTERVAL_MS, SERVICE_TIMEOUT_MS } from '../../constants.js';
 import { jobRunner } from '../../job-runner.service.js';
 import { createLogger } from '../../logger.service.js';
 import { RateLimitBackoff } from '../../rate-limit-backoff.js';
-import { userSettingsService } from '../../settings/index.js';
-import { workspaceDataService, workspaceRatchetService } from '../../workspace/index.js';
-import { CIStatus, RatchetState, SessionStatus } from '../../../../shared/core/index.js';
-import { checkActiveFixerSession as checkActiveFixerSessionHelper, hasActiveSession as hasActiveSessionHelper, } from './ratchet-active-session.helpers.js';
-import { logWorkspaceRatchetingDecision as logWorkspaceRatchetingDecisionHelper } from './ratchet-decision-logging.helpers.js';
-import { triggerRatchetFixer } from './ratchet-fixer-dispatch.helpers.js';
-import { determineRatchetState as determineRatchetStateHelper, fetchPRState as fetchPRStateHelper, getAuthenticatedUsernameCached as getAuthenticatedUsernameCachedHelper, hasNewReviewActivitySinceLastDispatch as hasNewReviewActivitySinceLastDispatchHelper, isPRStateFetchSkipped, shouldSkipCleanPR as shouldSkipCleanPRHelper, } from './ratchet-pr-state.helpers.js';
-import { RatchetWorkspaceCheckCoordinator, } from './ratchet-workspace-check-coordinator.js';
+import { workspacePRMonitoringService, workspacePrSnapshotService, } from '../../workspace/index.js';
+import { deriveRatchetState, RatchetState } from '../../../../shared/core/index.js';
 const logger = createLogger('ratchet');
-const RATCHET_WORKSPACE_CONCURRENCY = 3;
-const ratchetWorkspaceLimit = pLimit(RATCHET_WORKSPACE_CONCURRENCY);
-const scheduleRatchetBatchCheck = (task) => ratchetWorkspaceLimit(task);
-const RECENTLY_FETCHED_REASON = 'recently_fetched';
-function isRecentlyFetchedWaitResult(result) {
-    return result.action.type === 'WAITING' && result.action.reason === RECENTLY_FETCHED_REASON;
-}
+const POLL_JOB = 'pr-event-poll';
 export const RATCHET_STATE_CHANGED = 'ratchet_state_changed';
 export const RATCHET_TOGGLED = 'ratchet_toggled';
 export const RATCHET_DISPATCH_CHANGED = 'ratchet_dispatch_changed';
-const RATCHET_POLL_JOB = 'ratchet-poll';
-class RatchetService extends EventEmitter {
-    runSignal = null;
+function aggregateState(rows) {
+    const states = rows.map((pr) => deriveRatchetState({
+        ratchetEnabled: true,
+        prState: pr.state,
+        prCiStatus: pr.ciStatus,
+        prHasMergeConflict: pr.hasMergeConflict,
+        prReviewState: pr.reviewState,
+    }));
+    if (states.length && states.every((s) => s === RatchetState.MERGED)) {
+        return RatchetState.MERGED;
+    }
+    return ([
+        RatchetState.MERGE_CONFLICT,
+        RatchetState.CI_FAILED,
+        RatchetState.REVIEW_PENDING,
+        RatchetState.CI_RUNNING,
+        RatchetState.READY,
+    ].find((s) => states.includes(s)) ?? RatchetState.IDLE);
+}
+export class RatchetService extends EventEmitter {
+    bridge = null;
     stopped = false;
-    workspaceCheckTimeoutMs = SERVICE_TIMEOUT_MS.ratchetWorkspaceCheck;
-    checkCoordinator = new RatchetWorkspaceCheckCoordinator(() => this.workspaceCheckTimeoutMs);
-    cachedAuthenticatedUsername = null;
     backoff = new RateLimitBackoff();
-    sessionBridge = null;
-    githubBridge = null;
-    snapshotBridge = null;
-    workspaceBridge = null;
+    limit = pLimit(3);
+    checking = new Map();
+    controllers = new Set();
     constructor() {
         super();
         jobRunner.register({
-            name: RATCHET_POLL_JOB,
+            name: POLL_JOB,
             intervalMs: SERVICE_INTERVAL_MS.ratchetPoll,
             runImmediately: true,
-            run: (signal) => this.runCycle(signal),
-            computeDelay: (base) => this.nextPollDelay(base),
+            run: async (signal) => {
+                this.backoff.beginCycle();
+                await this.checkAllWorkspaces(signal);
+                this.backoff.resetIfCleanCycle(logger, 'PR monitoring');
+            },
+            computeDelay: (base) => this.backoff.computeDelay(base),
         });
     }
-    get isShuttingDown() {
-        return this.stopped || (this.runSignal?.aborted ?? false);
+    configure(bridge) {
+        this.bridge = bridge;
     }
-    configure(bridges) {
-        this.sessionBridge = bridges.session;
-        this.githubBridge = bridges.github;
-        this.snapshotBridge = bridges.snapshot;
-        this.workspaceBridge = bridges.workspace;
-    }
-    get workspace() {
-        if (!this.workspaceBridge) {
-            throw new Error('RatchetService not configured: workspace bridge missing. Call configure() first.');
-        }
-        return this.workspaceBridge;
-    }
-    get session() {
-        if (!this.sessionBridge) {
-            throw new Error('RatchetService not configured: session bridge missing. Call configure() first.');
-        }
-        return this.sessionBridge;
-    }
-    get github() {
-        if (!this.githubBridge) {
-            throw new Error('RatchetService not configured: github bridge missing. Call configure() first.');
-        }
-        return this.githubBridge;
-    }
-    get snapshot() {
-        if (!this.snapshotBridge) {
-            throw new Error('RatchetService not configured: snapshot bridge missing. Call configure() first.');
-        }
-        return this.snapshotBridge;
-    }
-    start() {
+    async start() {
         this.stopped = false;
-        jobRunner.start(RATCHET_POLL_JOB);
+        await this.bridge?.retireLegacy?.();
+        if (!this.stopped) {
+            jobRunner.start(POLL_JOB);
+        }
     }
     async stop() {
         this.stopped = true;
-        await jobRunner.stop(RATCHET_POLL_JOB);
-    }
-    async runCycle(signal) {
-        this.runSignal = signal;
-        try {
-            this.backoff.beginCycle();
-            await this.checkAllWorkspaces();
-            this.backoff.resetIfCleanCycle(logger, 'Ratchet');
-        }
-        catch (err) {
-            logger.error('Ratchet check failed', toError(err));
-        }
-        finally {
-            this.runSignal = null;
-        }
-    }
-    nextPollDelay(baseIntervalMs) {
-        const delayMs = this.backoff.computeDelay(baseIntervalMs);
-        if (this.backoff.currentMultiplier > 1) {
-            logger.debug('Using backoff delay for next ratchet check', {
-                baseIntervalMs,
-                backoffMultiplier: this.backoff.currentMultiplier,
-                delayMs,
-            });
+        for (const controller of this.controllers) {
+            controller.abort();
         }
-        return delayMs;
+        await jobRunner.stop(POLL_JOB);
     }
-    async checkAllWorkspaces() {
-        if (this.isShuttingDown) {
+    async checkAllWorkspaces(signal) {
+        if (this.stopped || signal?.aborted) {
             return { checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] };
         }
-        const workspaces = await workspaceRatchetService.findCandidates();
-        if (workspaces.length === 0) {
+        const workspaces = await workspacePRMonitoringService.listEnabled();
+        if (this.stopped || signal?.aborted) {
             return { checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] };
         }
-        const userSettings = await userSettingsService.get();
-        const results = await Promise.all(workspaces.map((workspace) => this.runWorkspaceCheckSafely(workspace, undefined, scheduleRatchetBatchCheck, userSettings.ratchetReviewTriggerMode)));
-        const stateChanges = results.filter((r) => r.previousState !== r.newState).length;
-        const actionsTriggered = results.filter((r) => r.action.type === 'TRIGGERED_FIXER').length;
-        if (stateChanges > 0 || actionsTriggered > 0) {
-            logger.info('Ratchet check completed', {
-                checked: workspaces.length,
-                stateChanges,
-                actionsTriggered,
-            });
-        }
-        return { checked: workspaces.length, stateChanges, actionsTriggered, results };
+        const results = await Promise.all(workspaces.map((config) => this.limit(() => this.check(config, signal))));
+        return {
+            checked: results.length,
+            stateChanges: results.filter((r) => r.previousState !== r.newState).length,
+            actionsTriggered: results.filter((r) => r.action.type === 'EVENTS_QUEUED').length,
+            results,
+        };
     }
-    async checkWorkspaceById(workspaceId, opts) {
-        if (this.isShuttingDown) {
-            return null;
-        }
-        const workspace = await workspaceRatchetService.findCandidateById(workspaceId);
-        if (!workspace) {
+    async checkWorkspaceById(workspaceId, _options) {
+        if (this.stopped) {
             return null;
         }
-        const userSettings = await userSettingsService.get();
-        const reviewTriggerMode = userSettings.ratchetReviewTriggerMode;
-        const result = await this.runWorkspaceCheckSafely(workspace, opts, undefined, reviewTriggerMode);
-        if (opts?.bypassPrFetchCooldown && isRecentlyFetchedWaitResult(result)) {
-            const freshWorkspace = await workspaceRatchetService.findCandidateById(workspaceId);
-            if (!freshWorkspace) {
-                return result;
-            }
-            return this.runWorkspaceCheckSafely(freshWorkspace, opts, undefined, reviewTriggerMode);
-        }
-        return result;
-    }
-    async recordSessionEnd(workspaceId, sessionId, outcome) {
-        const settled = await this.workspace.recordSessionEnd(workspaceId, sessionId, outcome);
-        if (!settled) {
-            return;
-        }
-        this.emit(RATCHET_DISPATCH_CHANGED, {
-            workspaceId,
-        });
-    }
-    async runWorkspaceCheckSafely(workspace, opts, schedule, reviewTriggerMode) {
-        try {
-            return await this.checkCoordinator.run(workspace, (signal, commitSideEffects) => {
-                signal.throwIfAborted();
-                return this.processWorkspace(workspace, opts, signal, commitSideEffects, reviewTriggerMode);
-            }, schedule);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.warn('Ratchet workspace check failed', {
-                workspaceId: workspace.id,
-                prUrl: workspace.prUrl,
-                error: errorMessage,
+        const config = (await workspacePRMonitoringService.listEnabled()).find((c) => c.workspaceId === workspaceId);
+        return !this.stopped && config ? await this.check(config) : null;
+    }
+    check(config, parentSignal) {
+        const previousState = aggregateState(config.workspace.prs);
+        if (this.stopped || parentSignal?.aborted) {
+            return Promise.resolve({
+                workspaceId: config.workspaceId,
+                previousState,
+                newState: previousState,
+                action: { type: 'WAITING', reason: 'PR monitoring stopped' },
             });
-            return {
-                workspaceId: workspace.id,
-                previousState: workspace.ratchetState,
-                newState: workspace.ratchetState,
-                action: { type: 'ERROR', error: errorMessage },
-            };
-        }
-    }
-    async setWorkspaceRatcheting(workspaceId, enabled) {
-        const workspace = await workspaceDataService.findById(workspaceId);
-        if (!workspace) {
-            throw new Error(`Workspace not found: ${workspaceId}`);
         }
-        if (enabled) {
-            await workspaceRatchetService.enable(workspaceId);
-            this.emit(RATCHET_TOGGLED, {
-                workspaceId,
-                enabled: true,
-                ratchetState: workspace.ratchetState,
-            });
-            return;
-        }
-        await workspaceRatchetService.disable(workspaceId);
-        await this.stopActiveRatchetSessionsAfterDisable(workspaceId);
-        if (workspace.ratchetState !== RatchetState.IDLE) {
-            this.emit(RATCHET_STATE_CHANGED, {
-                workspaceId,
-                fromState: workspace.ratchetState,
-                toState: RatchetState.IDLE,
-            });
-        }
-        this.emit(RATCHET_TOGGLED, {
-            workspaceId,
-            enabled: false,
-            ratchetState: RatchetState.IDLE,
-        });
-    }
-    async processWorkspace(workspace, opts, signal = new AbortController().signal, commitSideEffects = () => {
-    }, reviewTriggerMode) {
-        signal.throwIfAborted();
-        if (this.isShuttingDown) {
-            return {
-                workspaceId: workspace.id,
-                previousState: workspace.ratchetState,
-                newState: workspace.ratchetState,
-                action: { type: 'WAITING', reason: 'Shutting down' },
-            };
-        }
-        if (!workspace.ratchetEnabled) {
-            const action = { type: 'DISABLED', reason: 'Workspace ratcheting disabled' };
-            const fromState = workspace.ratchetState;
-            this.logWorkspaceRatchetingDecision(workspace, fromState, fromState, action, null);
-            return {
-                workspaceId: workspace.id,
-                previousState: fromState,
-                newState: fromState,
-                action,
-            };
-        }
-        try {
-            signal.throwIfAborted();
-            const effectiveReviewTriggerMode = reviewTriggerMode ?? (await userSettingsService.get()).ratchetReviewTriggerMode;
-            signal.throwIfAborted();
-            const authenticatedUsername = await this.getAuthenticatedUsernameCached(signal);
-            signal.throwIfAborted();
-            const prStateResult = await this.fetchPRState(workspace, authenticatedUsername, {
-                bypassRecentFetchCooldown: opts?.bypassPrFetchCooldown,
-                reviewTriggerMode: effectiveReviewTriggerMode,
-            }, signal);
-            signal.throwIfAborted();
-            if (isPRStateFetchSkipped(prStateResult)) {
-                const action = { type: 'WAITING', reason: prStateResult.reason };
-                this.logWorkspaceRatchetingDecision(workspace, workspace.ratchetState, workspace.ratchetState, action, null);
+        const existing = this.checking.get(config.workspaceId);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const controller = new AbortController();
+        this.controllers.add(controller);
+        const signal = AbortSignal.any([
+            controller.signal,
+            AbortSignal.timeout(SERVICE_TIMEOUT_MS.ratchetWorkspaceCheck),
+            ...(parentSignal ? [parentSignal] : []),
+        ]);
+        const bridge = this.bridge;
+        if (!bridge) {
+            return Promise.reject(new Error('PR monitoring bridge is not configured'));
+        }
+        const run = (async () => {
+            try {
+                await this.observeAssociations(config, bridge, signal);
+                signal.throwIfAborted();
+                await workspacePRMonitoringService.markChecked(config.workspaceId);
+                signal.throwIfAborted();
+                const queued = await workspacePRMonitoringService.listPending(config.workspaceId);
+                signal.throwIfAborted();
+                await bridge.wake(config.workspaceId);
+                signal.throwIfAborted();
+                this.emit(RATCHET_DISPATCH_CHANGED, { workspaceId: config.workspaceId });
+                signal.throwIfAborted();
+                const newState = aggregateState(await workspacePrSnapshotService.list(config.workspaceId));
+                signal.throwIfAborted();
+                this.emitStateChange(config.workspaceId, previousState, newState);
                 return {
-                    workspaceId: workspace.id,
-                    previousState: workspace.ratchetState,
-                    newState: workspace.ratchetState,
-                    action,
+                    workspaceId: config.workspaceId,
+                    previousState,
+                    newState,
+                    action: queued.length
+                        ? { type: 'EVENTS_QUEUED' }
+                        : { type: 'WAITING', reason: 'No actionable PR changes' },
                 };
             }
-            if (!prStateResult) {
-                const action = { type: 'ERROR', error: 'Failed to fetch PR state' };
-                this.logWorkspaceRatchetingDecision(workspace, workspace.ratchetState, workspace.ratchetState, action, null);
+            catch (error) {
+                if (!signal.aborted) {
+                    this.backoff.handleError(error, logger, 'PR monitoring', { workspaceId: config.workspaceId, prUrl: config.workspace.prs[0]?.url ?? '' }, SERVICE_INTERVAL_MS.ratchetPoll);
+                }
                 return {
-                    workspaceId: workspace.id,
-                    previousState: workspace.ratchetState,
-                    newState: workspace.ratchetState,
-                    action,
+                    workspaceId: config.workspaceId,
+                    previousState,
+                    newState: previousState,
+                    action: {
+                        type: 'ERROR',
+                        error: error instanceof Error ? error.message : String(error),
+                    },
                 };
             }
-            const prStateInfo = prStateResult;
+            finally {
+                this.controllers.delete(controller);
+                this.checking.delete(config.workspaceId);
+            }
+        })();
+        this.checking.set(config.workspaceId, run);
+        return run;
+    }
+    async observeAssociations(config, bridge, signal) {
+        for (const pr of config.workspace.prs) {
             signal.throwIfAborted();
-            if (prStateInfo.prState === 'MERGED') {
-                await this.stopActiveRatchetSessionsForMergedPr(workspace.id, signal);
+            try {
+                await bridge.observe({ workspaceId: config.workspaceId, prId: pr.id }, signal);
+            }
+            catch (error) {
                 signal.throwIfAborted();
+                const rateLimited = this.backoff.handleError(error, logger, 'PR monitoring', { workspaceId: config.workspaceId, prUrl: pr.url }, SERVICE_INTERVAL_MS.ratchetPoll);
+                if (rateLimited) {
+                    break;
+                }
             }
-            const decisionContext = await this.buildRatchetDecisionContext(workspace, prStateInfo, signal);
-            signal.throwIfAborted();
-            const decision = await this.decideRatchetAction(decisionContext, signal);
-            signal.throwIfAborted();
-            const action = await this.applyRatchetDecision(decisionContext, decision, signal, commitSideEffects);
-            signal.throwIfAborted();
-            return await this.finishRatchetCheck(workspace, prStateInfo, action, decisionContext, signal);
-        }
-        catch (error) {
-            signal.throwIfAborted();
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error('Error processing workspace in ratchet', toError(error), {
-                workspaceId: workspace.id,
-            });
-            const action = { type: 'ERROR', error: errorMessage };
-            this.logWorkspaceRatchetingDecision(workspace, workspace.ratchetState, workspace.ratchetState, action, null);
-            return {
-                workspaceId: workspace.id,
-                previousState: workspace.ratchetState,
-                newState: workspace.ratchetState,
-                action,
-            };
-        }
-    }
-    logWorkspaceRatchetingDecision(workspace, previousState, newState, action, prStateInfo, decisionContext = null) {
-        logWorkspaceRatchetingDecisionHelper({
-            workspace,
-            previousState,
-            newState,
-            action,
-            prStateInfo,
-            decisionContext,
-        });
-    }
-    async buildRatchetDecisionContext(workspace, prStateInfo, signal = new AbortController().signal) {
-        const previousState = workspace.ratchetState;
-        const newState = determineRatchetStateHelper(prStateInfo);
-        const hasNewReviewActivitySinceLastDispatch = hasNewReviewActivitySinceLastDispatchHelper(workspace, prStateInfo);
-        const hasStateChangedSinceLastDispatch = this.hasStateChangedSinceLastDispatch(workspace, prStateInfo);
-        const isCleanPrWithNoNewReviewActivity = shouldSkipCleanPRHelper(workspace, prStateInfo);
-        const activeFixerCheck = prStateInfo.prState === 'OPEN'
-            ? await this.checkActiveFixerSession(workspace, signal)
-            : { kind: 'none' };
-        signal.throwIfAborted();
-        const dispatchOutcome = activeFixerCheck.kind === 'settled'
-            ? activeFixerCheck.outcome
-            : workspace.ratchetDispatchOutcome;
-        return {
-            workspace,
-            prStateInfo,
-            previousState,
-            newState,
-            hasNewReviewActivitySinceLastDispatch,
-            hasStateChangedSinceLastDispatch,
-            isCleanPrWithNoNewReviewActivity,
-            activeFixerCheck,
-            dispatchOutcome,
-            dispatchRetryCount: workspace.ratchetDispatchRetryCount,
-        };
-    }
-    async decideRatchetAction(context, signal = new AbortController().signal) {
-        signal.throwIfAborted();
-        if (context.prStateInfo.prState === 'MERGED') {
-            return { type: 'RETURN_ACTION', action: { type: 'COMPLETED' } };
-        }
-        if (context.prStateInfo.prState !== 'OPEN') {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'PR is not open' },
-            };
-        }
-        const isTerminalCIStatus = context.prStateInfo.ciStatus === CIStatus.SUCCESS ||
-            context.prStateInfo.ciStatus === CIStatus.FAILURE;
-        if (!(isTerminalCIStatus || context.prStateInfo.hasMergeConflict)) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'Waiting for CI to complete (not in terminal state)' },
-            };
-        }
-        if (context.activeFixerCheck.kind === 'active') {
-            return { type: 'RETURN_ACTION', action: context.activeFixerCheck.action };
-        }
-        if (context.activeFixerCheck.kind === 'ended_concurrently') {
-            return {
-                type: 'RETURN_ACTION',
-                action: {
-                    type: 'WAITING',
-                    reason: 'Fixer session ended during this check; re-evaluating next cycle',
-                },
-            };
-        }
-        if (!context.hasStateChangedSinceLastDispatch && context.dispatchOutcome === 'DIED') {
-            return this.decideDiedFixerRetry(context, signal);
-        }
-        if (context.isCleanPrWithNoNewReviewActivity) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'PR is clean (green CI and no new review activity)' },
-            };
-        }
-        if (!this.hasActionableFixTrigger(context.prStateInfo)) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'No CI failures or PR review comments to address' },
-            };
-        }
-        if (!context.hasStateChangedSinceLastDispatch) {
-            await this.recordDispatchStalled(context);
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'PR state unchanged since last ratchet dispatch' },
-            };
-        }
-        signal.throwIfAborted();
-        if (await this.hasActiveSession(context.workspace.id, signal)) {
-            return {
-                type: 'RETURN_ACTION',
-                action: {
-                    type: 'WAITING',
-                    reason: 'Workspace has another working session',
-                },
-            };
-        }
-        return { type: 'TRIGGER_FIXER', retryCount: 0 };
-    }
-    async recordDispatchStalled(context) {
-        const marked = await this.workspace.markDispatchStalled(context.workspace.id, context.prStateInfo.snapshotKey);
-        if (marked) {
-            this.emit(RATCHET_DISPATCH_CHANGED, {
-                workspaceId: context.workspace.id,
-            });
-        }
-    }
-    async decideDiedFixerRetry(context, signal = new AbortController().signal) {
-        if (context.dispatchRetryCount >= SERVICE_THRESHOLDS.ratchetDispatchMaxRetries) {
-            await this.recordDispatchStalled(context);
-            return {
-                type: 'RETURN_ACTION',
-                action: {
-                    type: 'WAITING',
-                    reason: `Fixer died ${context.dispatchRetryCount + 1} times for this PR state; waiting for PR state to change`,
-                },
-            };
-        }
-        signal.throwIfAborted();
-        if (await this.hasActiveSession(context.workspace.id, signal)) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'Workspace has another working session' },
-            };
-        }
-        return { type: 'TRIGGER_FIXER', retryCount: context.dispatchRetryCount + 1 };
-    }
-    async applyRatchetDecision(context, decision, signal = new AbortController().signal, commitSideEffects = () => {
-    }) {
-        if (decision.type === 'RETURN_ACTION') {
-            return decision.action;
-        }
-        signal.throwIfAborted();
-        const action = await this.triggerFixer(context.workspace, context.prStateInfo, decision.retryCount, signal, commitSideEffects);
-        signal.throwIfAborted();
-        return action;
-    }
-    hasActionableFixTrigger(prStateInfo) {
-        if (prStateInfo.ciStatus === CIStatus.FAILURE) {
-            return true;
-        }
-        if (prStateInfo.hasMergeConflict) {
-            return true;
-        }
-        if (prStateInfo.hasChangesRequested) {
-            return true;
         }
-        return (prStateInfo.reviewComments?.length ?? 0) > 0;
     }
-    async finishRatchetCheck(workspace, prStateInfo, action, decisionContext, signal = new AbortController().signal) {
-        signal.throwIfAborted();
-        const updateResult = await this.updateWorkspaceAfterCheck(workspace, prStateInfo, action, signal);
-        signal.throwIfAborted();
-        if (updateResult === 'disabled') {
-            const disabledAction = {
-                type: 'DISABLED',
-                reason: 'Workspace ratcheting disabled',
-            };
-            this.logWorkspaceRatchetingDecision(workspace, decisionContext.previousState, RatchetState.IDLE, disabledAction, prStateInfo, decisionContext);
-            return {
-                workspaceId: workspace.id,
-                previousState: decisionContext.previousState,
-                newState: RatchetState.IDLE,
-                action: disabledAction,
-            };
-        }
-        if (decisionContext.previousState !== decisionContext.newState) {
+    emitStateChange(workspaceId, previousState, newState) {
+        if (newState !== previousState) {
             this.emit(RATCHET_STATE_CHANGED, {
-                workspaceId: workspace.id,
-                fromState: decisionContext.previousState,
-                toState: decisionContext.newState,
-                prCiStatus: prStateInfo.ciStatus,
+                workspaceId,
+                fromState: previousState,
+                toState: newState,
             });
         }
-        this.logWorkspaceRatchetingDecision(workspace, decisionContext.previousState, decisionContext.newState, action, prStateInfo, decisionContext);
-        return {
-            workspaceId: workspace.id,
-            previousState: decisionContext.previousState,
-            newState: decisionContext.newState,
-            action,
-        };
-    }
-    hasStateChangedSinceLastDispatch(workspace, prStateInfo) {
-        return workspace.ratchetDispatchSnapshotKey !== prStateInfo.snapshotKey;
     }
-    async updateWorkspaceAfterCheck(workspace, prStateInfo, action, signal = new AbortController().signal) {
-        const now = new Date();
-        const dispatched = action.type === 'TRIGGERED_FIXER' && action.promptSent;
-        signal.throwIfAborted();
-        const updated = await workspaceRatchetService.recordCheckIfEnabled(workspace.id, now);
-        signal.throwIfAborted();
-        if (!updated) {
-            return 'disabled';
+    async setWorkspaceRatcheting(workspaceId, enabled, options) {
+        if (!this.bridge) {
+            throw new Error('PR monitoring bridge is not configured');
         }
-        if (dispatched) {
-            signal.throwIfAborted();
-            await this.snapshot.recordReviewCheck(workspace.id, now);
-            signal.throwIfAborted();
-        }
-        if (prStateInfo.ciStatus !== workspace.prCiStatus ||
-            prStateInfo.cachedPrState !== workspace.prState ||
-            prStateInfo.reviewDecision !== workspace.prReviewState ||
-            prStateInfo.hasMergeConflict !== workspace.prHasMergeConflict) {
-            signal.throwIfAborted();
-            await this.snapshot.recordPrObservation({
-                workspaceId: workspace.id,
-                prUrl: workspace.prUrl,
-                prNumber: prStateInfo.prNumber,
-                ciStatus: prStateInfo.ciStatus,
-                prState: prStateInfo.cachedPrState,
-                reviewState: prStateInfo.reviewDecision,
-                hasMergeConflict: prStateInfo.hasMergeConflict,
-                observedAt: now,
-            });
-            signal.throwIfAborted();
-        }
-        return 'applied';
-    }
-    async checkActiveFixerSession(workspace, signal = new AbortController().signal) {
-        return await checkActiveFixerSessionHelper({
-            workspace,
-            sessionBridge: this.session,
-            workspaceBridge: this.workspace,
-            signal,
-            onDispatchChanged: (event) => {
-                this.emit(RATCHET_DISPATCH_CHANGED, event);
-            },
-        });
-    }
-    async hasActiveSession(workspaceId, signal = new AbortController().signal) {
-        return await hasActiveSessionHelper(workspaceId, this.session, signal);
-    }
-    async fetchPRState(workspace, authenticatedUsername, opts, signal) {
-        return await fetchPRStateHelper({
-            workspace,
-            authenticatedUsername,
-            reviewTriggerMode: opts?.reviewTriggerMode ?? 'CHANGES_REQUESTED',
-            github: this.github,
-            backoff: this.backoff,
-            signal,
-            bypassRecentFetchCooldown: opts?.bypassRecentFetchCooldown,
-        });
-    }
-    async getAuthenticatedUsernameCached(signal) {
-        const { username, cache } = await getAuthenticatedUsernameCachedHelper({
-            cachedValue: this.cachedAuthenticatedUsername,
-            github: this.github,
-            signal,
-        });
-        this.cachedAuthenticatedUsername = cache;
-        return username;
-    }
-    async triggerFixer(workspace, prStateInfo, retryCount, signal = new AbortController().signal, commitSideEffects = () => {
-    }) {
-        const action = await triggerRatchetFixer({
-            workspace,
-            prStateInfo,
-            retryCount,
-            sessionBridge: this.session,
-            signal,
-            commitSideEffects,
-            onDispatchChanged: (event) => {
-                this.emit(RATCHET_DISPATCH_CHANGED, event);
-            },
+        const config = await workspacePRMonitoringService.get(workspaceId);
+        const result = await this.bridge.setMonitoring({
+            workspaceId,
+            enabled,
+            recipientSessionId: options?.recipientSessionId,
+            deliveryMode: options?.deliveryMode,
+            resume: options?.resume,
+            expectedBindingRevision: options?.expectedBindingRevision ?? config?.bindingRevision ?? 0,
         });
-        return action;
-    }
-    async stopActiveRatchetSessionsForMergedPr(workspaceId, signal) {
-        signal.throwIfAborted();
-        const sessions = await this.session.findSessionsByWorkspaceId(workspaceId);
-        signal.throwIfAborted();
-        const activeRatchetSessions = sessions.filter((session) => session.workflow === 'ratchet' &&
-            (session.status === SessionStatus.RUNNING || session.status === SessionStatus.IDLE));
-        for (const session of activeRatchetSessions) {
-            signal.throwIfAborted();
-            if (!this.session.isSessionRunning(session.id)) {
-                continue;
+        if (result.status === 'updated') {
+            if (enabled !== (config?.enabled ?? false)) {
+                this.emit(RATCHET_TOGGLED, { workspaceId, enabled, ratchetState: RatchetState.IDLE });
             }
-            await this.session.stopSession(session.id);
-            signal.throwIfAborted();
-        }
-    }
-    async stopActiveRatchetSessionsAfterDisable(workspaceId) {
-        const sessions = await this.session.findSessionsByWorkspaceId(workspaceId);
-        const activeRatchetSessions = sessions.filter((session) => session.workflow === 'ratchet' &&
-            (session.status === SessionStatus.RUNNING || session.status === SessionStatus.IDLE));
-        for (const session of activeRatchetSessions) {
-            if (!this.session.isSessionRunning(session.id)) {
-                continue;
-            }
-            try {
-                await this.session.stopSession(session.id);
-            }
-            catch (error) {
-                logger.warn('Failed to stop ratchet session after disabling ratchet', {
-                    workspaceId,
-                    sessionId: session.id,
-                    error: error instanceof Error ? error.message : String(error),
-                });
+            else {
+                this.emit(RATCHET_DISPATCH_CHANGED, { workspaceId });
             }
         }
+        return result;
     }
 }
 export const ratchetService = new RatchetService();