factory-factory 0.2.4 → 0.2.6

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

@@ -1,21 +1,23 @@
 import { CIStatus, RatchetState, SessionStatus } from '../../../prisma/generated/client.js';
 import pLimit from 'p-limit';
+import { buildRatchetDispatchPrompt } from '../prompts/ratchet-dispatch.js';
 import { claudeSessionAccessor } from '../resource_accessors/claude-session.accessor.js';
-import { userSettingsAccessor } from '../resource_accessors/user-settings.accessor.js';
 import { workspaceAccessor } from '../resource_accessors/workspace.accessor.js';
 import { fixerSessionService } from './fixer-session.service.js';
 import { githubCLIService } from './github-cli.service.js';
 import { createLogger } from './logger.service.js';
-import { messageStateService } from './message-state.service.js';
 import { sessionService } from './session.service.js';
+import { sessionStoreService } from './session-store.service.js';
 const logger = createLogger('ratchet');
 const RATCHET_POLL_INTERVAL_MS = 60_000;
 const MAX_CONCURRENT_CHECKS = 5;
 const RATCHET_WORKFLOW = 'ratchet';
+const AUTHENTICATED_USERNAME_CACHE_TTL_MS = 5 * 60_000;
 class RatchetService {
     isShuttingDown = false;
     monitorLoop = null;
     checkLimit = pLimit(MAX_CONCURRENT_CHECKS);
+    cachedAuthenticatedUsername = null;
     start() {
         if (this.monitorLoop) {
             return;
@@ -53,21 +55,13 @@ class RatchetService {
         if (this.isShuttingDown) {
             return { checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] };
         }
-        const userSettings = await userSettingsAccessor.get();
-        const settings = {
-            autoFixCi: userSettings.ratchetAutoFixCi,
-            autoFixReviews: userSettings.ratchetAutoFixReviews,
-            autoMerge: userSettings.ratchetAutoMerge,
-            allowedReviewers: userSettings.ratchetAllowedReviewers ?? [],
-        };
         const workspaces = await workspaceAccessor.findWithPRsForRatchet();
         if (workspaces.length === 0) {
             return { checked: 0, stateChanges: 0, actionsTriggered: 0, results: [] };
         }
-        logger.debug('Checking workspaces for ratchet progression', { count: workspaces.length });
-        const results = await Promise.all(workspaces.map((workspace) => this.checkLimit(() => this.processWorkspace(workspace, settings))));
+        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' || r.action.type === 'NOTIFIED_ACTIVE_FIXER').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,
@@ -85,16 +79,9 @@ class RatchetService {
         if (!workspace) {
             return null;
         }
-        const userSettings = await userSettingsAccessor.get();
-        const settings = {
-            autoFixCi: userSettings.ratchetAutoFixCi,
-            autoFixReviews: userSettings.ratchetAutoFixReviews,
-            autoMerge: userSettings.ratchetAutoMerge,
-            allowedReviewers: userSettings.ratchetAllowedReviewers ?? [],
-        };
-        return this.processWorkspace(workspace, settings);
+        return this.processWorkspace(workspace);
     }
-    async processWorkspace(workspace, settings) {
+    async processWorkspace(workspace) {
         if (this.isShuttingDown) {
             return {
                 workspaceId: workspace.id,
@@ -104,46 +91,27 @@ class RatchetService {
             };
         }
         try {
-            const prStateInfo = await this.fetchPRState(workspace, settings.allowedReviewers);
+            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: { type: 'ERROR', error: 'Failed to fetch PR state' },
+                    action,
                 };
             }
-            const newState = this.determineRatchetState(prStateInfo);
-            const previousState = workspace.ratchetState;
-            if (newState !== previousState) {
-                logger.info('Ratchet state transition', {
-                    workspaceId: workspace.id,
-                    from: previousState,
-                    to: newState,
-                    prNumber: prStateInfo.prNumber,
-                });
-            }
-            const latestWorkspace = await workspaceAccessor.findById(workspace.id);
-            const shouldTakeAction = latestWorkspace?.ratchetEnabled ?? workspace.ratchetEnabled;
-            const action = shouldTakeAction
-                ? await this.executeRatchetAction(workspace, newState, prStateInfo, settings)
-                : { type: 'DISABLED', reason: 'Workspace ratcheting disabled' };
-            const now = new Date();
-            const shouldRecordCiRunId = shouldTakeAction &&
-                prStateInfo.ciStatus === CIStatus.FAILURE &&
-                !!prStateInfo.ciRunId &&
-                (action.type === 'NOTIFIED_ACTIVE_FIXER' ||
-                    (action.type === 'TRIGGERED_FIXER' && action.promptSent));
-            await workspaceAccessor.update(workspace.id, {
-                ratchetState: shouldTakeAction ? newState : RatchetState.IDLE,
-                ratchetLastCheckedAt: now,
-                ...(shouldRecordCiRunId ? { ratchetLastCiRunId: prStateInfo.ciRunId } : {}),
-                ...(prStateInfo.hasNewReviewComments ? { prReviewLastCheckedAt: now } : {}),
-            });
+            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);
+            this.logWorkspaceRatchetingDecision(workspace, decisionContext.previousState, decisionContext.finalState, action, prStateInfo, decisionContext);
             return {
                 workspaceId: workspace.id,
-                previousState,
-                newState: shouldTakeAction ? newState : RatchetState.IDLE,
+                previousState: decisionContext.previousState,
+                newState: decisionContext.finalState,
                 action,
             };
         }
@@ -152,13 +120,306 @@ class RatchetService {
             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: { type: 'ERROR', error: errorMessage },
+                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.hasNonRatchetActiveSession(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 non-ratchet chat 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,
+                    prReviewLastCheckedAt: 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 (!sessionService.isSessionRunning(session.id)) {
+            await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: null });
+            return null;
+        }
+        return { type: 'FIXER_ACTIVE', sessionId: workspace.ratchetActiveSessionId };
+    }
+    async hasNonRatchetActiveSession(workspaceId) {
+        const sessions = await claudeSessionAccessor.findByWorkspaceId(workspaceId);
+        return sessions.some((session) => {
+            if (session.workflow === RATCHET_WORKFLOW) {
+                return false;
+            }
+            return sessionService.isSessionWorking(session.id);
+        });
     }
     resolveRatchetPrContext(workspace) {
         const prInfo = githubCLIService.extractPRInfo(workspace.prUrl);
@@ -179,7 +440,7 @@ class RatchetService {
             prNumber,
         };
     }
-    async fetchPRState(workspace, allowedReviewers) {
+    async fetchPRState(workspace, authenticatedUsername) {
         const prContext = this.resolveRatchetPrContext(workspace);
         if (!prContext) {
             return null;
@@ -190,56 +451,21 @@ class RatchetService {
                 githubCLIService.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 = githubCLIService.computeCIStatus(statusCheckRollup);
-            const failedChecks = [];
-            if (prDetails.statusCheckRollup) {
-                for (const check of prDetails.statusCheckRollup) {
-                    const conclusion = String(check.conclusion || check.status);
-                    if (conclusion === 'FAILURE' ||
-                        conclusion === 'ACTION_REQUIRED' ||
-                        conclusion === 'ERROR') {
-                        failedChecks.push({
-                            name: check.name || 'Unknown check',
-                            conclusion,
-                            detailsUrl: check.detailsUrl,
-                        });
-                    }
-                }
-            }
-            const ciRunId = this.extractFailedCiSignature(failedChecks);
-            const hasChangesRequested = prDetails.reviews.some((r) => r.state === 'CHANGES_REQUESTED');
-            const lastCheckedAt = workspace.prReviewLastCheckedAt?.getTime() ?? 0;
-            const filterByReviewer = allowedReviewers.length > 0;
-            const newReviewComments = reviewComments.filter((comment) => {
-                const createdTime = new Date(comment.createdAt).getTime();
-                const updatedTime = new Date(comment.updatedAt).getTime();
-                const isNewOrEdited = createdTime > lastCheckedAt || updatedTime > lastCheckedAt;
-                const isAllowedReviewer = !filterByReviewer || allowedReviewers.includes(comment.author.login);
-                return isNewOrEdited && isAllowedReviewer;
-            });
-            const newPRComments = prDetails.comments.filter((comment) => {
-                const createdTime = new Date(comment.createdAt).getTime();
-                const updatedTime = new Date(comment.updatedAt).getTime();
-                const isNewOrEdited = createdTime > lastCheckedAt || updatedTime > lastCheckedAt;
-                const isAllowedReviewer = !filterByReviewer || allowedReviewers.includes(comment.author.login);
-                return isNewOrEdited && isAllowedReviewer;
-            });
-            const hasNewReviewComments = newReviewComments.length > 0 || newPRComments.length > 0;
+            const hasChangesRequested = prDetails.reviewDecision === 'CHANGES_REQUESTED';
+            const latestReviewActivityAtMs = this.computeLatestReviewActivityAtMs(prDetails, reviewComments, authenticatedUsername);
+            const snapshotKey = this.computeDispatchSnapshotKey(ciStatus, hasChangesRequested, latestReviewActivityAtMs, statusCheckRollup);
             return {
                 ciStatus,
-                mergeStateStatus: prDetails.mergeStateStatus,
+                snapshotKey,
                 hasChangesRequested,
-                hasNewReviewComments,
-                failedChecks,
-                ciRunId,
-                reviews: prDetails.reviews,
-                comments: prDetails.comments,
-                reviewComments,
-                newReviewComments,
-                newPRComments,
+                latestReviewActivityAtMs,
+                statusCheckRollup,
                 prState: prDetails.state,
                 prNumber: prDetails.number,
             };
@@ -252,168 +478,95 @@ class RatchetService {
             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 githubCLIService.getAuthenticatedUsername();
+        this.cachedAuthenticatedUsername = {
+            value: username,
+            expiresAtMs: nowMs + AUTHENTICATED_USERNAME_CACHE_TTL_MS,
+        };
+        return username;
+    }
     determineRatchetState(pr) {
         if (pr.prState === 'MERGED') {
             return RatchetState.MERGED;
         }
-        if (pr.ciStatus === CIStatus.PENDING) {
+        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.ciStatus === CIStatus.UNKNOWN) {
-            return RatchetState.CI_RUNNING;
-        }
-        if (pr.hasChangesRequested || pr.hasNewReviewComments) {
+        if (pr.hasChangesRequested) {
             return RatchetState.REVIEW_PENDING;
         }
         return RatchetState.READY;
     }
-    async executeRatchetAction(workspace, state, prStateInfo, settings) {
-        const existingFixerResult = await this.handleExistingFixerSession(workspace, state, prStateInfo);
-        if (existingFixerResult) {
-            return existingFixerResult;
-        }
-        return this.handleStateWithoutActiveFixer(workspace, state, prStateInfo, settings);
-    }
-    async handleExistingFixerSession(workspace, state, prStateInfo) {
-        if (!workspace.ratchetActiveSessionId) {
-            return null;
-        }
-        const session = await claudeSessionAccessor.findById(workspace.ratchetActiveSessionId);
-        const client = sessionService.getClient(workspace.ratchetActiveSessionId);
-        if (!session) {
-            await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: null });
-            return null;
-        }
-        if (session.status === SessionStatus.IDLE) {
-            if (!client) {
-                await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: null });
-            }
-            return null;
-        }
-        if (session.status !== SessionStatus.RUNNING || !client) {
-            await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: null });
-            return null;
-        }
-        const shouldNotify = this.shouldNotifyActiveFixer(state, workspace.ratchetLastNotifiedState, prStateInfo.ciRunId, workspace.ratchetLastCiRunId);
-        if (!shouldNotify) {
-            return { type: 'FIXER_ACTIVE', sessionId: workspace.ratchetActiveSessionId };
-        }
-        const delivered = await this.notifyActiveFixer(workspace, state, prStateInfo, client);
-        if (delivered) {
-            return {
-                type: 'NOTIFIED_ACTIVE_FIXER',
-                sessionId: workspace.ratchetActiveSessionId,
-                issue: state,
-            };
-        }
-        logger.warn('Failed to notify active fixer; clearing stale reference and retrying', {
-            workspaceId: workspace.id,
-            sessionId: workspace.ratchetActiveSessionId,
-            state,
-        });
-        await workspaceAccessor.update(workspace.id, { ratchetActiveSessionId: null });
-        return null;
-    }
-    async handleStateWithoutActiveFixer(workspace, state, prStateInfo, settings) {
-        switch (state) {
-            case RatchetState.IDLE:
-                return { type: 'WAITING', reason: 'No PR or ratchet not active' };
-            case RatchetState.CI_RUNNING:
-                return { type: 'WAITING', reason: 'CI is running' };
-            case RatchetState.CI_FAILED:
-                if (!settings.autoFixCi) {
-                    return { type: 'DISABLED', reason: 'CI auto-fix disabled' };
-                }
-                if (prStateInfo.ciRunId && prStateInfo.ciRunId === workspace.ratchetLastCiRunId) {
-                    logger.info('Skipping CI fixer dispatch — already handled this CI run', {
-                        workspaceId: workspace.id,
-                        ciRunId: prStateInfo.ciRunId,
-                    });
-                    return {
-                        type: 'WAITING',
-                        reason: 'Already dispatched fixer for this CI run; waiting for new run',
-                    };
-                }
-                return await this.triggerFixer(workspace, 'ci', prStateInfo, settings);
-            case RatchetState.REVIEW_PENDING:
-                if (!settings.autoFixReviews) {
-                    return { type: 'DISABLED', reason: 'Review auto-fix disabled' };
-                }
-                return await this.triggerFixer(workspace, 'review', prStateInfo, settings);
-            case RatchetState.READY:
-                if (settings.autoMerge) {
-                    logger.info('PR ready for merge (auto-merge not yet implemented)', {
-                        workspaceId: workspace.id,
-                        prNumber: workspace.prNumber,
-                    });
-                    return { type: 'READY_FOR_MERGE' };
-                }
-                return { type: 'READY_FOR_MERGE' };
-            case RatchetState.MERGED:
-                return { type: 'COMPLETED' };
-            default:
-                return { type: 'WAITING', reason: `Unknown state: ${state}` };
-        }
-    }
-    shouldNotifyActiveFixer(currentState, lastNotifiedState, currentCiRunId, lastCiRunId) {
-        if (currentState === RatchetState.CI_FAILED &&
-            currentCiRunId &&
-            currentCiRunId !== lastCiRunId) {
-            return true;
-        }
-        if (currentState === lastNotifiedState) {
-            return false;
-        }
-        return currentState === RatchetState.CI_FAILED;
-    }
-    async notifyActiveFixer(workspace, state, prStateInfo, client) {
-        if (!workspace.ratchetActiveSessionId) {
-            logger.warn('notifyActiveFixer called without active session ID', {
-                workspaceId: workspace.id,
-            });
-            return false;
-        }
-        let message = '';
-        if (state === RatchetState.CI_FAILED) {
-            message = `⚠️ **CI Failed**
-
-The CI checks have failed. This may be due to your recent changes.
-
-**Failed checks:**
-${prStateInfo.failedChecks.map((c) => `- **${c.name}**: ${c.conclusion}${c.detailsUrl ? ` ([logs](${c.detailsUrl}))` : ''}`).join('\n')}
-
-Please investigate and fix the CI failure before continuing with your current task.
-Use \`gh pr checks ${prStateInfo.prNumber}\` to see current status.
-Use \`gh run view <run-id> --log-failed\` to see detailed logs.`;
-        }
-        if (message) {
-            try {
-                await client.sendMessage(message);
-                logger.info('Notified active fixer about state change', {
-                    workspaceId: workspace.id,
-                    sessionId: workspace.ratchetActiveSessionId,
-                    state,
-                });
-                await workspaceAccessor.update(workspace.id, {
-                    ratchetLastNotifiedState: state,
-                });
-                return true;
-            }
-            catch (error) {
-                logger.warn('Failed to notify fixer about state change', {
-                    workspaceId: workspace.id,
-                    state,
-                    error,
-                });
-                return false;
-            }
-        }
-        return false;
-    }
-    async triggerFixer(workspace, fixerType, prStateInfo, settings) {
+    async triggerFixer(workspace, prStateInfo) {
         try {
             const result = await fixerSessionService.acquireAndDispatch({
                 workspaceId: workspace.id,
@@ -421,30 +574,31 @@ Use \`gh run view <run-id> --log-failed\` to see detailed logs.`;
                 sessionName: 'Ratchet',
                 runningIdleAction: 'restart',
                 dispatchMode: 'start_empty_and_send',
-                buildPrompt: () => this.buildInitialPrompt(fixerType, workspace.prUrl, prStateInfo, settings),
+                buildPrompt: () => buildRatchetDispatchPrompt(workspace.prUrl, prStateInfo.prNumber),
                 beforeStart: ({ sessionId, prompt }) => {
-                    messageStateService.injectCommittedUserMessage(sessionId, prompt);
+                    sessionStoreService.injectCommittedUserMessage(sessionId, prompt);
                 },
             });
             if (result.status === 'started') {
-                const shouldMarkNotified = result.promptSent ?? true;
+                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 (sessionService.isSessionRunning(result.sessionId)) {
+                        await sessionService.stopClaudeSession(result.sessionId);
+                    }
+                    return { type: 'ERROR', error: 'Failed to deliver initial ratchet prompt' };
+                }
                 await workspaceAccessor.update(workspace.id, {
                     ratchetActiveSessionId: result.sessionId,
-                    ...(shouldMarkNotified && {
-                        ratchetLastNotifiedState: this.determineRatchetState(prStateInfo),
-                    }),
-                });
-                logger.info('Ratchet fixer session started', {
-                    workspaceId: workspace.id,
-                    sessionId: result.sessionId,
-                    fixerType,
-                    prNumber: prStateInfo.prNumber,
                 });
                 return {
                     type: 'TRIGGERED_FIXER',
                     sessionId: result.sessionId,
-                    fixerType,
-                    promptSent: shouldMarkNotified,
+                    promptSent,
                 };
             }
             if (result.status === 'already_active') {
@@ -460,169 +614,10 @@ Use \`gh run view <run-id> --log-failed\` to see detailed logs.`;
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to trigger ratchet fixer', error, {
                 workspaceId: workspace.id,
-                fixerType,
             });
             return { type: 'ERROR', error: errorMessage };
         }
     }
