fix: address PR review findings for XState PR review refactor

- handleComplete uses getOrCreateActor so late-arriving results after
  auth change or restart are processed instead of silently dropped
- GITHUB_AUTH_CHANGED handler now kills running review subprocesses and
  aborts CI wait controllers before clearing XState actors
- Duplicate review detection reads actual progress from actor snapshot
  instead of hardcoding progress=50
- handleClearReview stops actor directly without sending CLEAR_REVIEW
  event, preventing double IPC emission to renderer

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: AndyMik90

apps/frontend/src/main/__tests__/pr-review-state-manager.test.ts

@@ -124,6 +124,15 @@ describe('PRReviewStateManager', () => {
       expect(snapshot!.context.result).toEqual(result);
     });
 
+    it('should create actor for handleComplete on unknown PR (late-arriving result)', () => {
+      const result = createMockResult();
+      // No handleStartReview called — handleComplete should create the actor
+      manager.handleComplete(projectId, prNumber, result);
+      const snapshot = manager.getState(projectId, prNumber);
+      expect(snapshot).not.toBeNull();
+      expect(snapshot!.context.result).toEqual(result);
+    });
+
     it('should send DETECT_EXTERNAL_REVIEW when overallStatus is in_progress', () => {
       manager.handleStartReview(projectId, prNumber);
       const result = createMockResult({ overallStatus: 'in_progress' });
@@ -239,6 +248,19 @@ describe('PRReviewStateManager', () => {
       expect(manager.getState(projectId, prNumber)).toBeNull();
     });
 
+    it('should emit exactly one cleared state IPC on handleClearReview (no double emission)', () => {
+      manager.handleStartReview(projectId, prNumber);
+      mockSafeSendToRenderer.mockClear();
+
+      manager.handleClearReview(projectId, prNumber);
+
+      // Should emit exactly 1 cleared state, not 2 (no double emission from
+      // sending CLEAR_REVIEW to actor subscription + manual emitClearedState)
+      expect(mockSafeSendToRenderer).toHaveBeenCalledTimes(1);
+      const payload = mockSafeSendToRenderer.mock.calls[0][3] as Record<string, unknown>;
+      expect(payload).toEqual(expect.objectContaining({ state: 'idle' }));
+    });
+
     it('should stop ALL actors and clear maps on handleAuthChange', () => {
       manager.handleStartReview(projectId, 1);
       manager.handleStartReview(projectId, 2);

apps/frontend/src/main/ipc-handlers/github/pr-handlers.ts

@@ -1664,6 +1664,24 @@ export function registerPRHandlers(getMainWindow: () => BrowserWindow | null): v
 
   // Clear all PR review actors when GitHub auth changes (account swap)
   ipcMain.on(IPC_CHANNELS.GITHUB_AUTH_CHANGED, () => {
+    // Cancel all running review subprocesses and CI wait controllers
+    for (const [reviewKey, entry] of runningReviews) {
+      if (entry === CI_WAIT_PLACEHOLDER) {
+        const abortController = ciWaitAbortControllers.get(reviewKey);
+        if (abortController) {
+          abortController.abort();
+          ciWaitAbortControllers.delete(reviewKey);
+        }
+      } else {
+        try {
+          entry.kill("SIGTERM");
+        } catch {
+          // Process may have already exited
+        }
+      }
+    }
+    runningReviews.clear();
+    ciWaitAbortControllers.clear();
     prReviewStateManager.handleAuthChange();
   });
 
@@ -1881,10 +1899,12 @@ export function registerPRHandlers(getMainWindow: () => BrowserWindow | null): v
         // Check if already running — notify renderer so it can display ongoing logs
         if (runningReviews.has(reviewKey)) {
           debugLog("Review already running, notifying renderer", { reviewKey });
+          const currentSnapshot = prReviewStateManager.getState(projectId, prNumber);
+          const currentProgress = currentSnapshot?.context?.progress?.progress ?? 50;
           sendProgress({
             phase: "analyzing",
             prNumber,
-            progress: 50,
+            progress: currentProgress,
             message: "Review is already in progress. Reconnecting to ongoing review...",
           });
           return;
@@ -2904,10 +2924,12 @@ export function registerPRHandlers(getMainWindow: () => BrowserWindow | null): v
           // Check if already running — notify renderer so it can display ongoing logs
           if (runningReviews.has(reviewKey)) {
             debugLog("Follow-up review already running, notifying renderer", { reviewKey });
+            const currentSnapshot = prReviewStateManager.getState(projectId, prNumber);
+            const currentProgress = currentSnapshot?.context?.progress?.progress ?? 50;
             sendProgress({
               phase: "analyzing",
               prNumber,
-              progress: 50,
+              progress: currentProgress,
               message: "Follow-up review is already in progress. Reconnecting to ongoing review...",
             });
             return;

apps/frontend/src/main/pr-review-state-manager.ts

@@ -53,8 +53,16 @@ export class PRReviewStateManager {
   }
 
   handleComplete(projectId: string, prNumber: number, result: PRReviewResult): void {
-    const actor = this.getActor(projectId, prNumber);
-    if (!actor) return;
+    // Use getOrCreateActor so late-arriving results (e.g. after auth change or
+    // app restart) still get processed instead of silently dropped.
+    const actor = this.getOrCreateActor(projectId, prNumber);
+
+    // If the actor is in idle state (freshly created for a late-arriving result),
+    // transition to reviewing first so REVIEW_COMPLETE is accepted.
+    const snapshot = actor.getSnapshot();
+    if (String(snapshot.value) === 'idle') {
+      actor.send({ type: 'START_REVIEW', prNumber, projectId } satisfies PRReviewEvent);
+    }
 
     // Detect external review (result arrives with 'in_progress' status from outside)
     if (result.overallStatus === 'in_progress') {
@@ -80,9 +88,10 @@ export class PRReviewStateManager {
     const key = this.getKey(projectId, prNumber);
     const actor = this.actors.get(key);
     if (actor) {
-      // Capture snapshot before clearing so the emitted payload has real context
+      // Capture snapshot before stopping so the emitted payload has real context.
+      // Don't send CLEAR_REVIEW to the actor — that would trigger the subscription
+      // and cause a duplicate IPC emission alongside emitClearedState below.
       const snapshot = actor.getSnapshot();
-      actor.send({ type: 'CLEAR_REVIEW' } satisfies PRReviewEvent);
       actor.stop();
       this.actors.delete(key);
       this.emitClearedState(key, snapshot?.context ?? null);