fix(git): keep task PR state in sync when the primary PR changes

Promoting a different PR to primary reordered the URL list but broadcast
the old primary's cached prState alongside the new primary's URL, so a
task could show "merged" while its primary PR was actually open until the
next background poll (~60s later) overwrote the cache.

setPrimaryPrUrl now fetches the promoted PR's live state via
getPrDetailsByUrl + mapPrState, persists it through updatePrCache, and
emits the fresh state, so the cache columns and prUrls[0] can no longer
disagree and every taskPrInfoChanged consumer updates immediately.

Generated-By: PostHog Code
Task-Id: 2772f1aa-cba4-46df-a8b6-3a14a0f15299

Author: frankh

packages/host-router/src/ports/git-pr-status.ts

@@ -13,5 +13,5 @@ export interface IGitPrStatus {
     cloudPrUrl: string | null,
   ): Promise<TaskPrStatus>;
   getCachedPrUrl(taskId: string): CachedPrUrlOutput;
-  setPrimaryPrUrl(taskId: string, prUrl: string): void;
+  setPrimaryPrUrl(taskId: string, prUrl: string): Promise<void>;
 }

packages/workspace-server/src/services/git/task-pr-status.test.ts

@@ -215,30 +215,66 @@ describe("TaskPrStatusService revalidation PR detection", () => {
 });
 
 describe("TaskPrStatusService.setPrimaryPrUrl", () => {
-  it("emits the promoted url as prUrl even though the row column is stale", () => {
-    const PR_OLD = "https://github.com/acme/repo/pull/1";
-    const PR_NEW = "https://github.com/acme/repo/pull/2";
-    const gitService = {} as unknown as GitService;
+  const PR_OLD = "https://github.com/acme/repo/pull/1";
+  const PR_NEW = "https://github.com/acme/repo/pull/2";
+
+  function makeService(getPrDetailsByUrl: ReturnType<typeof vi.fn>) {
+    const gitService = { getPrDetailsByUrl } as unknown as GitService;
     const workspaceService = { emit: vi.fn() };
     const workspaceRepo = {
       promotePrUrl: vi.fn(),
-      findByTaskId: vi.fn().mockReturnValue({ prUrl: PR_OLD, prState: "open" }),
+      updatePrCache: vi.fn(),
       getPrUrls: vi.fn().mockReturnValue([PR_NEW, PR_OLD]),
     };
     const service = new TaskPrStatusService(
       gitService,
       workspaceRepo as unknown as IWorkspaceRepository,
       workspaceService as unknown as WorkspaceService,
     );
+    return { service, workspaceService, workspaceRepo };
+  }
+
+  it("recomputes and emits the promoted PR's live state, not the stale cache", async () => {
+    const getPrDetailsByUrl = vi
+      .fn()
+      .mockResolvedValue({ state: "open", merged: false, draft: false });
+    const { service, workspaceService, workspaceRepo } =
+      makeService(getPrDetailsByUrl);
 
-    service.setPrimaryPrUrl("task-1", PR_NEW);
+    await service.setPrimaryPrUrl("task-1", PR_NEW);
 
     expect(workspaceRepo.promotePrUrl).toHaveBeenCalledWith("task-1", PR_NEW);
+    expect(getPrDetailsByUrl).toHaveBeenCalledWith(PR_NEW);
+    expect(workspaceRepo.updatePrCache).toHaveBeenCalledWith("task-1", {
+      prUrl: PR_NEW,
+      prState: "open",
+      accumulate: false,
+    });
     expect(workspaceService.emit).toHaveBeenCalledWith("taskPrInfoChanged", {
       taskId: "task-1",
       prUrl: PR_NEW,
       prUrls: [PR_NEW, PR_OLD],
       prState: "open",
     });
   });
+
+  it("emits a null state when the promoted PR's details are unavailable", async () => {
+    const getPrDetailsByUrl = vi.fn().mockResolvedValue(null);
+    const { service, workspaceService, workspaceRepo } =
+      makeService(getPrDetailsByUrl);
+
+    await service.setPrimaryPrUrl("task-1", PR_NEW);
+
+    expect(workspaceRepo.updatePrCache).toHaveBeenCalledWith("task-1", {
+      prUrl: PR_NEW,
+      prState: null,
+      accumulate: false,
+    });
+    expect(workspaceService.emit).toHaveBeenCalledWith("taskPrInfoChanged", {
+      taskId: "task-1",
+      prUrl: PR_NEW,
+      prUrls: [PR_NEW, PR_OLD],
+      prState: null,
+    });
+  });
 });

packages/workspace-server/src/services/git/task-pr-status.ts

@@ -48,14 +48,22 @@ export class TaskPrStatusService {
     };
   }
 
-  setPrimaryPrUrl(taskId: string, prUrl: string): void {
+  async setPrimaryPrUrl(taskId: string, prUrl: string): Promise<void> {
     this.workspaceRepo.promotePrUrl(taskId, prUrl);
-    const row = this.workspaceRepo.findByTaskId(taskId);
+    const details = await this.gitService.getPrDetailsByUrl(prUrl);
+    const prState: SidebarPrState = details
+      ? mapPrState(details.state, details.merged, details.draft)
+      : null;
+    this.workspaceRepo.updatePrCache(taskId, {
+      prUrl,
+      prState,
+      accumulate: false,
+    });
     this.workspaceService.emit("taskPrInfoChanged", {
       taskId,
       prUrl,
       prUrls: this.workspaceRepo.getPrUrls(taskId),
-      prState: row?.prState ?? null,
+      prState,
     });
   }