-    buildInitialPrompt(fixerType, prUrl, prStateInfo, settings) {
-        const prNumber = prStateInfo.prNumber;
-        switch (fixerType) {
-            case 'ci':
-                return this.buildCIFixPrompt(prNumber, prUrl, prStateInfo);
-            case 'review':
-                return this.buildReviewFixPrompt(prNumber, prUrl, prStateInfo, settings);
-            default:
-                return `Please investigate the issue with PR #${prNumber}.`;
-        }
-    }
-    buildCIFixPrompt(prNumber, prUrl, prStateInfo) {
-        let prompt = `## CI Failure Alert
-
-The CI checks for PR #${prNumber} have failed.
-
-**PR URL:** ${prUrl}
-
-`;
-        if (prStateInfo.failedChecks.length > 0) {
-            prompt += `### Failed Checks\n\n`;
-            for (const check of prStateInfo.failedChecks) {
-                prompt += `- **${check.name}**: ${check.conclusion}`;
-                if (check.detailsUrl) {
-                    prompt += ` ([logs](${check.detailsUrl}))`;
-                }
-                prompt += `\n`;
-            }
-            prompt += `\n`;
-        }
-        prompt += `### Next Steps
-
-1. Sync with main first: \`git fetch origin && git merge origin/main\` (resolve any conflicts)
-2. Use \`gh pr checks ${prNumber}\` to see the current check status
-3. Use \`gh run view <run-id> --log-failed\` to see detailed failure logs
-4. Identify the root cause and implement a fix
-5. Run tests locally to verify: \`pnpm test\`
-6. Run type checking: \`pnpm typecheck\`
-7. Run linting: \`pnpm check:fix\`
-8. Commit and push your changes
-
-Please investigate and fix these CI failures.`;
-        return prompt;
-    }
-    filterByAllowedReviewers(items, allowedReviewers) {
-        if (allowedReviewers.length === 0) {
-            return items;
-        }
-        return items.filter((item) => allowedReviewers.includes(item.author.login));
-    }
-    formatReviewsSection(reviews) {
-        if (reviews.length === 0) {
-            return '';
-        }
-        const lines = ['### Reviews Requesting Changes\n\n'];
-        for (const review of reviews) {
-            lines.push(`**${review.author.login}** (${new Date(review.submittedAt).toLocaleDateString()}):\n`);
-            if (review.body) {
-                lines.push(`> ${review.body.split('\n').join('\n> ')}\n`);
-            }
-            lines.push('\n');
-        }
-        return lines.join('');
-    }
-    formatCodeCommentsSection(comments) {
-        if (comments.length === 0) {
-            return '';
-        }
-        const lines = ['### Review Comments on Code\n\n'];
-        for (const comment of comments) {
-            const location = comment.line ? `:${comment.line}` : '';
-            lines.push(`**${comment.author.login}** on \`${comment.path}\`${location}:\n`);
-            lines.push(`> ${comment.body.split('\n').join('\n> ')}\n`);
-            lines.push(`> [View comment](${comment.url})\n\n`);
-        }
-        return lines.join('');
-    }
-    formatPRCommentsSection(comments) {
-        if (comments.length === 0) {
-            return '';
-        }
-        const lines = ['### PR Comments\n\n'];
-        for (const comment of comments) {
-            lines.push(`**${comment.author.login}** (${new Date(comment.createdAt).toLocaleDateString()}):\n`);
-            lines.push(`> ${comment.body.split('\n').join('\n> ')}\n\n`);
-        }
-        return lines.join('');
-    }
-    buildReviewFixPrompt(prNumber, prUrl, prStateInfo, settings) {
-        const parts = [
-            `## PR Review Comments Alert
-
-New review comments have been received on PR #${prNumber}.
-
-**PR URL:** ${prUrl}
-
-`,
-        ];
-        const changesRequestedReviews = prStateInfo.reviews.filter((r) => r.state === 'CHANGES_REQUESTED');
-        const filteredReviews = this.filterByAllowedReviewers(changesRequestedReviews, settings.allowedReviewers);
-        parts.push(this.formatReviewsSection(filteredReviews));
-        parts.push(this.formatCodeCommentsSection(prStateInfo.newReviewComments));
-        parts.push(this.formatPRCommentsSection(prStateInfo.newPRComments));
-        const reviewerSet = new Set([
-            ...filteredReviews.map((r) => r.author.login),
-            ...prStateInfo.newReviewComments.map((c) => c.author.login),
-            ...prStateInfo.newPRComments.map((c) => c.author.login),
-        ]);
-        const reviewerMentions = Array.from(reviewerSet)
-            .map((r) => `@${r}`)
-            .join(' ');
-        parts.push(`### Instructions
-
-**IMPORTANT: Execute autonomously. Do not ask the user for input or confirmation. Complete all steps without waiting.**
-
-1. **Sync with main** - Before making changes, sync your branch:
-   \`\`\`bash
-   git fetch origin && git merge origin/main
-   \`\`\`
-   Resolve any conflicts as part of your fix.
-
-2. **Analyze each comment** - Determine what changes are requested. If a comment is purely informational (e.g., automated coverage reports with no action items), note it and move on.
-
-3. **Implement fixes** - Address each actionable comment systematically. Make focused changes that directly address the feedback.
-
-4. **Verify changes**:
-   \`\`\`bash
-   pnpm test && pnpm typecheck && pnpm check:fix
-   \`\`\`
-
-5. **Commit and push**:
-   \`\`\`bash
-   git add -A && git commit -m "Address review comments" && git push
-   \`\`\`
-
-6. **Post re-review request** - After pushing, notify the reviewers:
-   \`\`\`bash
-   gh pr comment ${prNumber} --body "${reviewerMentions} I've addressed the review comments. Please re-review when you have a chance."
-   \`\`\`
-
-**Do not ask the user what to do. Analyze the comments, implement fixes, push, and request re-review.**`);
-        return parts.join('');
-    }
-    extractFailedCiSignature(failedChecks) {
-        if (failedChecks.length === 0) {
-            return null;
-        }
-        const failedEntries = [];
-        for (const check of failedChecks) {
-            const runIdMatch = check.detailsUrl?.match(/\/actions\/runs\/(\d+)/);
-            const runId = runIdMatch?.[1] ?? 'no-run-id';
-            failedEntries.push(`${check.name}:${runId}`);
-        }
-        if (failedEntries.length === 0) {
-            return null;
-        }
-        return failedEntries.sort().join('|');
-    }
 }
 export const ratchetService = new RatchetService();
 //# sourceMappingURL=ratchet.service.js.map