factory-factory 0.2.6 → 0.2.8

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

@@ -0,0 +1,756 @@
+import { EventEmitter } from 'node:events';
+import { CIStatus, RatchetState, SessionStatus } from '../../../../prisma/generated/client.js';
+import pLimit from 'p-limit';
+import { buildRatchetDispatchPrompt } from '../../../backend/prompts/ratchet-dispatch.js';
+import { claudeSessionAccessor } from '../../../backend/resource_accessors/claude-session.accessor.js';
+import { workspaceAccessor } from '../../../backend/resource_accessors/workspace.accessor.js';
+import { SERVICE_CACHE_TTL_MS, SERVICE_CONCURRENCY, SERVICE_INTERVAL_MS, } from '../../../backend/services/constants.js';
+import { createLogger } from '../../../backend/services/logger.service.js';
+import { RateLimitBackoff } from '../../../backend/services/rate-limit-backoff.js';
+import { fixerSessionService } from './fixer-session.service.js';
+const logger = createLogger('ratchet');
+const RATCHET_WORKFLOW = 'ratchet';
+export const RATCHET_STATE_CHANGED = 'ratchet_state_changed';
+class RatchetService extends EventEmitter {
+    isShuttingDown = false;
+    monitorLoop = null;
+    sleepTimeout = null;
+    sleepResolve = null;
+    checkLimit = pLimit(SERVICE_CONCURRENCY.ratchetWorkspaceChecks);
+    cachedAuthenticatedUsername = null;
+    backoff = new RateLimitBackoff();
+    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.processWorkspace(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.processWorkspace(workspace);
+    }
+    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,
+            });
+            return;
+        }
+        const activeSessionId = workspace.ratchetActiveSessionId;
+        if (activeSessionId && this.session.isSessionRunning(activeSessionId)) {
+            try {
+                await this.session.stopClaudeSession(activeSessionId);
+            }
+            catch (error) {
+                logger.warn('Failed to stop active ratchet session while disabling ratchet', {
+                    workspaceId,
+                    sessionId: activeSessionId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        await workspaceAccessor.update(workspaceId, {
+            ratchetEnabled: false,
+            ratchetState: RatchetState.IDLE,
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: null,
+        });
+    }
+    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);
+            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 (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);
+    }
+    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;
+        }
+        return prStateInfo.latestReviewActivityAtMs > workspace.prReviewLastCheckedAt.getTime();
+    }
+    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 session = await claudeSessionAccessor.findById(workspace.ratchetActiveSessionId);
+        if (!session) {
+            await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: null });
+            return null;
+        }
+        if (session.status !== SessionStatus.RUNNING) {
+            await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: null });
+            return null;
+        }
+        if (!this.session.isSessionRunning(session.id)) {
+            await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: null });
+            return null;
+        }
+        if (!this.session.isSessionWorking(session.id)) {
+            await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: null });
+            try {
+                await this.session.stopClaudeSession(session.id);
+            }
+            catch (error) {
+                logger.warn('Failed to stop completed ratchet session', {
+                    workspaceId: workspace.id,
+                    sessionId: session.id,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            return null;
+        }
+        return { type: 'FIXER_ACTIVE', sessionId: workspace.ratchetActiveSessionId };
+    }
+    async hasActiveSession(workspaceId) {
+        const sessions = await claudeSessionAccessor.findByWorkspaceId(workspaceId);
+        return sessions.some((session) => this.session.isSessionWorking(session.id));
+    }
+    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);
+            return {
+                ciStatus,
+                snapshotKey,
+                hasChangesRequested,
+                latestReviewActivityAtMs,
+                statusCheckRollup,
+                prState: prDetails.state,
+                prNumber: prDetails.number,
+            };
+        }
+        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) => !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),
+                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.stopClaudeSession(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