factory-factory 0.3.8 → 0.3.9

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

@@ -1,17 +1,15 @@
 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 { SERVICE_CONCURRENCY, SERVICE_INTERVAL_MS, 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';
+import { CIStatus, RatchetState } from '../../../shared/core/index.js';
+import { getActiveRatchetSession as getActiveRatchetSessionHelper, hasActiveSession as hasActiveSessionHelper, } from './ratchet-active-session.helpers.js';
+import { triggerRatchetFixer } from './ratchet-fixer-dispatch.helpers.js';
+import { buildFailedCheckDiagnostics as buildFailedCheckDiagnosticsHelper, buildReviewTimestampDiagnostics as buildReviewTimestampDiagnosticsHelper, buildSnapshotDiagnostics as buildSnapshotDiagnosticsHelper, computeDispatchSnapshotKey as computeDispatchSnapshotKeyHelper, computeLatestReviewActivityAtMs as computeLatestReviewActivityAtMsHelper, determineRatchetState as determineRatchetStateHelper, fetchPRState as fetchPRStateHelper, getAuthenticatedUsernameCached as getAuthenticatedUsernameCachedHelper, hasNewReviewActivitySinceLastDispatch as hasNewReviewActivitySinceLastDispatchHelper, shouldSkipCleanPR as shouldSkipCleanPRHelper, } from './ratchet-pr-state.helpers.js';
+import { handleReviewCommentPoll as handleReviewCommentPollHelper } from './ratchet-review-poll.helpers.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 {
@@ -152,6 +150,9 @@ class RatchetService extends EventEmitter {
         }
         return this.runWorkspaceCheckSafely(workspace);
     }
+    async clearRatchetActiveSessionIfMatching(workspaceId, sessionId) {
+        await workspaceAccessor.clearRatchetActiveSession(workspaceId, sessionId);
+    }
     async runWorkspaceCheckSafely(workspace) {
         const checkPromise = this.runWorkspaceCheck(workspace.id, () => this.processWorkspace(workspace));
         try {
@@ -159,9 +160,10 @@ class RatchetService extends EventEmitter {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            logger.error('Ratchet workspace check failed', error, {
+            logger.warn('Ratchet workspace check failed', {
                 workspaceId: workspace.id,
                 prUrl: workspace.prUrl,
+                error: errorMessage,
             });
             return {
                 workspaceId: workspace.id,
@@ -216,10 +218,16 @@ class RatchetService extends EventEmitter {
         }
         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,
-            });
+            try {
+                await this.session.stopSession(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,
@@ -376,70 +384,13 @@ class RatchetService extends EventEmitter {
         };
     }
     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),
-            },
-        };
+        return buildSnapshotDiagnosticsHelper(workspace, prStateInfo, decisionContext);
     }
     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),
-            },
-        };
+        return buildReviewTimestampDiagnosticsHelper(workspace, prStateInfo, decisionContext, logger);
     }
     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,
