fix(webhooks): heal pr_state from closed to open on synchronize after missed reopen (#4424)

The pr_state monotonic guard treated 'closed' as sticky except for the exact 'reopened' action. If a reopened webhook was missed or deduplicated, subsequent events like synchronize (new commits pushed) never flipped pr_state back to open, leaving the UI stuck showing 'closed' for an actually-open PR.

Synchronize deliveries carrying a new head sha (evidence of an actual new push, which can only happen on a genuinely open PR) now heal pr_state from closed back to open/draft. A synchronize redelivery with an unchanged head sha is still treated as a stale/duplicate event and does not heal the state, preserving existing out-of-order-delivery protections.

Co-authored-by: eshurakov <54751+eshurakov@users.noreply.github.com>
Co-authored-by: kiloconnect[bot] <240665456+kiloconnect[bot]@users.noreply.github.com>

Author: eshurakov

apps/web/src/lib/integrations/platforms/github/webhook-handlers/upsert-cli-session-pull-requests.test.ts

@@ -644,6 +644,76 @@ describe('upsertCliSessionPullRequestsFromWebhook', () => {
     expect(rows[0].pr_head_sha).toBe('sha-203-reopen');
   });
 
+  it('heals pr_state from closed -> open on synchronize when the reopened webhook was missed', async () => {
+    const branch = 'feature/missed-reopen-then-sync';
+    await seedSession({ branch, owner: testOwner });
+
+    // PR gets closed.
+    await upsertCliSessionPullRequestsFromWebhook(
+      makePayload({
+        action: 'closed',
+        prNumber: 210,
+        state: 'closed',
+        merged: false,
+        headRef: branch,
+        headSha: 'sha-210',
+      }),
+      testOwner
+    );
+
+    // The `reopened` webhook for this PR is never delivered (missed/deduped),
+    // but new commits are pushed to the now-actually-open PR, so GitHub
+    // delivers a `synchronize` event carrying a new head sha and the PR's
+    // real current state (open).
+    await upsertCliSessionPullRequestsFromWebhook(
+      makePayload({
+        action: 'synchronize',
+        prNumber: 210,
+        state: 'open',
+        headRef: branch,
+        headSha: 'sha-210-new-commit',
+      }),
+      testOwner
+    );
+
+    const rows = await readUserRow({ userId: testUserId, branch });
+    expect(rows[0].pr_state).toBe('open');
+    expect(rows[0].pr_head_sha).toBe('sha-210-new-commit');
+  });
+
+  it('does not heal pr_state from closed -> open on a stale synchronize redelivery with the same head sha', async () => {
+    const branch = 'feature/stale-sync-same-sha';
+    await seedSession({ branch, owner: testOwner });
+
+    await upsertCliSessionPullRequestsFromWebhook(
+      makePayload({
+        action: 'closed',
+        prNumber: 211,
+        state: 'closed',
+        merged: false,
+        headRef: branch,
+        headSha: 'sha-211',
+      }),
+      testOwner
+    );
+
+    // A redelivered/duplicate `synchronize` event for the same commit is not
+    // evidence of a new push, so pr_state stays closed.
+    await upsertCliSessionPullRequestsFromWebhook(
+      makePayload({
+        action: 'synchronize',
+        prNumber: 211,
+        state: 'open',
+        headRef: branch,
+        headSha: 'sha-211',
+      }),
+      testOwner
+    );
+
+    const rows = await readUserRow({ userId: testUserId, branch });
+    expect(rows[0].pr_state).toBe('closed');
+  });
+
   it('does not regress pr_state from merged -> closed on stale closed-unmerged redelivery', async () => {
     const branch = 'feature/monotonic-merged-closed';
     await seedSession({ branch, owner: testOwner });

apps/web/src/lib/integrations/platforms/github/webhook-handlers/upsert-cli-session-pull-requests.ts

@@ -145,6 +145,19 @@ export async function upsertCliSessionPullRequestsFromWebhook(
     const state = derivePrState(pull_request, action);
 
     // Defense-in-depth against out-of-order webhook deliveries.
+    //
+    // `closed` must not be permanently sticky: if the `reopened` webhook that
+    // should have flipped it back to open is missed or deduplicated, a later
+    // `synchronize` delivery carrying a new head sha (i.e. new commits were
+    // actually pushed, which can only happen on a PR that is really open) is
+    // used to self-heal pr_state instead of trusting only the `reopened`
+    // action name. A `synchronize` redelivery with the *same* head sha is
+    // treated as a stale/duplicate event and does not heal the state.
+    const closedStaysStickyUnlessNewCommit =
+      action === GITHUB_ACTION.SYNCHRONIZE
+        ? sql`AND ${github_branch_pull_requests.pr_head_sha} = excluded.pr_head_sha`
+        : sql``;
+
     const prStateSet =
       action === GITHUB_ACTION.REOPENED
         ? sql`excluded.pr_state`
@@ -156,6 +169,7 @@ export async function upsertCliSessionPullRequestsFromWebhook(
             WHEN ${github_branch_pull_requests.pr_number} = excluded.pr_number
               AND ${github_branch_pull_requests.pr_state} = 'closed'
               AND excluded.pr_state IN ('open', 'draft')
+              ${closedStaysStickyUnlessNewCommit}
             THEN ${github_branch_pull_requests.pr_state}
             ELSE excluded.pr_state
           END`;