@vantran-se/openchamber-web 2.1.1 → 2.2.0

package/server/lib/github/pr-status.test.js

@@ -1,6 +1,10 @@
 import { afterEach, beforeEach, describe, expect, mock, test, vi } from 'bun:test';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 
-import { findBranchPrCandidates, invalidateRepoPullsCache, isHistoricalPrOfCheckout } from './pr-status.js';
+import { findBranchPrCandidates, invalidateRepoPullsCache, isHistoricalPrOfCheckout, resolveGitHubPrStatus } from './pr-status.js';
 import { createOctokit, getOctokitCacheIdentity } from './octokit.js';
 
 const listMock = mock(async () => ({ data: [] }));
@@ -274,6 +278,110 @@ describe('findBranchPrCandidates', () => {
     expect(listMock.mock.calls.some((entry) => entry[0]?.state === 'all')).toBe(true);
     expect(listMock.mock.calls.length).toBeGreaterThan(callsAfterFirst + 1);
   });
+
+  test('does not reuse a cached history miss for a different source owner', async () => {
+    const target = { repo: { owner: 'upstream-cache-scope', repo: 'app' }, remoteName: 'origin' };
+    const ownerA = { repo: { owner: 'fork-cache-a', repo: 'app' } };
+    const ownerB = { repo: { owner: 'fork-cache-b', repo: 'app' } };
+    const ownerBPr = {
+      ...mergedPr,
+      number: 16,
+      head: { ...mergedPr.head, label: 'fork-cache-b:feature', user: { login: 'fork-cache-b' }, repo: { owner: { login: 'fork-cache-b' }, name: 'app' } },
+    };
+    listMock.mockImplementation(async ({ head }) => (
+      head === 'fork-cache-b:feature' ? { data: [ownerBPr] } : { data: [] }
+    ));
+    const octokit = octokitFor('test-token', 'test-account');
+
+    await findBranchPrCandidates({
+      octokit,
+      target,
+      branch: 'feature',
+      sourceCandidates: [ownerA],
+      force: true,
+      includeHistory: true,
+    });
+    const { historical } = await findBranchPrCandidates({
+      octokit,
+      target,
+      branch: 'feature',
+      sourceCandidates: [ownerB],
+      includeHistory: true,
+    });
+
+    expect(historical?.number).toBe(16);
+  });
+});
+
+describe('resolveGitHubPrStatus for a contributor fork checkout', () => {
+  let directory;
+
+  beforeEach(async () => {
+    directory = await fs.mkdtemp(path.join(os.tmpdir(), 'pr-status-fork-'));
+    const git = (...args) => execFileSync('git', args, { cwd: directory, stdio: 'ignore' });
+    git('init', '-q', '-b', 'fix/thing');
+    git('remote', 'add', 'origin', 'https://github.com/acme/app.git');
+    git('remote', 'add', 'pr-contrib', 'https://github.com/contrib/app.git');
+    invalidateRepoPullsCache('acme', 'app');
+  });
+
+  afterEach(async () => {
+    await fs.rm(directory, { recursive: true, force: true });
+  });
+
+  const forkPr = {
+    number: 44,
+    state: 'open',
+    head: { ref: 'fix/thing', label: 'contrib:fix/thing', user: { login: 'contrib' }, repo: { owner: { login: 'contrib' }, name: 'app' } },
+  };
+  const octokit = () => ({
+    openChamberCacheIdentity: getOctokitCacheIdentity(createOctokit('fork-token', 'fork-account')),
+    rest: {
+      repos: {
+        get: async ({ owner, repo }) => ({
+          data: owner === 'contrib'
+            ? { default_branch: 'main', parent: { owner: { login: 'acme' }, name: repo } }
+            : { default_branch: 'main' },
+        }),
+      },
+      pulls: { list: async ({ owner }) => ({ data: owner === 'acme' ? [forkPr] : [] }) },
+    },
+  });
+
+  test('finds the fork PR when the caller names the fork remote as the branch source', async () => {
+    const status = await resolveGitHubPrStatus({
+      octokit: octokit(), directory, branch: 'fix/thing', remoteName: 'origin', sourceRemoteName: 'pr-contrib', force: true,
+    });
+    expect(status.pr?.number).toBe(44);
+    expect(status.repo).toMatchObject({ owner: 'acme', repo: 'app' });
+  });
+
+  test('finds the merged fork PR in the primary remote once it is merged', async () => {
+    git(directory, '-c', 'user.name=Test User', '-c', 'user.email=test@example.com', 'commit', '-q', '--allow-empty', '-m', 'fix');
+    const mergedForkPr = {
+      ...forkPr,
+      state: 'closed',
+      merged_at: '2026-01-01T00:00:00Z',
+      head: { ...forkPr.head, sha: git(directory, 'rev-parse', 'HEAD').trim() },
+    };
+    const client = octokit();
+    client.rest.pulls.list = async ({ owner, state, head }) => ({
+      data: owner === 'acme' && state === 'all' && head === 'contrib:fix/thing' ? [mergedForkPr] : [],
+    });
+
+    const status = await resolveGitHubPrStatus({
+      octokit: client, directory, branch: 'fix/thing', remoteName: 'origin', sourceRemoteName: 'pr-contrib', force: true,
+    });
+    expect(status.pr?.number).toBe(44);
+    expect(status.repo).toMatchObject({ owner: 'acme', repo: 'app' });
+  });
+
+  test('without a source remote a same-named fork branch is not this branch', async () => {
+    const status = await resolveGitHubPrStatus({
+      octokit: octokit(), directory, branch: 'fix/thing', remoteName: 'origin', force: true,
+    });
+    expect(status.pr).toBeNull();
+  });
 });
 
 describe('isHistoricalPrOfCheckout', () => {
@@ -283,15 +391,30 @@ describe('isHistoricalPrOfCheckout', () => {
 
   test('a merged PR whose head commit is in the checkout history belongs to it', async () => {
     isAncestorMock.mockImplementation(async () => true);
+    const isPatchEquivalent = mock(async () => false);
     const pr = { ...mergedPr, head: { ...mergedPr.head, sha: 'abc1234' } };
-    expect(await isHistoricalPrOfCheckout('/repo', pr, { isAncestor: isAncestorMock })).toBe(true);
+    expect(await isHistoricalPrOfCheckout('/repo', pr, { isAncestor: isAncestorMock, isPatchEquivalent })).toBe(true);
     expect(isAncestorMock).toHaveBeenCalledWith('/repo', 'abc1234');
+    expect(isPatchEquivalent).not.toHaveBeenCalled();
+  });
+
+  test('a PR with a patch-equivalent head commit belongs to the checkout', async () => {
+    isAncestorMock.mockImplementation(async () => false);
+    const isPatchEquivalent = mock(async () => true);
+    const pr = { ...mergedPr, head: { ...mergedPr.head, sha: 'abc1234' } };
+
+    const belongsToCheckout = await isHistoricalPrOfCheckout('/repo', pr, { isAncestor: isAncestorMock, isPatchEquivalent });
+
+    expect(isPatchEquivalent).toHaveBeenCalledWith('/repo', 'abc1234');
+    expect(belongsToCheckout).toBe(true);
   });
 
   test('a reused branch name without the merged commits does not inherit the PR', async () => {
     isAncestorMock.mockImplementation(async () => false);
+    const isPatchEquivalent = mock(async () => false);
     const pr = { ...mergedPr, head: { ...mergedPr.head, sha: 'abc1234' } };
-    expect(await isHistoricalPrOfCheckout('/repo', pr, { isAncestor: isAncestorMock })).toBe(false);
+    expect(await isHistoricalPrOfCheckout('/repo', pr, { isAncestor: isAncestorMock, isPatchEquivalent })).toBe(false);
+    expect(isPatchEquivalent).toHaveBeenCalledWith('/repo', 'abc1234');
   });
 
   test('a PR without a head sha is never attributed', async () => {
@@ -299,3 +422,148 @@ describe('isHistoricalPrOfCheckout', () => {
     expect(isAncestorMock).not.toHaveBeenCalled();
   });
 });
+
+const git = (directory, ...args) => execFileSync('git', ['-C', directory, ...args], {
+  encoding: 'utf8',
+});
+
+const createRebasedCheckout = async (suffix, branch = 'feature') => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), `oc-pr-history-${suffix}-`));
+  git(directory, 'init', `--initial-branch=${branch}`);
+  git(directory, 'config', 'user.name', 'Test User');
+  git(directory, 'config', 'user.email', 'test@example.com');
+  await fs.writeFile(path.join(directory, 'status.txt'), 'base\n');
+  git(directory, 'add', 'status.txt');
+  git(directory, 'commit', '-m', 'base');
+  await fs.writeFile(path.join(directory, 'status.txt'), 'rebased change\n');
+  git(directory, 'commit', '-am', 'original change');
+  const originalSha = git(directory, 'rev-parse', 'HEAD').trim();
+  git(directory, 'reset', '--hard', 'HEAD~1');
+  await fs.writeFile(path.join(directory, 'status.txt'), 'rebased change\n');
+  git(directory, 'commit', '-am', 'rebased change');
+  const baseSha = git(directory, 'rev-parse', 'HEAD~1').trim();
+  git(directory, 'remote', 'add', 'origin', `https://github.com/fork-${suffix}/app-${suffix}.git`);
+  git(directory, 'remote', 'add', 'upstream', `https://github.com/upstream-${suffix}/app-${suffix}.git`);
+  git(directory, 'remote', 'add', 'contributor', `https://github.com/contributor-${suffix}/app-${suffix}.git`);
+  return { directory, originalSha, baseSha };
+};
+
+const createForkNetworkOctokit = ({ suffix, historicalPr, forkHistoricalPr = null, openParentPr = null, branch = 'feature' }) => {
+  const calls = [];
+  const fork = { owner: `fork-${suffix}`, repo: `app-${suffix}` };
+  const parent = { owner: `upstream-${suffix}`, repo: `app-${suffix}` };
+  const contributor = { owner: `contributor-${suffix}`, repo: `app-${suffix}` };
+  const octokit = {
+    openChamberCacheIdentity: getOctokitCacheIdentity(createOctokit(`token-${suffix}`, `account-${suffix}`)),
+    rest: {
+      repos: {
+        get: async ({ owner, repo }) => {
+          if (owner === fork.owner && repo === fork.repo) {
+            return { data: { default_branch: 'main', parent: { owner: { login: parent.owner }, name: parent.repo } } };
+          }
+          return { data: { default_branch: 'main' } };
+        },
+      },
+      pulls: {
+        list: async (options) => {
+          calls.push(options);
+          if (!options.head && options.owner === parent.owner && openParentPr) {
+            return { data: [openParentPr] };
+          }
+          if (options.owner === fork.owner && options.state === 'all' && options.head === `${fork.owner}:${branch}` && forkHistoricalPr) {
+            return { data: [forkHistoricalPr] };
+          }
+          if (options.owner === parent.owner && options.state === 'all' && options.head === `${fork.owner}:${branch}`) {
+            return { data: [historicalPr] };
+          }
+          return { data: [] };
+        },
+      },
+    },
+  };
+  return { octokit, calls, fork, parent, contributor };
+};
+
+describe('resolveGitHubPrStatus fork history', () => {
+  test.each([
+    ['closed', null],
+    ['merged', '2026-01-01T00:00:00Z'],
+  ])('restores a patch-equivalent %s PR from the primary fork parent', async (state, mergedAt) => {
+    const suffix = `terminal-${state}`;
+    const { directory, originalSha } = await createRebasedCheckout(suffix);
+    const historicalPr = {
+      number: state === 'closed' ? 301 : 302,
+      state: 'closed',
+      merged_at: mergedAt,
+      head: {
+        sha: originalSha,
+        ref: 'feature',
+        label: `fork-${suffix}:feature`,
+        user: { login: `fork-${suffix}` },
+        repo: { owner: { login: `fork-${suffix}` }, name: `app-${suffix}` },
+      },
+    };
+    const { octokit, calls, fork, parent, contributor } = createForkNetworkOctokit({ suffix, historicalPr });
+
+    try {
+      const resolved = await resolveGitHubPrStatus({ octokit, directory, branch: 'feature', remoteName: 'origin', force: true });
+
+      expect(resolved.pr?.number).toBe(historicalPr.number);
+      expect(resolved.repo).toMatchObject(parent);
+      const historyCalls = calls.filter((call) => call.state === 'all');
+      expect(historyCalls).toEqual([
+        expect.objectContaining({ owner: fork.owner, head: `${fork.owner}:feature` }),
+        expect.objectContaining({ owner: fork.owner, head: `${parent.owner}:feature` }),
+        expect.objectContaining({ owner: parent.owner, head: `${fork.owner}:feature` }),
+        expect.objectContaining({ owner: parent.owner, head: `${parent.owner}:feature` }),
+      ]);
+      expect(historyCalls.some((call) => call.owner === contributor.owner)).toBe(false);
+
+      const callsAfterFirst = calls.length;
+      const repeated = await resolveGitHubPrStatus({ octokit, directory, branch: 'feature', remoteName: 'origin' });
+      expect(repeated.pr?.number).toBe(historicalPr.number);
+      expect(calls).toHaveLength(callsAfterFirst);
+    } finally {
+      await fs.rm(directory, { recursive: true, force: true });
+    }
+  });
+
+  test('returns an open parent PR before an earlier terminal fork PR', async () => {
+    const suffix = 'open-priority';
+    const { directory, originalSha } = await createRebasedCheckout(suffix);
+    const terminalPr = {
+      number: 303,
+      state: 'closed',
+      head: { sha: originalSha, ref: 'feature', label: `fork-${suffix}:feature`, user: { login: `fork-${suffix}` }, repo: { owner: { login: `fork-${suffix}` }, name: `app-${suffix}` } },
+    };
+    const openParentPr = { ...terminalPr, number: 304, state: 'open', merged_at: null };
+    const { octokit } = createForkNetworkOctokit({ suffix, historicalPr: terminalPr, forkHistoricalPr: terminalPr, openParentPr });
+
+    try {
+      const resolved = await resolveGitHubPrStatus({ octokit, directory, branch: 'feature', remoteName: 'origin', force: true });
+      expect(resolved.pr?.number).toBe(openParentPr.number);
+    } finally {
+      await fs.rm(directory, { recursive: true, force: true });
+    }
+  });
+
+  test('does not inherit terminal fork history on the default branch', async () => {
+    const suffix = 'default-main-history';
+    const { directory, baseSha } = await createRebasedCheckout(suffix, 'main');
+    const terminalPr = {
+      number: 305,
+      state: 'closed',
+      merged_at: '2026-01-01T00:00:00Z',
+      head: { sha: baseSha, ref: 'main', label: `fork-${suffix}:main`, user: { login: `fork-${suffix}` }, repo: { owner: { login: `fork-${suffix}` }, name: `app-${suffix}` } },
+    };
+    const { octokit, calls } = createForkNetworkOctokit({ suffix, historicalPr: terminalPr, branch: 'main' });
+
+    try {
+      const resolved = await resolveGitHubPrStatus({ octokit, directory, branch: 'main', remoteName: 'origin', force: true });
+      expect(resolved.pr).toBeNull();
+      expect(calls.some((call) => call.state === 'all')).toBe(false);
+    } finally {
+      await fs.rm(directory, { recursive: true, force: true });
+    }
+  });
+});