-            };
-        }) ?? []);
+        return buildFailedCheckDiagnosticsHelper(prStateInfo);
     }
     describeNonRatchetingReason(action) {
         switch (action.type) {
@@ -574,105 +525,46 @@ class RatchetService extends EventEmitter {
         return (prStateInfo.reviewComments?.length ?? 0) > 0;
     }
     shouldSkipCleanPR(workspace, prStateInfo) {
-        if (prStateInfo.ciStatus !== CIStatus.SUCCESS || prStateInfo.hasChangesRequested) {
-            return false;
-        }
-        return !this.hasNewReviewActivitySinceLastDispatch(workspace, prStateInfo);
+        return shouldSkipCleanPRHelper(workspace, prStateInfo, logger);
     }
     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;
+        return hasNewReviewActivitySinceLastDispatchHelper(workspace, prStateInfo, logger);
     }
     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' };
+        if (pollResult.action !== 'comments-found') {
+            return null;
         }
-        existing.pollCount++;
-        existing.lastPolledAt = Date.now();
-        if (!this.shouldSkipCleanPR(workspace, freshPrState)) {
-            this.reviewPollTrackers.delete(workspace.id);
-            logger.info('Review comments detected during poll', {
+        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,
-                pollNumber: existing.pollCount,
-                latestReviewActivityAtMs: freshPrState.latestReviewActivityAtMs,
+                fromState: freshContext.previousState,
+                toState: freshContext.finalState,
             });
-            return { action: 'comments-found', freshPrState };
         }
-        return { action: 'waiting' };
+        this.logWorkspaceRatchetingDecision(workspace, freshContext.previousState, freshContext.finalState, freshAction, pollResult.freshPrState, freshContext);
+        return {
+            workspaceId: workspace.id,
+            previousState: freshContext.previousState,
+            newState: freshContext.finalState,
+            action: freshAction,
+        };
+    }
+    async handleReviewCommentPoll(workspace, prStateInfo, authenticatedUsername) {
+        return await handleReviewCommentPollHelper({
+            workspace,
+            prStateInfo,
+            authenticatedUsername,
+            reviewPollTrackers: this.reviewPollTrackers,
+            isShuttingDown: this.isShuttingDown,
+            fetchPRState: (workspaceArg, authenticatedUsernameArg) => this.fetchPRState(workspaceArg, authenticatedUsernameArg),
+            shouldSkipCleanPR: (workspaceArg, prStateInfoArg) => this.shouldSkipCleanPR(workspaceArg, prStateInfoArg),
+            logger,
+        });
     }
     hasStateChangedSinceLastDispatch(workspace, prStateInfo) {
         return workspace.ratchetLastCiRunId !== prStateInfo.snapshotKey;
@@ -694,286 +586,67 @@ class RatchetService extends EventEmitter {
         }
     }
     async getActiveRatchetSession(workspace) {
-        if (!workspace.ratchetActiveSessionId) {
-            return null;
-        }
-        const resolvedRatchetProvider = await ratchetProviderResolverService.resolveRatchetProvider({
-            workspaceId: workspace.id,
+        return await getActiveRatchetSessionHelper({
             workspace,
+            sessionBridge: this.session,
+            snapshotBridge: this.snapshot,
+            resetDispatchState: (workspaceId) => this.resetDispatchState(workspaceId),
+            clearActiveSession: (workspaceId) => this.clearActiveSession(workspaceId),
+            logger,
         });
-        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,
-        };
+        return await hasActiveSessionHelper(workspaceId, this.session);
     }
     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;
-        }
+        return await fetchPRStateHelper({
+            workspace,
+            authenticatedUsername,
+            github: this.github,
+            backoff: this.backoff,
+            logger,
+            computeLatestReviewActivityAtMs: (prDetails, reviewComments, authenticatedUsernameArg) => this.computeLatestReviewActivityAtMs(prDetails, reviewComments, authenticatedUsernameArg),
+            computeDispatchSnapshotKey: (ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks) => this.computeDispatchSnapshotKey(ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks),
+        });
     }
     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}`;
+        return computeDispatchSnapshotKeyHelper(ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusChecks);
     }
     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;
+        return computeLatestReviewActivityAtMsHelper(prDetails, reviewComments, 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,
-        };
+        const { username, cache } = await getAuthenticatedUsernameCachedHelper({
+            cachedValue: this.cachedAuthenticatedUsername,
+            github: this.github,
+        });
+        this.cachedAuthenticatedUsername = cache;
         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;
+        return determineRatchetStateHelper(pr);
     }
     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 };
-        }
+        return await triggerRatchetFixer({
+            workspace,
+            prStateInfo,
+            sessionBridge: this.session,
+            setActiveSession: (workspaceId, sessionId) => this.setActiveSession(workspaceId, sessionId),
+            clearActiveSession: (workspaceId) => this.clearActiveSession(workspaceId),
+            logger,
+        });
+    }
+    async setActiveSession(workspaceId, sessionId) {
+        await workspaceAccessor.update(workspaceId, { ratchetActiveSessionId: sessionId });
+    }
+    async clearActiveSession(workspaceId) {
+        await workspaceAccessor.update(workspaceId, { ratchetActiveSessionId: null });
+    }
+    async resetDispatchState(workspaceId) {
+        await workspaceAccessor.update(workspaceId, {
+            ratchetActiveSessionId: null,
+            ratchetLastCiRunId: null,
+        });
     }
 }
 export const ratchetService = new RatchetService();