feat: treat any PR base branch as a merge point, surface at top of Active

Extends the default-branch guard to any branch a PR is currently
targeting (develop, integration, release/*, …). After resolving PRs we
collect the union of baseBranch values; any worktree sitting on one of
those branches gets its PR assignment cleared. Self-derives — no config
or hardcoded list — and free, since every PR node already carries
baseRefName.

Renderer mirror: the no-PR / Active sidebar group now sorts merge-point
worktrees (main + any branch that's a PR base) immediately after the
main worktree, before feature worktrees, so the long-lived merge points
stay reachable at the top.

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

Author: big-guy

src/main/github.test.ts

@@ -481,6 +481,43 @@ describe('fetchPRStatusesForRepo matcher', () => {
     expect(result.get('/wt')).toBeNull()
   })
 
+  it('does not claim a PR for a worktree on a non-default merge-point branch (develop)', async () => {
+    // 'develop' isn't the default branch but PR #50 targets it as base.
+    // A worktree sitting on develop shouldn't be credited with a PR even
+    // if search-by-SHA surfaces a recently squashed candidate.
+    const developSha = 'a'.repeat(40)
+    const featureSha = 'b'.repeat(40)
+    fetchSpy.mockResolvedValueOnce(
+      mockResponse(200, {
+        data: {
+          repository: {
+            defaultBranchRef: { name: 'main' },
+            milestones: { totalCount: 0 },
+            // Worktree on develop: search returns the most-recently-squashed
+            // PR which still claims our origin via sameRepo fallback if we
+            // weren't already excluding it.
+            prBr0: { nodes: [] },
+            // Worktree on feature: legitimately ours, baseRefName=develop.
+            prBr1: { nodes: [gqlPR({ number: 50, baseRefName: 'develop', headRefOid: featureSha })] }
+          },
+          prSearch0: {
+            nodes: [gqlPR({ number: 99, state: 'MERGED', headRefOid: 'c'.repeat(40) })]
+          },
+          prSearch1: { nodes: [] }
+        }
+      })
+    )
+    const result = await fetchPRStatusesForRepo(
+      { origin: { owner: 'o', repo: 'r' }, upstream: { owner: 'o', repo: 'r' } },
+      [
+        { worktreePath: '/wt-dev', branch: 'develop', headSha: developSha },
+        { worktreePath: '/wt-feat', branch: 'feature', headSha: featureSha }
+      ]
+    )
+    expect(result.get('/wt-dev')).toBeNull()
+    expect(result.get('/wt-feat')?.number).toBe(50)
+  })
+
   it('does not claim a PR for a worktree on master when that is the default branch', async () => {
     const masterSha = 'c'.repeat(40)
     const mergedPRHeadSha = 'd'.repeat(40)

src/main/github.ts

@@ -453,7 +453,7 @@ ${PR_FRAGMENT}`
       // not the head of any PR — skip the resolution entirely to avoid
       // misattributing the latest squash-merged PR's status to it.
       if (defaultBranchName && req.branch === defaultBranchName) {
-        return { worktreePath: req.worktreePath, status: null as PRStatus | null }
+        return { worktreePath: req.worktreePath, branch: req.branch, status: null as PRStatus | null }
       }
       const brAlias = repoData[`prBr${i}`] as { nodes: GraphQLPR[] | null } | null | undefined
       const searchAlias = topData[`prSearch${i}`] as
@@ -466,7 +466,7 @@ ${PR_FRAGMENT}`
         (n): n is GraphQLPR => !!n && typeof (n as GraphQLPR).number === 'number'
       )
       const pr = resolvePRForWorktree(branchNodes, searchNodes, req.headSha, originFull)
-      if (!pr) return { worktreePath: req.worktreePath, status: null as PRStatus | null }
+      if (!pr) return { worktreePath: req.worktreePath, branch: req.branch, status: null as PRStatus | null }
       const [behindBy, firstReleaseTag] = await Promise.all([
         pr.state === 'MERGED' || pr.state === 'CLOSED'
           ? Promise.resolve(null)
@@ -476,9 +476,19 @@ ${PR_FRAGMENT}`
           : Promise.resolve(null)
       ])
       const status = buildPRStatus(pr, req.branch, behindBy, firstReleaseTag, hasMilestones)
-      return { worktreePath: req.worktreePath, status }
+      return { worktreePath: req.worktreePath, branch: req.branch, status }
     })
   )
+
+  // Any branch that some PR is targeting as base (develop / integration /
+  // release/*, etc.) is a merge point, not a PR head. Null out attributions
+  // for worktrees sitting on one of those.
+  const baseBranches = new Set<string>()
+  for (const b of built) if (b.status) baseBranches.add(b.status.baseBranch)
+  for (const b of built) {
+    if (b.status && baseBranches.has(b.branch)) b.status = null
+  }
+
   for (const b of built) result.set(b.worktreePath, b.status)
   return result
 }

src/renderer/worktree-sort.test.ts

@@ -155,4 +155,26 @@ describe('worktree-sort snoozed group', () => {
   it('getGroupKey returns snoozed when isSnoozed regardless of merged', () => {
     expect(getGroupKey(wt('/a'), mergedPR, true, true)).toBe('snoozed')
   })
+
+  it('no-pr group lists merge-point worktrees (PR bases) above feature worktrees', () => {
+    const main = stubWorktree({ path: '/main', branch: 'main', isMain: true, createdAt: 100 })
+    const develop = stubWorktree({ path: '/develop', branch: 'develop', createdAt: 50 })
+    const feature = stubWorktree({ path: '/feat', branch: 'feature/x', createdAt: 200 })
+    const featureWithPR = stubWorktree({ path: '/other', branch: 'feature/y', createdAt: 300 })
+    // Active PR targets develop — so develop counts as a base branch.
+    const groups = groupWorktrees(
+      [feature, develop, main, featureWithPR],
+      {
+        '/main': null,
+        '/develop': null,
+        '/feat': null,
+        '/other': stubPRStatus({ branch: 'feature/y', baseBranch: 'develop' })
+      },
+      {},
+      {}
+    )
+    const noPR = groups.find((g) => g.key === 'no-pr')!
+    // main pinned to top, then develop (a base branch), then features by createdAt desc.
+    expect(noPR.worktrees.map((w) => w.path)).toEqual(['/main', '/develop', '/feat'])
+  })
 })

src/renderer/worktree-sort.ts

@@ -49,6 +49,27 @@ function sortByCreatedAt(worktrees: Worktree[]): Worktree[] {
   })
 }
 
+/** Sort the no-PR / Active group: main first, then any worktree whose
+ *  branch is being targeted by an open PR (merge points like
+ *  develop/integration/release), then everything else by createdAt desc. */
+function sortNoPRGroup(worktrees: Worktree[], baseBranches: Set<string>): Worktree[] {
+  return [...worktrees].sort((a, b) => {
+    if (a.isMain !== b.isMain) return a.isMain ? -1 : 1
+    const aBase = baseBranches.has(a.branch) ? 1 : 0
+    const bBase = baseBranches.has(b.branch) ? 1 : 0
+    if (aBase !== bBase) return bBase - aBase
+    return (b.createdAt || 0) - (a.createdAt || 0)
+  })
+}
+
+function collectBaseBranches(prStatuses: Record<string, PRStatus | null>): Set<string> {
+  const out = new Set<string>()
+  for (const status of Object.values(prStatuses)) {
+    if (status?.baseBranch) out.add(status.baseBranch)
+  }
+  return out
+}
+
 /** Group worktrees by PR status, sorted by creation time within each group */
 export function groupWorktrees(
   worktrees: Worktree[],
@@ -77,12 +98,16 @@ export function groupWorktrees(
     grouped[key].push(wt)
   }
 
+  const baseBranches = collectBaseBranches(prStatuses)
   return GROUP_ORDER
     .filter((key) => grouped[key].length > 0)
     .map((key) => ({
       key,
       label: GROUP_LABELS[key],
-      worktrees: sortByCreatedAt(grouped[key])
+      worktrees:
+        key === 'no-pr'
+          ? sortNoPRGroup(grouped[key], baseBranches)
+          : sortByCreatedAt(grouped[key])
     }))
 }