package/server/lib/github/reference-search.js

@@ -22,14 +22,21 @@
 
 import { z } from 'zod';
 
-import { isGraphqlRateLimitError, parseSummaryRefs } from './pr-summaries.js';
+import { checkContextSchema, isGraphqlRateLimitError, parseSummaryRefs, summarizeCheckContexts } from './pr-summaries.js';
 
 const REFERENCE_PAGE_SIZE = 30;
 // The preview shows the description; the attach path reads the full one.
 const BODY_PREVIEW_MAX = 20_000;
 // Keys match the filter schema below.
-const SEARCH_FILTERS = {
-  open: '',
+// The list's state and whose items it shows combine, one qualifier each.
+const SEARCH_STATES = {
+  open: 'is:open',
+  closed: 'is:closed',
+  merged: 'is:merged',
+  all: '',
+};
+const SEARCH_PEOPLE = {
+  any: '',
   assigned: 'assignee:@me',
   created: 'author:@me',
   reviewRequested: 'review-requested:@me',
@@ -67,6 +74,8 @@ fragment PullReference on PullRequest {
 
 // The newest comments and reviews; `totalCount` says how many there are.
 const DETAIL_COMMENT_LIMIT = 50;
+// The newest commits, so the preview can show what each review answered.
+const DETAIL_COMMIT_LIMIT = 50;
 
 const DETAIL_QUERY = `
 query ReferenceDetail($owner: String!, $repo: String!, $number: Int!) {
@@ -79,11 +88,33 @@ query ReferenceDetail($owner: String!, $repo: String!, $number: Int!) {
       }
       ... on PullRequest {
         number
+        state
         reviewDecision
+        # The preview's checks, from the PR itself rather than the list's batch.
+        headCommit: commits(last: 1) {
+          nodes {
+            commit {
+              statusCheckRollup {
+                contexts(first: 100) {
+                  nodes {
+                    __typename
+                    ... on CheckRun { databaseId name status conclusion startedAt checkSuite { app { databaseId } } }
+                    ... on StatusContext { context state }
+                  }
+                }
+              }
+            }
+          }
+        }
+        reviewRequests(first: 30) { nodes { requestedReviewer { __typename ... on User { login avatarUrl } } } }
         additions
         deletions
         changedFiles
         comments(last: ${DETAIL_COMMENT_LIMIT}) { totalCount nodes { ...DetailComment } }
+        commits(last: ${DETAIL_COMMIT_LIMIT}) {
+          totalCount
+          nodes { commit { oid messageHeadline committedDate url author { name user { login avatarUrl } } } }
+        }
         reviews(last: 30) {
           nodes {
             author { login avatarUrl }
@@ -175,11 +206,40 @@ const detailSchema = z.object({
       z.object({
         __typename: z.literal('PullRequest'),
         number: z.number().int(),
+        state: z.enum(['OPEN', 'CLOSED', 'MERGED']),
         reviewDecision: z.enum(['APPROVED', 'CHANGES_REQUESTED', 'REVIEW_REQUIRED']).nullable(),
+        headCommit: z.object({
+          nodes: z.array(z.object({
+            commit: z.object({
+              statusCheckRollup: z.object({ contexts: z.object({ nodes: z.array(checkContextSchema) }) }).nullable(),
+            }),
+          })),
+        }),
+        reviewRequests: z.object({
+          nodes: z.array(z.object({
+            requestedReviewer: z.object({
+              __typename: z.string(),
+              login: z.string().optional(),
+              avatarUrl: z.string().nullable().optional(),
+            }).nullable(),
+          })),
+        }),
         additions: z.number().int(),
         deletions: z.number().int(),
         changedFiles: z.number().int(),
         comments: z.object({ totalCount: z.number().int(), nodes: z.array(detailCommentSchema) }),
+        commits: z.object({
+          totalCount: z.number().int(),
+          nodes: z.array(z.object({
+            commit: z.object({
+              oid: z.string(),
+              messageHeadline: z.string(),
+              committedDate: z.string().nullable(),
+              url: z.string().nullable(),
+              author: z.object({ name: z.string().nullable(), user: userSchema }).nullable(),
+            }),
+          })),
+        }),
         reviews: z.object({
           nodes: z.array(z.object({
             author: userSchema,
@@ -322,9 +382,29 @@ export async function fetchReferenceDetail({ octokit, owner, repo, number }) {
     commentTotal: item.comments.totalCount,
     pull: {
       reviewDecision: item.reviewDecision ? REVIEW_DECISIONS[item.reviewDecision] : null,
+      // People asked to review and not done yet; a team request is left out
+      // since the board only picks people.
+      reviewers: item.reviewRequests.nodes.flatMap(({ requestedReviewer: reviewer }) => (
+        reviewer?.__typename === 'User' && reviewer.login
+          ? [{ id: reviewer.login, ...toAuthor({ login: reviewer.login, avatarUrl: reviewer.avatarUrl }) }]
+          : []
+      )),
+      // Like the list's statuses: a closed or merged PR's checks are not actionable.
+      checks: item.state === 'OPEN'
+        ? summarizeCheckContexts(item.headCommit.nodes[0]?.commit.statusCheckRollup?.contexts.nodes ?? [])
+        : null,
       additions: item.additions,
       deletions: item.deletions,
       changedFiles: item.changedFiles,
+      commits: item.commits.nodes.map(({ commit }) => ({
+        sha: commit.oid,
+        headline: commit.messageHeadline,
+        author: toAuthor(commit.author?.user ?? null),
+        authorName: commit.author?.name ?? null,
+        committedAt: commit.committedDate,
+        url: commit.url,
+      })),
+      commitTotal: item.commits.totalCount,
     },
   };
 }
@@ -348,12 +428,18 @@ export function readPullStatusRefs(value) {
   return parseSummaryRefs(refs);
 }
 
-const filterSchema = z.enum(['open', 'assigned', 'created', 'reviewRequested']).catch('open');
+const stateSchema = z.enum(['open', 'closed', 'merged', 'all']).catch('open');
+const peopleSchema = z.enum(['any', 'assigned', 'created', 'reviewRequested']).catch('any');
 const kindSchema = z.enum(['issue', 'pull']).nullable().catch(null);
 
-/** The picker's filter values; anything else reads as `open`. */
-export function readReferenceFilter(value) {
-  return filterSchema.parse(value);
+/** A list's state; anything else reads as `open`. */
+export function readReferenceState(value) {
+  return stateSchema.parse(value);
+}
+
+/** Whose items a list shows; anything else reads as `any`. */
+export function readReferencePeople(value) {
+  return peopleSchema.parse(value);
 }
 
 /** `issue` or `pull`; anything else is null. */
@@ -391,18 +477,21 @@ export function parseReferenceLookup(text, repos) {
  * The GitHub search string for one picker page. The user's text may carry
  * its own qualifiers; state and sort are added only when it does not.
  */
-export function buildReferenceSearchQuery({ repos, kind, filter, text }) {
+export function buildReferenceSearchQuery({ repos, kind, state, people, text }) {
   const userText = text.trim();
   const parts = repos.map((entry) => `repo:${entry.owner}/${entry.repo}`);
   parts.push(kind === 'pull' ? 'is:pr' : 'is:issue');
   if (!/(^|\s)(is:(open|closed|merged|unmerged)|state:\S+)/i.test(userText)) {
-    parts.push('is:open');
+    // An issue is never merged; the nearest list is its closed one.
+    const stateQualifier = SEARCH_STATES[kind === 'issue' && state === 'merged' ? 'closed' : state];
+    if (stateQualifier) parts.push(stateQualifier);
   }
   if (!/(^|\s)sort:\S+/i.test(userText)) {
     parts.push('sort:updated-desc');
   }
-  const qualifier = SEARCH_FILTERS[filter];
-  if (qualifier) parts.push(qualifier);
+  // Review requests exist for pull requests only.
+  const peopleQualifier = kind === 'issue' && people === 'reviewRequested' ? '' : SEARCH_PEOPLE[people];
+  if (peopleQualifier) parts.push(peopleQualifier);
   if (userText) parts.push(userText);
   return parts.join(' ');
 }
@@ -442,7 +531,7 @@ async function runPartialQuery(octokit, query, variables) {
  * first. A lookup answers every repo that has the number, both kinds; a
  * search answers one kind, newest activity first.
  */
-export async function searchGitHubReferences({ octokit, repos, kind, filter, text, cursor }) {
+export async function searchGitHubReferences({ octokit, repos, kind, state, people, text, cursor }) {
   const lookup = parseReferenceLookup(text, repos);
   if (lookup) {
     if (lookup.repos.length === 0) {
@@ -457,7 +546,7 @@ export async function searchGitHubReferences({ octokit, repos, kind, filter, tex
   }
 
   const { search } = searchResultSchema.parse(await octokit.graphql(SEARCH_QUERY, {
-    q: buildReferenceSearchQuery({ repos, kind, filter, text }),
+    q: buildReferenceSearchQuery({ repos, kind, state, people, text }),
     first: REFERENCE_PAGE_SIZE,
     after: cursor || null,
   }));

package/server/lib/github/reference-search.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { buildReferenceSearchQuery, fetchReferenceDetail, parseReferenceLookup, readReferenceFilter, toReference } from './reference-search.js';
+import { buildReferenceSearchQuery, fetchReferenceDetail, parseReferenceLookup, readReferencePeople, readReferenceState, toReference } from './reference-search.js';
 
 const origin = { owner: 'acme', repo: 'app', source: 'origin' };
 const upstream = { owner: 'Upstream', repo: 'App', source: 'upstream' };
@@ -21,20 +21,36 @@ const common = (number, repository = { name: 'app', owner: { login: 'acme' } })
 
 describe('buildReferenceSearchQuery', () => {
   it('lists open items of one kind across the network, newest activity first', () => {
-    expect(buildReferenceSearchQuery({ repos, kind: 'issue', filter: 'open', text: '' }))
+    expect(buildReferenceSearchQuery({ repos, kind: 'issue', state: 'open', people: 'any', text: '' }))
       .toBe('repo:acme/app repo:Upstream/App is:issue is:open sort:updated-desc');
-    expect(buildReferenceSearchQuery({ repos: [origin], kind: 'pull', filter: 'reviewRequested', text: ' crash ' }))
+    expect(buildReferenceSearchQuery({ repos: [origin], kind: 'pull', state: 'open', people: 'reviewRequested', text: ' crash ' }))
       .toBe('repo:acme/app is:pr is:open sort:updated-desc review-requested:@me crash');
   });
 
+  it('combines a state with whose items they are', () => {
+    expect(buildReferenceSearchQuery({ repos: [origin], kind: 'pull', state: 'closed', people: 'created', text: '' }))
+      .toBe('repo:acme/app is:pr is:closed sort:updated-desc author:@me');
+    expect(buildReferenceSearchQuery({ repos: [origin], kind: 'pull', state: 'merged', people: 'assigned', text: '' }))
+      .toBe('repo:acme/app is:pr is:merged sort:updated-desc assignee:@me');
+    expect(buildReferenceSearchQuery({ repos: [origin], kind: 'issue', state: 'all', people: 'any', text: '' }))
+      .toBe('repo:acme/app is:issue sort:updated-desc');
+  });
+
+  it('reads issue-only nonsense as the nearest list: merged as closed, review requests as anyone', () => {
+    expect(buildReferenceSearchQuery({ repos: [origin], kind: 'issue', state: 'merged', people: 'reviewRequested', text: '' }))
+      .toBe('repo:acme/app is:issue is:closed sort:updated-desc');
+  });
+
   it('leaves state and sort to the user when their text sets them', () => {
-    expect(buildReferenceSearchQuery({ repos: [origin], kind: 'issue', filter: 'assigned', text: 'is:closed sort:created-asc' }))
+    expect(buildReferenceSearchQuery({ repos: [origin], kind: 'issue', state: 'open', people: 'assigned', text: 'is:closed sort:created-asc' }))
       .toBe('repo:acme/app is:issue assignee:@me is:closed sort:created-asc');
   });
 
-  it('reads an unknown filter as open', () => {
-    expect(readReferenceFilter('everything')).toBe('open');
-    expect(readReferenceFilter('created')).toBe('created');
+  it('reads unknown values as open and anyone', () => {
+    expect(readReferenceState('everything')).toBe('open');
+    expect(readReferenceState('merged')).toBe('merged');
+    expect(readReferencePeople('everyone')).toBe('any');
+    expect(readReferencePeople('created')).toBe('created');
   });
 });
 
@@ -130,11 +146,25 @@ describe('fetchReferenceDetail', () => {
   const pull = (reviews = []) => ({
     __typename: 'PullRequest',
     number: 9,
+    state: 'OPEN',
     reviewDecision: 'CHANGES_REQUESTED',
+    headCommit: { nodes: [{ commit: { statusCheckRollup: { contexts: { nodes: [
+      { __typename: 'CheckRun', databaseId: 1, name: 'test', status: 'COMPLETED', conclusion: 'FAILURE', startedAt: null, checkSuite: { app: { databaseId: 15368 } } },
+      { __typename: 'CheckRun', databaseId: 2, name: 'lint', status: 'COMPLETED', conclusion: 'SUCCESS', startedAt: null, checkSuite: { app: { databaseId: 15368 } } },
+    ] } } } }] },
+    reviewRequests: { nodes: [
+      { requestedReviewer: { __typename: 'User', login: 'hubot', avatarUrl: null } },
+      { requestedReviewer: { __typename: 'Team' } },
+      { requestedReviewer: null },
+    ] },
     additions: 12,
     deletions: 3,
     changedFiles: 2,
     comments: { totalCount: 1, nodes: [{ author, body: 'first', createdAt: '2026-10-01T10:00:00Z', url: 'u1' }] },
+    commits: { totalCount: 1, nodes: [{ commit: {
+      oid: 'abc1234', messageHeadline: 'fix: the thing', committedDate: '2026-10-01T08:00:00Z', url: 'https://github.com/acme/app/commit/abc1234',
+      author: { name: 'Octo Cat', user: author },
+    } }] },
     reviews: { nodes: reviews },
   });
 
@@ -166,9 +196,20 @@ describe('fetchReferenceDetail', () => {
     ]);
     expect(detail?.pull).toEqual({
       reviewDecision: 'changes_requested',
+      reviewers: [{ id: 'hubot', login: 'hubot', avatarUrl: undefined }],
+      checks: expect.objectContaining({ state: 'failure', total: 2, success: 1, failure: 1 }),
       additions: 12,
       deletions: 3,
       changedFiles: 2,
+      commits: [{
+        sha: 'abc1234',
+        headline: 'fix: the thing',
+        author: { login: 'octo', avatarUrl: 'https://avatars/octo' },
+        authorName: 'Octo Cat',
+        committedAt: '2026-10-01T08:00:00Z',
+        url: 'https://github.com/acme/app/commit/abc1234',
+      }],
+      commitTotal: 1,
     });
   });
 

package/server/lib/github/routes.auth.test.js

@@ -1187,6 +1187,24 @@ describe('gh CLI account consent', () => {
     await expect(getOctokitForAccountId('github.com#cli:9')).resolves.toMatchObject({ accountId: 'github.com#cli:9', source: 'cli' });
   });
 
+  it('offers the gh account as a Git transport credential only while the user has switched to it', async () => {
+    const fetch = stubGitHubUsers();
+    const { getGitHubCliCredential } = await import('./octokit.js');
+
+    await expect(getGitHubCliCredential('github.com#cli:9')).resolves.toBeNull();
+    expect(usedCliToken(fetch)).toBe(false);
+
+    auth.setGhCliActive(true);
+    await expect(getGitHubCliCredential('github.com#cli:9')).resolves.toMatchObject({
+      credentialId: 'github.com#cli:9', credentialRevision: 1, providerUserId: 'github.com#9',
+      accessToken: 'cli-token', status: 'valid',
+    });
+    await expect(getGitHubCliCredential('github.com#cli:9', 2)).resolves.toBeNull();
+    // gh signed in as somebody else is not the account the request named.
+    await expect(getGitHubCliCredential('github.com#cli:8')).resolves.toBeNull();
+    await expect(getGitHubCliCredential('github.com#9')).resolves.toBeNull();
+  });
+
   it('stops using the gh token after switching back to a saved account', async () => {
     const fetch = stubGitHubUsers();
     const saved = await auth.setGitHubAuth({ accessToken: 'token-a', user: { id: 7, login: 'saved-user' } });