factory-factory 0.3.8 → 0.3.10

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

@@ -1,980 +0,0 @@
-import { EventEmitter } from 'node:events';
-import pLimit from 'p-limit';
-import { buildRatchetDispatchPrompt } from '../../../backend/prompts/ratchet-dispatch.js';
-import { agentSessionAccessor } from '../../../backend/resource_accessors/agent-session.accessor.js';
-import { workspaceAccessor } from '../../../backend/resource_accessors/workspace.accessor.js';
-import { SERVICE_CACHE_TTL_MS, SERVICE_CONCURRENCY, SERVICE_INTERVAL_MS, SERVICE_THRESHOLDS, SERVICE_TIMEOUT_MS, } from '../../../backend/services/constants.js';
-import { createLogger } from '../../../backend/services/logger.service.js';
-import { RateLimitBackoff } from '../../../backend/services/rate-limit-backoff.js';
-import { CIStatus, RatchetState, SessionStatus } from '../../../shared/core/index.js';
-import { fixerSessionService } from './fixer-session.service.js';
-import { ratchetProviderResolverService } from './ratchet-provider-resolver.service.js';
-const logger = createLogger('ratchet');
-const RATCHET_WORKFLOW = 'ratchet';
-const REVIEW_POLL_INTERVAL_MS = 2 * 60_000;
-export const RATCHET_STATE_CHANGED = 'ratchet_state_changed';
-export const RATCHET_TOGGLED = 'ratchet_toggled';
-class RatchetService extends EventEmitter {
-    isShuttingDown = false;
-    monitorLoop = null;
-    sleepTimeout = null;
-    sleepResolve = null;
-    workspaceCheckTimeoutMs = SERVICE_TIMEOUT_MS.ratchetWorkspaceCheck;
-    checkLimit = pLimit(SERVICE_CONCURRENCY.ratchetWorkspaceChecks);
-    inFlightWorkspaceChecks = new Map();
-    cachedAuthenticatedUsername = null;
-    backoff = new RateLimitBackoff();
-    reviewPollTrackers = new Map();
-    sessionBridge = null;
-    githubBridge = null;
-    snapshotBridge = null;
-    configure(bridges) {
-        this.sessionBridge = bridges.session;
-        this.githubBridge = bridges.github;
-        this.snapshotBridge = bridges.snapshot;
-    }
-    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() {
-        if (this.monitorLoop !== null) {
-            return;
-        }
-        this.isShuttingDown = false;
-        this.monitorLoop = this.runContinuousLoop();
-        logger.info('Ratchet service started', { intervalMs: SERVICE_INTERVAL_MS.ratchetPoll });
-    }
-    async stop() {
-        this.isShuttingDown = true;
-        this.wakeSleep();
-        if (this.monitorLoop !== null) {
-            logger.debug('Waiting for ratchet monitor loop to complete');
-            await this.monitorLoop;
-            this.monitorLoop = null;
-        }
-        logger.info('Ratchet service stopped');
-    }
-    async runContinuousLoop() {
-        while (!this.isShuttingDown) {
-            try {
-                this.backoff.beginCycle();
-                await this.checkAllWorkspaces();
-                this.backoff.resetIfCleanCycle(logger, 'Ratchet');
-            }
-            catch (err) {
-                logger.error('Ratchet check failed', err);
-            }
-            if (!this.isShuttingDown) {
-                const delayMs = this.backoff.computeDelay(SERVICE_INTERVAL_MS.ratchetPoll);
-                if (this.backoff.currentMultiplier > 1) {
-                    logger.debug('Using backoff delay for next ratchet check', {
-                        baseIntervalMs: SERVICE_INTERVAL_MS.ratchetPoll,
-                        backoffMultiplier: this.backoff.currentMultiplier,
-                        delayMs,
-                    });
-                }
-                await this.sleep(delayMs);
-            }
-        }
-    }
-    sleep(ms) {
-        return new Promise((resolve) => {
-            let settled = false;
-            const finish = () => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                if (this.sleepTimeout) {
-                    clearTimeout(this.sleepTimeout);
-                    this.sleepTimeout = null;
-                }
-                if (this.sleepResolve === finish) {
-                    this.sleepResolve = null;
-                }
-                resolve();
-            };
-            this.sleepResolve = finish;
-            this.sleepTimeout = setTimeout(finish, ms);
-            if (this.isShuttingDown) {
-                finish();
-            }
-        });
-    }
-    wakeSleep() {
-        const resolveSleep = this.sleepResolve;
-        if (resolveSleep) {
-            resolveSleep();
-        }
-    }
-    async checkAllWorkspaces() {
-        if (this.isShuttingDown) {
-            return { checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] };
-        }
-        const workspaces = await workspaceAccessor.findWithPRsForRatchet();
-        if (workspaces.length === 0) {
-            return { checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] };
-        }
-        const results = await Promise.all(workspaces.map((workspace) => this.checkLimit(() => this.runWorkspaceCheckSafely(workspace))));
-        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 };
-    }
-    async checkWorkspaceById(workspaceId) {
-        if (this.isShuttingDown) {
-            return null;
-        }
-        const workspace = await workspaceAccessor.findForRatchetById(workspaceId);
-        if (!workspace) {
-            return null;
-        }
-        return this.runWorkspaceCheckSafely(workspace);
-    }
-    async runWorkspaceCheckSafely(workspace) {
-        const checkPromise = this.runWorkspaceCheck(workspace.id, () => this.processWorkspace(workspace));
-        try {
-            return await this.withWorkspaceCheckTimeout(workspace, checkPromise);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error('Ratchet workspace check failed', error, {
-                workspaceId: workspace.id,
-                prUrl: workspace.prUrl,
-            });
-            return {
-                workspaceId: workspace.id,
-                previousState: workspace.ratchetState,
-                newState: workspace.ratchetState,
-                action: { type: 'ERROR', error: errorMessage },
-            };
-        }
-    }
-    withWorkspaceCheckTimeout(workspace, checkPromise) {
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                if (this.inFlightWorkspaceChecks.get(workspace.id) === checkPromise) {
-                    this.inFlightWorkspaceChecks.delete(workspace.id);
-                }
-                reject(new Error(`Workspace check timed out after ${this.workspaceCheckTimeoutMs}ms`));
-            }, this.workspaceCheckTimeoutMs);
-            timeout.unref?.();
-            checkPromise.then(resolve, reject).finally(() => {
-                clearTimeout(timeout);
-            });
-        });
-    }
-    runWorkspaceCheck(workspaceId, runner) {
-        const existing = this.inFlightWorkspaceChecks.get(workspaceId);
-        if (existing) {
-            return existing;
-        }
-        const inFlight = runner().finally(() => {
-            if (this.inFlightWorkspaceChecks.get(workspaceId) === inFlight) {
-                this.inFlightWorkspaceChecks.delete(workspaceId);
-            }
-        });
-        this.inFlightWorkspaceChecks.set(workspaceId, inFlight);
-        return inFlight;
-    }
-    async setWorkspaceRatcheting(workspaceId, enabled) {
-        const workspace = await workspaceAccessor.findById(workspaceId);
-        if (!workspace) {
-            throw new Error(`Workspace not found: ${workspaceId}`);
-        }
-        if (enabled) {
-            await workspaceAccessor.update(workspaceId, {
-                ratchetEnabled: true,
-            });
-            this.emit(RATCHET_TOGGLED, {
-                workspaceId,
-                enabled: true,
-                ratchetState: workspace.ratchetState,
-            });
-            return;
-        }
-        const activeSessionId = workspace.ratchetActiveSessionId;
-        if (activeSessionId && this.session.isSessionRunning(activeSessionId)) {
-            await this.safeStopSession(activeSessionId, 'Failed to stop active ratchet session while disabling ratchet', {
-                workspaceId,
-                sessionId: activeSessionId,
-            });
-        }
-        await workspaceAccessor.update(workspaceId, {
-            ratchetEnabled: false,
-            ratchetState: RatchetState.IDLE,
-            ratchetActiveSessionId: null,
-            ratchetLastCiRunId: null,
-        });
-        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) {
-        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 newState = RatchetState.IDLE;
-            await workspaceAccessor.update(workspace.id, {
-                ratchetState: newState,
-                ratchetLastCheckedAt: new Date(),
-            });
-            if (workspace.ratchetState !== newState) {
-                this.emit(RATCHET_STATE_CHANGED, {
-                    workspaceId: workspace.id,
-                    fromState: workspace.ratchetState,
-                    toState: newState,
-                });
-            }
-            this.logWorkspaceRatchetingDecision(workspace, workspace.ratchetState, newState, action, null);
-            return {
-                workspaceId: workspace.id,
-                previousState: workspace.ratchetState,
-                newState,
-                action,
-            };
-        }
-        try {
-            const authenticatedUsername = await this.getAuthenticatedUsernameCached();
-            const prStateInfo = await this.fetchPRState(workspace, authenticatedUsername);
-            if (!prStateInfo) {
-                const action = { type: 'ERROR', error: 'Failed to fetch PR state' };
-                this.logWorkspaceRatchetingDecision(workspace, workspace.ratchetState, workspace.ratchetState, action, null);
-                return {
-                    workspaceId: workspace.id,
-                    previousState: workspace.ratchetState,
-                    newState: workspace.ratchetState,
-                    action,
-                };
-            }
-            const decisionContext = await this.buildRatchetDecisionContext(workspace, prStateInfo);
-            const decision = this.decideRatchetAction(decisionContext);
-            if (prStateInfo.prState === 'MERGED') {
-                this.reviewPollTrackers.delete(workspace.id);
-            }
-            else if (decisionContext.isCleanPrWithNoNewReviewActivity) {
-                const pollDispatch = await this.processReviewCommentPoll(workspace, prStateInfo, authenticatedUsername);
-                if (pollDispatch) {
-                    return pollDispatch;
-                }
-            }
-            else {
-                this.reviewPollTrackers.delete(workspace.id);
-            }
-            const action = await this.applyRatchetDecision(decisionContext, decision);
-            await this.updateWorkspaceAfterCheck(workspace, prStateInfo, action, decisionContext.finalState);
-            if (decisionContext.previousState !== decisionContext.finalState) {
-                this.emit(RATCHET_STATE_CHANGED, {
-                    workspaceId: workspace.id,
-                    fromState: decisionContext.previousState,
-                    toState: decisionContext.finalState,
-                });
-            }
-            this.logWorkspaceRatchetingDecision(workspace, decisionContext.previousState, decisionContext.finalState, action, prStateInfo, decisionContext);
-            return {
-                workspaceId: workspace.id,
-                previousState: decisionContext.previousState,
-                newState: decisionContext.finalState,
-                action,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error('Error processing workspace in ratchet', 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) {
-        const prNumber = prStateInfo?.prNumber ?? workspace.prNumber;
-        const prNumberLabel = prNumber ?? 'unknown';
-        const workspacePrPrefix = `workspace ${workspace.id} for PR #${prNumberLabel}`;
-        const context = this.buildRatchetingLogContext(workspace, previousState, newState, action, prStateInfo, prNumber, decisionContext);
-        if (action.type === 'TRIGGERED_FIXER') {
-            logger.info(`Ratcheting ${workspacePrPrefix}`, {
-                ...context,
-                sessionId: action.sessionId,
-                promptSent: action.promptSent,
-            });
-            return;
-        }
-        const reason = this.describeNonRatchetingReason(action);
-        logger.info(`Not ratcheting ${workspacePrPrefix} because ${reason}`, context);
-    }
-    buildRatchetingLogContext(workspace, previousState, newState, action, prStateInfo, prNumber, decisionContext) {
-        const reviewDiagnostics = this.buildReviewTimestampDiagnostics(workspace, prStateInfo, decisionContext);
-        const snapshotDiagnostics = this.buildSnapshotDiagnostics(workspace, prStateInfo, decisionContext);
-        const latestReviewActivityAt = reviewDiagnostics.latestReviewActivityAtMs;
-        return {
-            workspaceId: workspace.id,
-            prUrl: workspace.prUrl,
-            prNumber,
-            prState: prStateInfo?.prState ?? null,
-            ciStatus: prStateInfo?.ciStatus ?? null,
-            hasChangesRequested: prStateInfo?.hasChangesRequested ?? null,
-            snapshotKey: prStateInfo?.snapshotKey ?? null,
-            ciSnapshotKey: snapshotDiagnostics.ciSnapshotKey,
-            snapshotComparison: snapshotDiagnostics.snapshotComparison,
-            previousState,
-            newState,
-            ratchetEnabled: workspace.ratchetEnabled,
-            ratchetActiveSessionId: workspace.ratchetActiveSessionId,
-            ratchetLastCiRunId: workspace.ratchetLastCiRunId,
-            ciStatusCheckRollup: prStateInfo?.statusCheckRollup ?? null,
-            ciFailedChecks: this.buildFailedCheckDiagnostics(prStateInfo),
-            prReviewLastCheckedAt: workspace.prReviewLastCheckedAt?.toISOString() ?? null,
-            latestReviewActivityAt: latestReviewActivityAt
-                ? new Date(latestReviewActivityAt).toISOString()
-                : null,
-            reviewTimestampComparison: reviewDiagnostics.reviewTimestampComparison,
-            actionType: action.type,
-        };
-    }
-    buildSnapshotDiagnostics(workspace, prStateInfo, decisionContext) {
-        if (!prStateInfo) {
-            return {
-                ciSnapshotKey: null,
-                snapshotComparison: null,
-            };
-        }
-        return {
-            ciSnapshotKey: this.computeCiSnapshotKey(prStateInfo.ciStatus, prStateInfo.statusCheckRollup),
-            snapshotComparison: {
-                previousDispatchSnapshotKey: workspace.ratchetLastCiRunId,
-                currentSnapshotKey: prStateInfo.snapshotKey,
-                changedSinceLastDispatch: decisionContext?.hasStateChangedSinceLastDispatch ??
-                    this.hasStateChangedSinceLastDispatch(workspace, prStateInfo),
-            },
-        };
-    }
-    buildReviewTimestampDiagnostics(workspace, prStateInfo, decisionContext) {
-        const latestReviewActivityAtMs = prStateInfo?.latestReviewActivityAtMs ?? null;
-        const prReviewLastCheckedAtMs = workspace.prReviewLastCheckedAt?.getTime() ?? null;
-        const deltaMs = latestReviewActivityAtMs !== null && prReviewLastCheckedAtMs !== null
-            ? latestReviewActivityAtMs - prReviewLastCheckedAtMs
-            : null;
-        if (!prStateInfo) {
-            return {
-                latestReviewActivityAtMs,
-                reviewTimestampComparison: null,
-            };
-        }
-        return {
-            latestReviewActivityAtMs,
-            reviewTimestampComparison: {
-                prReviewLastCheckedAt: workspace.prReviewLastCheckedAt?.toISOString() ?? null,
-                latestReviewActivityAt: latestReviewActivityAtMs !== null
-                    ? new Date(latestReviewActivityAtMs).toISOString()
-                    : null,
-                prReviewLastCheckedAtMs,
-                latestReviewActivityAtMs,
-                deltaMs,
-                hasNewReviewActivitySinceLastDispatch: decisionContext?.hasNewReviewActivitySinceLastDispatch !== undefined
-                    ? decisionContext.hasNewReviewActivitySinceLastDispatch
-                    : this.hasNewReviewActivitySinceLastDispatch(workspace, prStateInfo),
-            },
-        };
-    }
-    buildFailedCheckDiagnostics(prStateInfo) {
-        return (prStateInfo?.statusCheckRollup
-            ?.filter((check) => {
-            const conclusion = check.conclusion?.toUpperCase();
-            return (conclusion === 'FAILURE' ||
-                conclusion === 'TIMED_OUT' ||
-                conclusion === 'CANCELLED' ||
-                conclusion === 'ERROR' ||
-                conclusion === 'ACTION_REQUIRED');
-        })
-            .map((check) => {
-            const runIdMatch = check.detailsUrl?.match(/\/actions\/runs\/(\d+)/);
-            return {
-                name: check.name ?? 'unknown',
-                status: check.status ?? null,
-                conclusion: check.conclusion ?? null,
-                runId: runIdMatch?.[1] ?? null,
-                detailsUrl: check.detailsUrl ?? null,
-            };
-        }) ?? []);
-    }
-    describeNonRatchetingReason(action) {
-        switch (action.type) {
-            case 'WAITING':
-                return action.reason;
-            case 'FIXER_ACTIVE':
-                return `Ratchet fixer session is already active (${action.sessionId})`;
-            case 'DISABLED':
-                return action.reason;
-            case 'COMPLETED':
-                return 'PR is already merged';
-            case 'ERROR':
-                return action.error;
-        }
-        const exhaustiveCheck = action;
-        throw new Error(`Unhandled ratchet action: ${JSON.stringify(exhaustiveCheck)}`);
-    }
-    async buildRatchetDecisionContext(workspace, prStateInfo) {
-        const previousState = workspace.ratchetState;
-        const newState = this.determineRatchetState(prStateInfo);
-        const finalState = workspace.ratchetEnabled ? newState : RatchetState.IDLE;
-        const hasNewReviewActivitySinceLastDispatch = this.hasNewReviewActivitySinceLastDispatch(workspace, prStateInfo);
-        const hasStateChangedSinceLastDispatch = this.hasStateChangedSinceLastDispatch(workspace, prStateInfo);
-        const isCleanPrWithNoNewReviewActivity = this.shouldSkipCleanPR(workspace, prStateInfo);
-        const activityChecks = await this.collectRatchetingActivityChecks(workspace, prStateInfo, isCleanPrWithNoNewReviewActivity, hasStateChangedSinceLastDispatch);
-        return {
-            workspace,
-            prStateInfo,
-            previousState,
-            newState,
-            finalState,
-            hasNewReviewActivitySinceLastDispatch,
-            hasStateChangedSinceLastDispatch,
-            isCleanPrWithNoNewReviewActivity,
-            activeRatchetSession: activityChecks.activeRatchetSession,
-            hasOtherActiveSession: activityChecks.hasOtherActiveSession,
-        };
-    }
-    async collectRatchetingActivityChecks(workspace, prStateInfo, isCleanPrWithNoNewReviewActivity, hasStateChangedSinceLastDispatch) {
-        if (!workspace.ratchetEnabled ||
-            prStateInfo.prState !== 'OPEN' ||
-            isCleanPrWithNoNewReviewActivity) {
-            return {
-                activeRatchetSession: null,
-                hasOtherActiveSession: false,
-            };
-        }
-        const activeRatchetSession = await this.getActiveRatchetSession(workspace);
-        if (activeRatchetSession) {
-            return {
-                activeRatchetSession,
-                hasOtherActiveSession: false,
-            };
-        }
-        if (!hasStateChangedSinceLastDispatch) {
-            return {
-                activeRatchetSession: null,
-                hasOtherActiveSession: false,
-            };
-        }
-        return {
-            activeRatchetSession: null,
-            hasOtherActiveSession: await this.hasActiveSession(workspace.id),
-        };
-    }
-    decideRatchetAction(context) {
-        if (!context.workspace.ratchetEnabled) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'DISABLED', reason: 'Workspace ratcheting disabled' },
-            };
-        }
-        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) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'Waiting for CI to complete (not in terminal state)' },
-            };
-        }
-        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.activeRatchetSession) {
-            return { type: 'RETURN_ACTION', action: context.activeRatchetSession };
-        }
-        if (!context.hasStateChangedSinceLastDispatch) {
-            return {
-                type: 'RETURN_ACTION',
-                action: { type: 'WAITING', reason: 'PR state unchanged since last ratchet dispatch' },
-            };
-        }
-        if (context.hasOtherActiveSession) {
-            return {
-                type: 'RETURN_ACTION',
-                action: {
-                    type: 'WAITING',
-                    reason: 'Workspace is not idle (active session)',
-                },
-            };
-        }
-        return { type: 'TRIGGER_FIXER' };
-    }
-    async applyRatchetDecision(context, decision) {
-        if (decision.type === 'RETURN_ACTION') {
-            return decision.action;
-        }
-        return await this.triggerFixer(context.workspace, context.prStateInfo);
-    }
-    hasActionableFixTrigger(prStateInfo) {
-        if (prStateInfo.ciStatus === CIStatus.FAILURE) {
-            return true;
-        }
-        return (prStateInfo.reviewComments?.length ?? 0) > 0;
-    }
-    shouldSkipCleanPR(workspace, prStateInfo) {
-        if (prStateInfo.ciStatus !== CIStatus.SUCCESS || prStateInfo.hasChangesRequested) {
-            return false;
-        }
-        return !this.hasNewReviewActivitySinceLastDispatch(workspace, prStateInfo);
-    }
-    hasNewReviewActivitySinceLastDispatch(workspace, prStateInfo) {
-        if (prStateInfo.latestReviewActivityAtMs === null) {
-            return false;
-        }
-        if (!workspace.prReviewLastCheckedAt) {
-            return true;
-        }
-        if (prStateInfo.latestReviewActivityAtMs > workspace.prReviewLastCheckedAt.getTime()) {
-            return true;
-        }
-        if (!workspace.ratchetActiveSessionId) {
-            const age = Date.now() - workspace.prReviewLastCheckedAt.getTime();
-            if (age > SERVICE_THRESHOLDS.ratchetReviewCheckStaleMs) {
-                logger.info('Review check timestamp is stale with no active session, treating as new activity', {
-                    workspaceId: workspace.id,
-                    checkedAtAge: Math.round(age / 1000),
-                });
-                return true;
-            }
-        }
-        return false;
-    }
-    async processReviewCommentPoll(workspace, prStateInfo, authenticatedUsername) {
-        const pollResult = await this.handleReviewCommentPoll(workspace, prStateInfo, authenticatedUsername);
-        if (pollResult.action === 'comments-found') {
-            const freshContext = await this.buildRatchetDecisionContext(workspace, pollResult.freshPrState);
-            const freshDecision = this.decideRatchetAction(freshContext);
-            const freshAction = await this.applyRatchetDecision(freshContext, freshDecision);
-            await this.updateWorkspaceAfterCheck(workspace, pollResult.freshPrState, freshAction, freshContext.finalState);
-            if (freshContext.previousState !== freshContext.finalState) {
-                this.emit(RATCHET_STATE_CHANGED, {
-                    workspaceId: workspace.id,
-                    fromState: freshContext.previousState,
-                    toState: freshContext.finalState,
-                });
-            }
-            this.logWorkspaceRatchetingDecision(workspace, freshContext.previousState, freshContext.finalState, freshAction, pollResult.freshPrState, freshContext);
-            return {
-                workspaceId: workspace.id,
-                previousState: freshContext.previousState,
-                newState: freshContext.finalState,
-                action: freshAction,
-            };
-        }
-        return null;
-    }
-    async handleReviewCommentPoll(workspace, prStateInfo, authenticatedUsername) {
-        const existing = this.reviewPollTrackers.get(workspace.id);
-        if (!existing) {
-            this.reviewPollTrackers.set(workspace.id, {
-                snapshotKey: prStateInfo.snapshotKey,
-                lastPolledAt: Date.now(),
-                pollCount: 0,
-            });
-            logger.info('Started review comment polling', {
-                workspaceId: workspace.id,
-                snapshotKey: prStateInfo.snapshotKey,
-            });
-            return { action: 'waiting' };
-        }
-        if (existing.snapshotKey !== prStateInfo.snapshotKey) {
-            this.reviewPollTrackers.set(workspace.id, {
-                snapshotKey: prStateInfo.snapshotKey,
-                lastPolledAt: Date.now(),
-                pollCount: 0,
-            });
-            logger.info('Reset review comment polling (new snapshot)', {
-                workspaceId: workspace.id,
-                snapshotKey: prStateInfo.snapshotKey,
-            });
-            return { action: 'waiting' };
-        }
-        if (Date.now() - existing.lastPolledAt < REVIEW_POLL_INTERVAL_MS) {
-            return { action: 'waiting' };
-        }
-        if (this.isShuttingDown) {
-            return { action: 'waiting' };
-        }
-        const freshPrState = await this.fetchPRState(workspace, authenticatedUsername);
-        if (!freshPrState) {
-            return { action: 'waiting' };
-        }
-        existing.pollCount++;
-        existing.lastPolledAt = Date.now();
-        if (!this.shouldSkipCleanPR(workspace, freshPrState)) {
-            this.reviewPollTrackers.delete(workspace.id);
-            logger.info('Review comments detected during poll', {
-                workspaceId: workspace.id,
-                pollNumber: existing.pollCount,
-                latestReviewActivityAtMs: freshPrState.latestReviewActivityAtMs,
-            });
-            return { action: 'comments-found', freshPrState };
-        }
-        return { action: 'waiting' };
-    }
-    hasStateChangedSinceLastDispatch(workspace, prStateInfo) {
-        return workspace.ratchetLastCiRunId !== prStateInfo.snapshotKey;
-    }
-    async updateWorkspaceAfterCheck(workspace, prStateInfo, action, nextState) {
-        const now = new Date();
-        const dispatched = action.type === 'TRIGGERED_FIXER' && action.promptSent;
-        await workspaceAccessor.update(workspace.id, {
-            ratchetState: nextState,
-            ratchetLastCheckedAt: now,
-            ...(dispatched
-                ? {
-                    ratchetLastCiRunId: prStateInfo.snapshotKey,
-                }
-                : {}),
-        });
-        if (dispatched) {
-            await this.snapshot.recordReviewCheck(workspace.id, now);
-        }
-    }
-    async getActiveRatchetSession(workspace) {
-        if (!workspace.ratchetActiveSessionId) {
-            return null;
-        }
-        const resolvedRatchetProvider = await ratchetProviderResolverService.resolveRatchetProvider({
-            workspaceId: workspace.id,
-            workspace,
-        });
-        const session = await agentSessionAccessor.findById(workspace.ratchetActiveSessionId);
-        if (!session) {
-            await this.clearFailedRatchetDispatch(workspace, 'session not found in database');
-            return null;
-        }
-        if (session.provider !== resolvedRatchetProvider) {
-            await this.clearFailedRatchetDispatch(workspace, `provider mismatch: expected ${resolvedRatchetProvider}, got ${session.provider}`);
-            await this.stopSessionForProviderMismatch(workspace.id, session.id, resolvedRatchetProvider, session.provider);
-            return null;
-        }
-        if (session.status !== SessionStatus.RUNNING) {
-            await this.clearFailedRatchetDispatch(workspace, `session status is ${session.status}`);
-            return null;
-        }
-        if (!this.session.isSessionRunning(session.id)) {
-            await this.clearFailedRatchetDispatch(workspace, 'session process is not running');
-            return null;
-        }
-        if (!this.session.isSessionWorking(session.id)) {
-            await this.clearActiveRatchetSession(workspace.id);
-            await this.stopCompletedRatchetSession(workspace.id, session.id);
-            return null;
-        }
-        return { type: 'FIXER_ACTIVE', sessionId: workspace.ratchetActiveSessionId };
-    }
-    async clearFailedRatchetDispatch(workspace, reason) {
-        logger.info('Clearing failed ratchet dispatch, resetting state for retry', {
-            workspaceId: workspace.id,
-            sessionId: workspace.ratchetActiveSessionId,
-            reason,
-        });
-        await workspaceAccessor.update(workspace.id, {
-            ratchetActiveSessionId: null,
-            ratchetLastCiRunId: null,
-        });
-        await this.snapshot.recordReviewCheck(workspace.id, null);
-    }
-    async hasActiveSession(workspaceId) {
-        const sessions = await agentSessionAccessor.findByWorkspaceId(workspaceId);
-        return sessions.some((session) => this.session.isSessionWorking(session.id));
-    }
-    async clearActiveRatchetSession(workspaceId) {
-        await workspaceAccessor.update(workspaceId, { ratchetActiveSessionId: null });
-    }
-    async safeStopSession(sessionId, warningMessage, warningContext) {
-        try {
-            await this.session.stopSession(sessionId);
-        }
-        catch (error) {
-            logger.warn(warningMessage, {
-                ...warningContext,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    async stopCompletedRatchetSession(workspaceId, sessionId) {
-        await this.safeStopSession(sessionId, 'Failed to stop completed ratchet session', {
-            workspaceId,
-            sessionId,
-        });
-    }
-    async stopSessionForProviderMismatch(workspaceId, sessionId, expectedProvider, actualProvider) {
-        await this.safeStopSession(sessionId, 'Failed to stop mismatched ratchet provider session', {
-            workspaceId,
-            sessionId,
-            expectedProvider,
-            actualProvider,
-        });
-    }
-    resolveRatchetPrContext(workspace) {
-        const prInfo = this.github.extractPRInfo(workspace.prUrl);
-        if (!prInfo) {
-            logger.warn('Could not parse PR URL', { prUrl: workspace.prUrl });
-            return null;
-        }
-        const prNumber = workspace.prNumber ?? prInfo.number;
-        if (!prNumber) {
-            logger.warn('Could not determine PR number for ratchet check', {
-                workspaceId: workspace.id,
-                prUrl: workspace.prUrl,
-            });
-            return null;
-        }
-        return {
-            repo: `${prInfo.owner}/${prInfo.repo}`,
-            prNumber,
-        };
-    }
-    async fetchPRState(workspace, authenticatedUsername) {
-        const prContext = this.resolveRatchetPrContext(workspace);
-        if (!prContext) {
-            return null;
-        }
-        try {
-            const [prDetails, reviewComments] = await Promise.all([
-                this.github.getPRFullDetails(prContext.repo, prContext.prNumber),
-                this.github.getReviewComments(prContext.repo, prContext.prNumber),
-            ]);
-            const statusCheckRollup = prDetails.statusCheckRollup?.map((check) => ({
-                name: check.name,
-                status: check.status,
-                conclusion: check.conclusion ?? undefined,
-                detailsUrl: check.detailsUrl,
-            })) ?? null;
-            const ciStatus = this.github.computeCIStatus(statusCheckRollup);
-            const hasChangesRequested = prDetails.reviewDecision === 'CHANGES_REQUESTED';
-            const latestReviewActivityAtMs = this.computeLatestReviewActivityAtMs(prDetails, reviewComments, authenticatedUsername);
-            const snapshotKey = this.computeDispatchSnapshotKey(ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusCheckRollup);
-            const filteredReviewComments = reviewComments
-                .filter((c) => !this.isIgnoredReviewAuthor(c.author.login, authenticatedUsername))
-                .map((c) => ({
-                author: c.author.login,
-                body: c.body,
-                path: c.path,
-                line: c.line,
-                url: c.url,
-            }));
-            return {
-                ciStatus,
-                snapshotKey,
-                hasChangesRequested,
-                latestReviewActivityAtMs,
-                statusCheckRollup,
-                prState: prDetails.state,
-                prNumber: prDetails.number,
-                reviewComments: filteredReviewComments,
-            };
-        }
-        catch (error) {
-            this.backoff.handleError(error, logger, 'Ratchet', { workspaceId: workspace.id, prUrl: workspace.prUrl }, SERVICE_INTERVAL_MS.ratchetPoll);
-            return null;
-        }
-    }
-    computeDispatchSnapshotKey(ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks) {
-        const ciKey = this.computeCiSnapshotKey(ciStatus, statusChecks);
-        const reviewKey = `${hasChangesRequested ? 'changes-requested' : 'no-changes-requested'}:${latestReviewActivityAtMs ?? 'none'}`;
-        return `${ciKey}|${reviewKey}`;
-    }
-    computeCiSnapshotKey(ciStatus, statusChecks) {
-        if (ciStatus !== CIStatus.FAILURE) {
-            return `ci:${ciStatus}`;
-        }
-        const failedChecks = statusChecks?.filter((check) => {
-            const conclusion = check.conclusion?.toUpperCase();
-            return (conclusion === 'FAILURE' ||
-                conclusion === 'TIMED_OUT' ||
-                conclusion === 'CANCELLED' ||
-                conclusion === 'ERROR' ||
-                conclusion === 'ACTION_REQUIRED');
-        }) ?? [];
-        if (failedChecks.length === 0) {
-            return 'ci:FAILURE:unknown';
-        }
-        const signature = failedChecks
-            .map((check) => {
-            const runIdMatch = check.detailsUrl?.match(/\/actions\/runs\/(\d+)/);
-            const runId = runIdMatch?.[1];
-            const stableCheckIdentity = runId ?? check.detailsUrl ?? 'no-run-id-or-details-url';
-            return `${check.name ?? 'unknown'}:${check.conclusion ?? 'UNKNOWN'}:${stableCheckIdentity}`;
-        })
-            .sort()
-            .join('|');
-        return `ci:FAILURE:${signature}`;
-    }
-    computeLatestReviewActivityAtMs(prDetails, reviewComments, authenticatedUsername) {
-        const entries = [
-            ...prDetails.reviews.map((review) => ({
-                authorLogin: review.author.login,
-                timestamp: review.submittedAt,
-            })),
-            ...prDetails.comments.map((comment) => ({
-                authorLogin: comment.author.login,
-                timestamp: comment.updatedAt,
-            })),
-            ...reviewComments.map((reviewComment) => ({
-                authorLogin: reviewComment.author.login,
-                timestamp: reviewComment.updatedAt,
-            })),
-        ];
-        const timestamps = entries
-            .filter((entry) => entry.timestamp !== null &&
-            !this.isIgnoredReviewAuthor(entry.authorLogin, authenticatedUsername))
-            .map((entry) => Date.parse(entry.timestamp))
-            .filter((timestamp) => Number.isFinite(timestamp));
-        return timestamps.length > 0 ? Math.max(...timestamps) : null;
-    }
-    isIgnoredReviewAuthor(authorLogin, authenticatedUsername) {
-        if (!authenticatedUsername) {
-            return false;
-        }
-        return authorLogin === authenticatedUsername;
-    }
-    async getAuthenticatedUsernameCached() {
-        const nowMs = Date.now();
-        if (this.cachedAuthenticatedUsername && this.cachedAuthenticatedUsername.expiresAtMs > nowMs) {
-            return this.cachedAuthenticatedUsername.value;
-        }
-        const username = await this.github.getAuthenticatedUsername();
-        this.cachedAuthenticatedUsername = {
-            value: username,
-            expiresAtMs: nowMs + SERVICE_CACHE_TTL_MS.ratchetAuthenticatedUsername,
-        };
-        return username;
-    }
-    determineRatchetState(pr) {
-        if (pr.prState === 'MERGED') {
-            return RatchetState.MERGED;
-        }
-        if (pr.prState !== 'OPEN') {
-            return RatchetState.IDLE;
-        }
-        if (pr.ciStatus === CIStatus.PENDING || pr.ciStatus === CIStatus.UNKNOWN) {
-            return RatchetState.CI_RUNNING;
-        }
-        if (pr.ciStatus === CIStatus.FAILURE) {
-            return RatchetState.CI_FAILED;
-        }
-        if (pr.hasChangesRequested) {
-            return RatchetState.REVIEW_PENDING;
-        }
-        return RatchetState.READY;
-    }
-    async triggerFixer(workspace, prStateInfo) {
-        try {
-            const result = await fixerSessionService.acquireAndDispatch({
-                workspaceId: workspace.id,
-                workflow: RATCHET_WORKFLOW,
-                sessionName: 'Ratchet',
-                runningIdleAction: 'restart',
-                dispatchMode: 'start_empty_and_send',
-                buildPrompt: () => buildRatchetDispatchPrompt(workspace.prUrl, prStateInfo.prNumber, prStateInfo.reviewComments),
-                beforeStart: ({ sessionId, prompt }) => {
-                    this.session.injectCommittedUserMessage(sessionId, prompt);
-                },
-            });
-            if (result.status === 'started') {
-                const promptSent = result.promptSent ?? true;
-                if (!promptSent) {
-                    logger.warn('Ratchet session started but prompt delivery failed', {
-                        workspaceId: workspace.id,
-                        sessionId: result.sessionId,
-                    });
-                    await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: null });
-                    if (this.session.isSessionRunning(result.sessionId)) {
-                        await this.session.stopSession(result.sessionId);
-                    }
-                    return { type: 'ERROR', error: 'Failed to deliver initial ratchet prompt' };
-                }
-                await workspaceAccessor.update(workspace.id, {
-                    ratchetActiveSessionId: result.sessionId,
-                });
-                return {
-                    type: 'TRIGGERED_FIXER',
-                    sessionId: result.sessionId,
-                    promptSent,
-                };
-            }
-            if (result.status === 'already_active') {
-                await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: result.sessionId });
-                return { type: 'FIXER_ACTIVE', sessionId: result.sessionId };
-            }
-            if (result.status === 'skipped') {
-                return { type: 'ERROR', error: result.reason };
-            }
-            return { type: 'ERROR', error: result.error };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error('Failed to trigger ratchet fixer', error, {
-                workspaceId: workspace.id,
-            });
-            return { type: 'ERROR', error: errorMessage };
-        }
-    }
-}
-export const ratchetService = new RatchetService();
-//# sourceMappingURL=ratchet.service.js.map