@gitkraken/core-gitlens 0.5.109 → 0.5.110

package/src/git/utils/pullRequest.utils.ts

@@ -4,9 +4,58 @@ import type {
 	PullRequestRefs,
 	PullRequestRepositoryIdentityDescriptor,
 	PullRequestShape,
+	PullRequestSortField,
+	PullRequestSorting,
 } from '../models/pullRequest.js';
 import { shortenRevision } from './revision.utils.js';
 
+/**
+ * How each sort field is read off a {@link PullRequestShape}, for the filtered PR search, which MERGES its
+ * relationship × state facets in the facade and so has to order the union itself instead of trusting the
+ * per-facet server order. Only the fields the shape carries appear — the same rule as `getIssueComparator`, and
+ * the reason {@link PullRequestSortField} is just these two.
+ */
+const pullRequestSortValues: Partial<
+	Record<PullRequestSortField, (pr: PullRequestShape) => number | Date | string | undefined>
+> = {
+	created: pr => pr.createdDate,
+	updated: pr => pr.updatedDate,
+};
+
+/**
+ * A comparator for one sort key over normalized pull requests, or `undefined` when the field isn't derivable
+ * from a {@link PullRequestShape} — the signal that the key is only honorable on a SINGLE-origin read where the
+ * provider already ordered the page. Missing values sort LAST in both directions (partitioned before any
+ * arithmetic so two missing values compare equal, exactly as `getIssueComparator` does).
+ *
+ * Note it orders whatever it is handed. Sorting a page already capped at the result ceiling does not make it the
+ * top N.
+ */
+export function getPullRequestComparator(
+	sort: PullRequestSorting,
+): ((a: PullRequestShape, b: PullRequestShape) => number) | undefined {
+	const [field, direction] = sort.split(':') as [PullRequestSortField, 'asc' | 'desc'];
+	const getValue = pullRequestSortValues[field];
+	if (getValue == null) return undefined;
+
+	return (a, b) => {
+		const left = toComparable(getValue(a));
+		const right = toComparable(getValue(b));
+		if (left == null || right == null) {
+			if (left == null && right == null) return 0;
+
+			return left == null ? 1 : -1;
+		}
+
+		const ordered = left < right ? -1 : left > right ? 1 : 0;
+		return direction === 'asc' ? ordered : -ordered;
+	};
+}
+
+function toComparable(value: number | Date | string | undefined): number | string | undefined {
+	return value instanceof Date ? value.getTime() : value;
+}
+
 export interface PullRequestUrlIdentity<TProvider extends string = string> {
 	provider?: TProvider;
 
@@ -143,6 +192,7 @@ export function serializePullRequest(value: PullRequest): PullRequestShape {
 		thumbsUpCount: value.thumbsUpCount,
 		reviewDecision: value.reviewDecision,
 		reviewRequests: value.reviewRequests,
+		latestReviews: value.latestReviews,
 		assignees: value.assignees,
 		authoredByMe: value.authoredByMe,
 		project: value.project

package/src/plus/git-github/api/github.ts

@@ -21,7 +21,7 @@ import type {
 	PullRequestState,
 	PullRequestStateFilter,
 } from '../../../git/models/pullRequest.js';
-import { PullRequestMergeMethod } from '../../../git/models/pullRequest.js';
+import { defaultPullRequestSort, PullRequestMergeMethod } from '../../../git/models/pullRequest.js';
 import type { Provider } from '../../../git/models/remoteProvider.js';
 import type { RepositoryMetadata } from '../../../git/models/repositoryMetadata.js';
 import type { GitRevisionRange } from '../../../git/models/revision.js';
@@ -29,6 +29,7 @@ import type { GitUser } from '../../../git/models/user.js';
 import type { RepositoryVisibility } from '../../../git/providers/types.js';
 import { getGitHubNoReplyAddressParts } from '../../../git/remotes/github.js';
 import { effectiveIssueSort, getIssueComparator } from '../../../git/utils/issue.utils.js';
+import { getPullRequestComparator } from '../../../git/utils/pullRequest.utils.js';
 import {
 	createRevisionRange,
 	getRevisionRangeParts,
@@ -110,10 +111,17 @@ const accountResolveBatchSize = 25;
 
 // Pull-request search selects the full PR fragment (reviews, requests, refs, commits, etc.),
 // which makes GitHub reject broad 100-node searches with `Resource limits for this query
-// exceeded` on large repositories. Thirty keeps the default within that GraphQL cost budget
-// while callers that know their scope is cheap can still opt into the supported 100-node max.
+// exceeded` on large repositories. Thirty keeps the default within that GraphQL cost budget;
+// the 100-node maximum the connection accepts is for the lite shape, whose per-node cost is a
+// fraction of it. The budget is per DOCUMENT, and one document holds every relationship × state
+// facet, so the worst case scales with the facet count (five relationships × four states = 20).
 const defaultPullRequestSearchPageSize = 30;
 const maxPullRequestSearchPageSize = 100;
+// Pages `searchMyPullRequests` drains for a caller that wants a whole list rather than a page.
+// Four reduced pages cover more than the single 100-node page this read served before it paged,
+// so the smaller page costs coverage nowhere; it bounds an unbounded drain on a read whose
+// consumers (Launchpad, the Graph pull-request panel) block on it.
+const maxMyPullRequestSearchPages = 4;
 
 function isRetryableTransientError(ex: unknown): ex is RequestError {
 	// An aborted request is rethrown as the original `AbortError` (not a `RequestError`), so it is
@@ -259,6 +267,24 @@ repository {
 	viewerPermission
 }
 `;
+/**
+ * One review's fields, shared by `latestReviews` and `viewerLatestReview`. The two selections must stay
+ * identical: `fromGitHubPullRequest` merges the viewer's review into the capped `latestReviews` window and
+ * dedups by `id`, so a field present in only one of them would produce rows that differ by where they came
+ * from rather than by what they are.
+ */
+const gqlPullRequestReviewFragment = `
+id
+author {
+	login
+	avatarUrl(size: $avatarSize)
+	url
+}
+state
+commit {
+	oid
+}
+`;
 const gqlPullRequestFragment = `
 ${gqlPullRequestLiteFragment}
 additions
@@ -278,14 +304,12 @@ mergedBy {
 reviewDecision
 latestReviews(first: 25) {
 	nodes {
-		author {
-			login
-			avatarUrl(size: $avatarSize)
-			url
-		}
-		state
+		${gqlPullRequestReviewFragment}
 	}
 }
+viewerLatestReview {
+	${gqlPullRequestReviewFragment}
+}
 reviewRequests(first: 25) {
 	nodes {
 		asCodeOwner
@@ -3526,8 +3550,10 @@ export class GitHubApi {
 	 * One page of the current user's pull requests, filtered by state and optionally by an explicit
 	 * relationship qualifier. Backs the PR sweeps, which drain it page by page.
 	 *
-	 * Ordering is part of the contract, not an option: always `sort:updated` (most recently updated first),
-	 * matching {@link searchPullRequestsPage}. A caller that stops before `hasMore` clears — every sweep with a
+	 * Ordering is part of the contract, not an option: always `sort:updated` (most recently updated first), which is
+	 * {@link searchPullRequestsPage}'s DEFAULT rather than its only order — that read takes a `criteria.sort`, this
+	 * one does not, because a sweep's recency window is what its page budget is defined against. A caller that stops
+	 * before `hasMore` clears — every sweep with a
 	 * page budget — therefore retains a well-defined recency window instead of an arbitrary slice of GitHub's
 	 * relevance ranking.
 	 */
@@ -3558,7 +3584,15 @@ export class GitHubApi {
 		cancellation?: AbortSignal,
 	): Promise<{ values: PullRequest[]; cursor?: string; hasMore: boolean; truncated: boolean }> {
 		const scope = getScopedLogger();
-		const limit = Math.min(100, this.config.getLaunchpadQueryLimit?.() ?? 100);
+		// The page follows the projection rather than being a separate decision: the full fragment is what GitHub
+		// rejects at 100 nodes (see `defaultPullRequestSearchPageSize`), so every read that selects it pages at the
+		// reduced size, and only the lite shape asks for the maximum. A caller that wants a whole list pages for it
+		// — see `searchMyPullRequests`.
+		const configuredLimit = this.config.getLaunchpadQueryLimit?.() ?? maxPullRequestSearchPageSize;
+		const limit = Math.min(
+			options?.summary === true ? maxPullRequestSearchPageSize : defaultPullRequestSearchPageSize,
+			configuredLimit,
+		);
 
 		try {
 			interface SearchResult {
@@ -3666,6 +3700,16 @@ export class GitHubApi {
 		}
 	}
 
+	/**
+	 * The whole list rather than a page: this read has no cursor to hand back (its `IntegrationResult<T[]>` return
+	 * has no paging channel at all), so it drains up to {@link maxMyPullRequestSearchPages} pages itself.
+	 *
+	 * Draining instead of taking one page is what lets the full projection page at the reduced size everywhere
+	 * (see the `limit` in {@link searchMyPullRequestsPage}): a single page would otherwise have to ask for 100
+	 * nodes of the selection GitHub rejects at that size, purely because this caller cannot resume. Ordering is
+	 * `sort:updated`, so the pages compose into a defined window rather than a shifting relevance ranking, and the
+	 * drain stops as soon as GitHub reports no next page.
+	 */
 	@trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
 	async searchMyPullRequests(
 		provider: Provider,
@@ -3681,7 +3725,33 @@ export class GitHubApi {
 		},
 		cancellation?: AbortSignal,
 	): Promise<PullRequest[]> {
-		return (await this.searchMyPullRequestsPage(provider, token, options, cancellation)).values;
+		const values: PullRequest[] = [];
+		// The searches behind one page can overlap (a PR can be authored by and review-requested from the same
+		// user), and a later page can repeat a row an earlier one already served if the PR was updated mid-drain.
+		const seen = new Set<string>();
+		let cursor: string | undefined;
+
+		for (let page = 0; page < maxMyPullRequestSearchPages; page++) {
+			const result = await this.searchMyPullRequestsPage(
+				provider,
+				token,
+				{ ...options, cursor: cursor },
+				cancellation,
+			);
+			for (const pr of result.values) {
+				if (seen.has(pr.url)) continue;
+
+				seen.add(pr.url);
+				values.push(pr);
+			}
+
+			// A missing or repeated cursor with `hasMore` would loop on the same page forever.
+			if (!result.hasMore || result.cursor == null || result.cursor === cursor) break;
+
+			cursor = result.cursor;
+		}
+
+		return values;
 	}
 
 	/**
@@ -3948,6 +4018,85 @@ export class GitHubApi {
 		}
 	}
 
+	/**
+	 * The PR twin of {@link countIssues}: counts pull requests for several scopes in ONE request via aliased
+	 * `search` fields selecting only `issueCount` with `first: 0`. Same positional/undefined contract as the issue
+	 * count.
+	 *
+	 * The one difference is states. {@link toGitHubPullRequestSearchFacets} fans a scope's states out into one
+	 * `search` each, so this reports the count the SAME way {@link searchPullRequestsPage} reports its total — the
+	 * LARGEST facet's `issueCount`, not their sum: the result ceiling applies per search, so the max is what
+	 * `exceedsProviderLimit` compares against, and summing would claim a total the read never surfaces. Relationships
+	 * are OR-ed and can't be a single count; the facade refuses a multi-relationship scope, so at most one is here.
+	 */
+	@trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
+	async countPullRequests(
+		provider: Provider,
+		token: GitHubTokenInfo,
+		scopes: readonly { repos?: string[]; org?: string; criteria?: PullRequestSearchCriteria }[],
+		options?: { baseUrl?: string },
+		cancellation?: AbortSignal,
+	): Promise<(number | undefined)[]> {
+		const scope = getScopedLogger();
+		if (scopes.length === 0) return [];
+
+		// Each scope expands to one query string per state facet (all sharing its single relationship, which the
+		// facade guarantees). A scope's count is the MAX across its facets — mirroring searchPullRequestsPage's
+		// totalCount — so the aliases stay grouped by scope and are reduced after the response.
+		const scopeQueries = scopes.map(s => {
+			const scopeQualifiers = toGitHubIssueSearchScopeQualifiers(s.org, s.repos);
+			return toGitHubPullRequestSearchFacets(s.criteria).map(f =>
+				[...scopeQualifiers, ...f.qualifiers].join(' '),
+			);
+		});
+
+		// Aliases are positional and generated (`s${scope}f${facet}`): a caller's key is arbitrary text and would
+		// break the document, so results are reduced back to one count per scope by index.
+		const aliased = scopeQueries.flatMap((queries, si) =>
+			queries.map((query, fi) => ({ alias: `s${si}f${fi}`, query: query })),
+		);
+		const params = aliased.map(a => `$${a.alias}: String!`).join('\n\t\t\t\t');
+		// `first: 0` is what makes this cheap — `issueCount` alone, no nodes over the wire.
+		const fields = aliased
+			.map(a => `${a.alias}: search(query: $${a.alias}, type: ISSUE, first: 0) { issueCount }`)
+			.join('\n\t\t\t\t');
+		const query = `query countPullRequests(
+				${params}
+			) {
+				${fields}
+			}`;
+
+		const variables: Record<string, unknown> = { baseUrl: options?.baseUrl };
+		for (const a of aliased) {
+			variables[a.alias] = a.query;
+		}
+
+		try {
+			const rsp = await this.graphql<Record<string, { issueCount?: number } | undefined>>(
+				provider,
+				token,
+				query,
+				variables,
+				scope,
+				cancellation,
+			);
+			if (rsp == null) return scopes.map(() => undefined);
+
+			return scopeQueries.map((queries, si) => {
+				let max: number | undefined;
+				for (let fi = 0; fi < queries.length; fi++) {
+					const count = rsp[`s${si}f${fi}`]?.issueCount;
+					if (count != null) {
+						max = max == null ? count : Math.max(max, count);
+					}
+				}
+				return max;
+			});
+		} catch (ex) {
+			throw this.handleException(ex, provider, scope);
+		}
+	}
+
 	/**
 	 * The aliased-search engine behind every GitHub issue search: one GraphQL request carrying N independently
 	 * cursored `search` fields, `@include`-gated so an exhausted or unrequested one costs nothing.
@@ -4234,8 +4383,11 @@ export class GitHubApi {
 	 * every active relationship × state facet, so one HTTP request serves one page even when the logical search is
 	 * a union. The cursor preserves each facet's continuation plus the positional page.
 	 *
-	 * Ordering is always most-recently-updated-first, and user text is sanitized before it reaches the provider
-	 * query. See {@link toGitHubPullRequestSearchFacets}.
+	 * Ordering is `criteria.sort`, defaulting to most-recently-updated-first — the order this read served before it
+	 * was expressible. It is requested of the provider AND re-applied to the merged page, because the page is a
+	 * union of facets and no per-facet server order describes it. The sort is part of the cursor fingerprint, so
+	 * changing it invalidates a threaded cursor exactly as changing the text or the scope does. User text is
+	 * sanitized before it reaches the provider query. See {@link toGitHubPullRequestSearchFacets}.
 	 */
 	@trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
 	async searchPullRequestsPage(
@@ -4395,7 +4547,15 @@ export class GitHubApi {
 					}
 				}
 			}
-			pullRequests.sort((a, b) => b.updatedDate.getTime() - a.updatedDate.getTime());
+			// The PR path re-sorts the merged page rather than trusting the per-facet server order — GitHub's
+			// server-side PR sort has been unreliable (the per-branch path re-sorts for the same reason), and the
+			// union of several facets is unordered regardless. The key was validated against
+			// `githubPullRequestSearchCapabilities.sorts` upstream, so its comparator is always defined for a PR
+			// shape; the guard only guards the unreachable case rather than inventing an order for it.
+			const comparator = getPullRequestComparator(options?.criteria?.sort ?? defaultPullRequestSort);
+			if (comparator != null) {
+				pullRequests.sort(comparator);
+			}
 			const values = [
 				...uniqueBy(
 					pullRequests,

package/src/plus/git-github/api/pullRequestSearchQuery.ts

@@ -1,6 +1,10 @@
-import type { PullRequestSearchCriteria, PullRequestStateFilter } from '../../../git/models/pullRequest.js';
-import { PullRequestFilter } from '../../../git/models/pullRequest.js';
-import { sanitizeGitHubSearchText } from './issueSearchQuery.js';
+import type {
+	PullRequestSearchCriteria,
+	PullRequestSorting,
+	PullRequestStateFilter,
+} from '../../../git/models/pullRequest.js';
+import { defaultPullRequestSort, PullRequestFilter } from '../../../git/models/pullRequest.js';
+import { sanitizeGitHubQualifierValue, sanitizeGitHubSearchText } from './issueSearchQuery.js';
 
 export type GitHubPullRequestSearchFacet = {
 	/** Stable GraphQL alias and composite-cursor key. */
@@ -8,10 +12,20 @@ export type GitHubPullRequestSearchFacet = {
 	qualifiers: string[];
 };
 
-const relationshipQualifier: Record<PullRequestFilter, string> = {
+/**
+ * The GitHub search qualifier each relationship translates to. Exhaustive over `PullRequestFilter` so a new
+ * member can't be silently unmapped.
+ *
+ * Exported because the account-wide read builds its own facets from the same vocabulary (see
+ * `GitHubIntegrationBase.getProviderMyPullRequestsForUser`). Kept as ONE declaration rather than a copy per
+ * caller: the exhaustive `Record` makes a missing key a compile error, but nothing would catch two copies
+ * disagreeing on a qualifier STRING, and a wrong qualifier is a read that quietly answers a different question.
+ */
+export const gitHubPullRequestRelationshipQualifiers: Record<PullRequestFilter, string> = {
 	[PullRequestFilter.Author]: 'author:@me',
 	[PullRequestFilter.Assignee]: 'assignee:@me',
 	[PullRequestFilter.ReviewRequested]: 'review-requested:@me',
+	[PullRequestFilter.Reviewed]: 'reviewed-by:@me',
 	[PullRequestFilter.Mention]: 'mentions:@me',
 };
 
@@ -19,6 +33,7 @@ const relationshipAlias: Record<PullRequestFilter, string> = {
 	[PullRequestFilter.Author]: 'author',
 	[PullRequestFilter.Assignee]: 'assignee',
 	[PullRequestFilter.ReviewRequested]: 'reviewRequested',
+	[PullRequestFilter.Reviewed]: 'reviewed',
 	[PullRequestFilter.Mention]: 'mention',
 };
 
@@ -29,6 +44,30 @@ const stateAlias: Record<PullRequestStateFilter, string> = {
 	all: 'All',
 };
 
+/**
+ * How each orderable key becomes a GitHub `sort:` qualifier.
+ *
+ * A literal `Record` over the union rather than a derived transform, for the same reason the relationship tables
+ * are: adding a sort field without deciding its qualifier fails the build instead of quietly emitting a search
+ * with no ordering constraint — the one failure mode the ordering contract exists to prevent, and the one a
+ * caller cannot detect from the result.
+ *
+ * `updated:desc` maps to the bare `sort:updated`, not `sort:updated-desc`. The two are the same query to GitHub,
+ * but the bare form is what this read has always emitted, so keeping it makes the default byte-identical to
+ * today's query — matching `toGitHubIssueSortQualifier`. Do not "normalize" it.
+ */
+export const gitHubPullRequestSortQualifiers: Partial<Record<PullRequestSorting, string>> = {
+	'created:asc': 'sort:created-asc',
+	'created:desc': 'sort:created-desc',
+	'updated:asc': 'sort:updated-asc',
+	'updated:desc': 'sort:updated',
+};
+
+/** The `sort:` qualifier for a key, or `undefined` when there is no key or GitHub can't express it. */
+export function toGitHubPullRequestSortQualifier(sort: PullRequestSorting | undefined): string | undefined {
+	return sort != null ? gitHubPullRequestSortQualifiers[sort] : undefined;
+}
+
 function stateQualifiers(state: PullRequestStateFilter): string[] {
 	switch (state) {
 		case 'closed':
@@ -62,18 +101,53 @@ export function toGitHubPullRequestSearchFacets(
 		: ['open'];
 	const states: PullRequestStateFilter[] = requestedStates.includes('all') ? ['all'] : requestedStates;
 	const text = criteria?.text != null ? sanitizeGitHubSearchText(criteria.text) : '';
+	// Ordering is part of the contract, not an option: without an explicit `sort:` GitHub answers in relevance
+	// order, so which rows land inside the result ceiling would shift with its ranking even when nothing changed
+	// upstream. A key GitHub can't express is REFUSED here, not approximated with a fallback order — a silent
+	// `sort:updated` substitute would emit one order in the query while the merged-page comparator applied another
+	// (or none for an unknown field), which is exactly the "the N most recent are what you get" promise the ceiling
+	// contract cannot keep under a guessed order. Unreachable through the facade — every key is validated against
+	// `githubPullRequestSearchCapabilities.sorts` first — so this guards the direct callers of this exported builder
+	// and of `GitHubApi.searchPullRequestsPage`.
+	//
+	// Deliberately STRICTER than the issue path, which drops an inexpressible qualifier and searches on
+	// (`toGitHubIssueSearchQualifiers` pushes `toGitHubIssueSortQualifier`'s result only when it is non-null). The
+	// two reads differ in what that costs: an issue search is served by whichever facets the provider ordered, while
+	// this one hands its merged page to `getPullRequestComparator`, so a dropped qualifier here means the query and
+	// the comparator disagree about the order the ceiling was applied under. Refusing is the only answer that
+	// cannot lie about which rows were reachable.
+	const sort = criteria?.sort ?? defaultPullRequestSort;
+	const sortQualifier = toGitHubPullRequestSortQualifier(sort);
+	if (sortQualifier == null) {
+		throw new Error(`GitHub cannot order a pull request search by '${sort}'`);
+	}
+
+	// Facet-independent, unlike the relationship/state qualifiers below — build once and share.
+	const dateQualifiers: string[] = [];
+	const pushDate = (value: string | undefined, toQualifier: (sanitized: string) => string): void => {
+		if (value == null) return;
+
+		const sanitized = sanitizeGitHubQualifierValue(value);
+		if (sanitized.length > 0) {
+			dateQualifiers.push(toQualifier(sanitized));
+		}
+	};
+	pushDate(criteria?.updatedAfter, v => `updated:>=${v}`);
+	pushDate(criteria?.createdAfter, v => `created:>=${v}`);
 
 	return relationships.flatMap(relationship =>
 		states.map(state => ({
 			alias: `${relationship != null ? relationshipAlias[relationship] : 'scope'}${stateAlias[state]}`,
 			qualifiers: [
 				'is:pr',
-				...(relationship != null ? [relationshipQualifier[relationship]] : []),
+				...(relationship != null ? [gitHubPullRequestRelationshipQualifiers[relationship]] : []),
 				...stateQualifiers(state),
+				// `!= null`, not truthy: `draft:false` narrows to ready-for-review PRs just as `draft:true` narrows to drafts.
+				...(criteria?.draft != null ? [`draft:${criteria.draft}`] : []),
 				...(criteria?.includeArchived === true ? [] : ['archived:false']),
 				...(text.length > 0 ? [text] : []),
-				// Contract, not an option: a capped result is the N most recently updated only under this order.
-				'sort:updated',
+				...dateQualifiers,
+				sortQualifier,
 			],
 		})),
 	);

package/src/plus/git-github/models.ts

@@ -194,6 +194,13 @@ export type GitHubPullRequestMergeableState = 'MERGEABLE' | 'CONFLICTING' | 'UNK
 export type GitHubPullRequestStatusCheckRollupState = 'SUCCESS' | 'FAILURE' | 'PENDING' | 'EXPECTED' | 'ERROR';
 export type GitHubPullRequestReviewState = 'APPROVED' | 'CHANGES_REQUESTED' | 'COMMENTED' | 'DISMISSED' | 'PENDING';
 
+type GitHubPullRequestReview = {
+	id: string;
+	author: GitHubMember | null;
+	state: GitHubPullRequestReviewState;
+	commit?: { oid: string } | null;
+};
+
 export interface GitHubPullRequest extends GitHubPullRequestLite {
 	additions: number;
 	assignees: {
@@ -204,11 +211,14 @@ export interface GitHubPullRequest extends GitHubPullRequestLite {
 	mergeable: GitHubPullRequestMergeableState;
 	reviewDecision: GitHubPullRequestReviewDecision;
 	latestReviews: {
-		nodes: {
-			author: GitHubMember | null;
-			state: GitHubPullRequestReviewState;
-		}[];
+		nodes: GitHubPullRequestReview[];
 	};
+	/**
+	 * The current user's own latest review. `latestReviews` is capped, so on a heavily-reviewed pull request
+	 * the viewer's own review can fall outside that window — which is exactly the row a "needs my review"
+	 * surface is asking about.
+	 */
+	viewerLatestReview: GitHubPullRequestReview | null;
 	reviewRequests: {
 		nodes: {
 			asCodeOwner: boolean;
@@ -401,6 +411,19 @@ export function fromGitHubPullRequestStatusCheckRollupState(
 }
 
 export function fromGitHubPullRequest(pr: GitHubPullRequest, provider: Provider): PullRequest {
+	// `latestReviews` is capped, so keep the viewer's own review even when it falls outside that window, deduped
+	// by review id since the two selections overlap. Unsubmitted drafts are dropped from the union rather than
+	// from the viewer's side alone: `PENDING` is in GitHub's review-state enum on both selections, and the field
+	// this feeds is documented as reviews already SUBMITTED — a draft there tells a "needs my review" consumer
+	// the review is done, and a reviewer with a submitted review plus a draft would get two conflicting rows.
+	const viewerLatestReview = pr.viewerLatestReview;
+	const latestReviews = [
+		...pr.latestReviews.nodes,
+		...(viewerLatestReview != null && !pr.latestReviews.nodes.some(r => r.id === viewerLatestReview.id)
+			? [viewerLatestReview]
+			: []),
+	].filter(review => review.state !== 'PENDING');
+
 	return new PullRequest(
 		provider,
 		fromGitHubMemberOrGhost(pr.author),
@@ -467,9 +490,10 @@ export function fromGitHubPullRequest(pr: GitHubPullRequest, provider: Provider)
 					: undefined,
 			)
 			.filter(<T>(r?: T): r is T => Boolean(r)),
-		pr.latestReviews.nodes.map(r => ({
+		latestReviews.map(r => ({
 			reviewer: fromGitHubMemberOrGhost(r.author),
 			state: fromGitHubPullRequestReviewState(r.state),
+			commitOid: r.commit?.oid,
 		})),
 		pr.assignees.nodes.map(r => ({
 			id: r.login,

package/src/plus/integrations/integrationService.ts

@@ -77,8 +77,13 @@ import { providersMetadata } from './providers/models.js';
 import type { ProvidersApi } from './providers/providersApi.js';
 import { broadenIssues } from './reads/broaden.js';
 import type { RepositoryResolutionContext } from './reads/context.js';
-import type { IssueCountResult, IssueCountScope } from './reads/counts.js';
-import { countIssues } from './reads/counts.js';
+import type {
+	IssueCountResult,
+	IssueCountScope,
+	PullRequestCountResult,
+	PullRequestCountScope,
+} from './reads/counts.js';
+import { countIssues, countPullRequests } from './reads/counts.js';
 import type { SupportedFilters } from './reads/filters.js';
 import { getSupportedFilters } from './reads/filters.js';
 import { listOrgs, listProjects, listRepos } from './reads/hierarchy.js';
@@ -1147,6 +1152,24 @@ export class IntegrationService implements Disposable, RepositoryResolutionConte
 		return countIssues(this, options);
 	}
 
+	/**
+	 * How many pull requests match each scope, without fetching any — the PR twin of {@link countIssues}. See
+	 * {@link IntegrationManager.countPullRequests} for the cost model, the per-scope isolation rules, and why
+	 * `count: undefined` must not be rendered as zero.
+	 */
+	async countPullRequests(options: {
+		providerId: IntegrationIds;
+		scopes: readonly PullRequestCountScope[];
+		connectionId?: string;
+		/**
+		 * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
+		 * it must come from the trusted authentication configuration, not repository or remote data.
+		 */
+		domain?: string;
+	}): Promise<ProviderResult<PullRequestCountResult>> {
+		return countPullRequests(this, options);
+	}
+
 	/**
 	 * Reads the user's issues from an issue-tracker provider (Jira/Linear/Trello), whose issues live under
 	 * resource → project (not repos), so they can't go through {@link listIssuesPage} (git-host, repo-scoped).

package/src/plus/integrations/manager.ts

@@ -9,7 +9,12 @@ import type { ConfiguredIntegrationsChangeEvent } from './authentication/configu
 import type { ConfiguredIntegrationDescriptor } from './authentication/models.js';
 import type { IntegrationIds } from './constants.js';
 import type { IssueFilter, IssueSorting, PullRequestFilter } from './providerFilters.js';
-import type { IssueCountResult, IssueCountScope } from './reads/counts.js';
+import type {
+	IssueCountResult,
+	IssueCountScope,
+	PullRequestCountResult,
+	PullRequestCountScope,
+} from './reads/counts.js';
 import type { SupportedFilters } from './reads/filters.js';
 import type {
 	ConnectionStateChangeEvent,
@@ -156,6 +161,22 @@ type PullRequestSweepCommonOptions = {
 	 * This extends the provider-native result; it is not a narrowing filter.
 	 */
 	includeReviewRequested?: boolean;
+	/**
+	 * Account-wide only: fetch the full PR projection (review decision, review requests, latest reviews)
+	 * instead of the default summary/lite one. Opt-in because it enlarges every account-wide page; callers
+	 * that classify by review state (e.g. a "needs my review" surface) set it, others keep the lean read.
+	 *
+	 * GitHub/GHE only today — no other provider's account-wide read has a projection switch, so they return
+	 * their native shape regardless. A cross-provider sweep therefore gets reviews from GitHub targets and
+	 * whatever the others natively carry; it is a breadth request, not a guarantee, so it does not refuse
+	 * (unlike `filters`, where dropping a member would change the requested set).
+	 *
+	 * Projection only: it cannot change which pull requests come back. Every GitHub account-wide read goes through
+	 * the same search whether or not it is set, so the Launchpad ignored-repository and organization qualifiers
+	 * (and the per-facet result ceiling) apply the same either way. What it costs is the reduced page size, and a
+	 * document whose weight scales with the number of relationship × state facets in flight.
+	 */
+	includeReviews?: boolean;
 	forceSync?: boolean;
 	maxPages?: number;
 	/**
@@ -355,10 +376,17 @@ export interface IntegrationManager {
 	 * GitHub's mismatched `involves:@me`. Omit relationships only with a repository/organization scope to search
 	 * every PR there.
 	 *
-	 * Results are always ordered most-recently-updated-first. If the provider's result ceiling is reached, the
-	 * request still succeeds and carries a warning omission with `totalCount`, `limit`, and `recovery: 'none'`.
-	 * `totalCount` is the largest provider-reported pre-ceiling facet count, not the reachable or returned row
-	 * count; this mirrors the per-search ceiling's own unit.
+	 * **Ordering is `criteria.sort`**, most-recently-updated-first when omitted. It is validated like every other
+	 * criterion — a key not in `getSupportedFilters().pullRequestSearch.sorts` refuses the whole read rather than
+	 * falling back, because at a bounded result window another order reaches another subset. The page is a union of
+	 * the provider's relationship × state facets, so it is re-ordered as a whole rather than served as concatenated
+	 * per-facet runs. Changing the sort invalidates a threaded cursor (it is part of the cursor's fingerprint,
+	 * alongside the text and the scope); drop the cursor when you change the order.
+	 *
+	 * If the provider's result ceiling is reached, the request still succeeds and carries a warning omission with
+	 * `totalCount`, `limit`, `sort`, and `recovery: 'none'`. `totalCount` is the largest provider-reported
+	 * pre-ceiling facet count, not the reachable or returned row count; this mirrors the per-search ceiling's own
+	 * unit.
 	 *
 	 * Check `getSupportedFilters().pullRequestSearch` before calling. A provider that reports no relationships
 	 * refuses the read rather than returning a page that never honored the criteria or scope.
@@ -518,6 +546,23 @@ export interface IntegrationManager {
 		/** Self-managed host domain fallback; see {@link ProviderSweepTarget.domain}. */
 		domain?: string;
 	}): Promise<ProviderResult<IssueCountResult>>;
+	/**
+	 * How many pull requests match each scope, fetching none of them — the PR twin of {@link countIssues}, behind a
+	 * "this will fetch ~N pull requests" preview and a live count next to an unapplied filter. Same cost model,
+	 * per-scope isolation, `key`-echo, and `count: undefined` ≠ zero rule as the issue count; GitHub/GHE only.
+	 *
+	 * The one PR-specific difference: a scope's `states` are counted as independent searches, so the reported count
+	 * is the LARGEST of them (the same total {@link searchPullRequestsPage} surfaces), not their sum. Several states
+	 * in one scope are therefore fine; only several relationships are refused — one relationship per scope, see
+	 * {@link PullRequestCountScope}.
+	 */
+	countPullRequests(options: {
+		providerId: IntegrationIds;
+		scopes: readonly PullRequestCountScope[];
+		connectionId?: string;
+		/** Self-managed host domain fallback; see {@link ProviderSweepTarget.domain}. */
+		domain?: string;
+	}): Promise<ProviderResult<PullRequestCountResult>>;
 	/** Issue trackers are cloud-only, so this read takes no `domain`. */
 	listIssueTrackerIssuesPage(options: {
 		providerId: IntegrationIds;