@gitkraken/core-gitlens 0.5.108 → 0.5.110

package/src/plus/integrations/providers/pullRequestReviews.ts

@@ -0,0 +1,122 @@
+import type { GitPullRequest } from '@gitkraken/provider-apis';
+import { GitPullRequestReviewState } from '@gitkraken/provider-apis';
+import type { PullRequestReviewer } from '../../../git/models/pullRequest.js';
+import { PullRequestReviewDecision, PullRequestReviewState } from '../../../git/models/pullRequest.js';
+import { fromProviderAccount, toProviderAccount } from './accounts.js';
+
+/**
+ * The GitLens-local extension of provider-apis' review shape, in two parts: a `DISMISSED` state the upstream
+ * `GitPullRequestReviewState` has no member for, and the head-commit oid a review was submitted against
+ * (optional, so a raw SDK review stays assignable — only the GitHub path populates it).
+ *
+ * Both exist for the same case: on GitHub the `dismiss stale reviews` rule flips an approval to dismissed on
+ * the next push, which is exactly the "the PR moved past my review" situation the oid detects. Dropping such a
+ * review instead would hand a consumer a PR out of the `reviewed-by:@me` set with no review row at all,
+ * indistinguishable from never having reviewed it.
+ */
+export const providerPullRequestReviewStateDismissed = 'DISMISSED' as const;
+export type ProviderPullRequestReview = Omit<NonNullable<GitPullRequest['reviews']>[number], 'state'> & {
+	state: GitPullRequestReviewState | typeof providerPullRequestReviewStateDismissed;
+	commitOid?: string;
+};
+/**
+ * The review list as it travels on {@link ProviderPullRequest}: `null` when the read carried no review data at
+ * all, as opposed to an empty array for a pull request nobody has reviewed.
+ */
+export type ProviderPullRequestReviews = ProviderPullRequestReview[] | null;
+
+export const toProviderPullRequestReviewState = {
+	[PullRequestReviewState.Approved]: GitPullRequestReviewState.Approved,
+	[PullRequestReviewState.ChangesRequested]: GitPullRequestReviewState.ChangesRequested,
+	[PullRequestReviewState.Commented]: GitPullRequestReviewState.Commented,
+	[PullRequestReviewState.ReviewRequested]: GitPullRequestReviewState.ReviewRequested,
+	[PullRequestReviewState.Dismissed]: providerPullRequestReviewStateDismissed,
+	// A review the author started but never submitted. Visible only to that author and carrying no verdict, so
+	// it stays unmapped and is dropped by the projection.
+	[PullRequestReviewState.Pending]: null,
+};
+
+export const fromProviderPullRequestReviewState = {
+	[GitPullRequestReviewState.Approved]: PullRequestReviewState.Approved,
+	[GitPullRequestReviewState.ChangesRequested]: PullRequestReviewState.ChangesRequested,
+	[GitPullRequestReviewState.Commented]: PullRequestReviewState.Commented,
+	[GitPullRequestReviewState.ReviewRequested]: PullRequestReviewState.ReviewRequested,
+	[providerPullRequestReviewStateDismissed]: PullRequestReviewState.Dismissed,
+};
+
+export function toProviderReviews(reviewers: PullRequestReviewer[]): ProviderPullRequestReviews {
+	// Only `Pending` maps to null (see `toProviderPullRequestReviewState`), so this drops exactly the reviews
+	// that carry no verdict rather than defaulting them to `ReviewRequested` — which would report an unsubmitted
+	// draft as a pending request from that reviewer.
+	return reviewers
+		.filter(r => r.state !== PullRequestReviewState.Pending)
+		.map(reviewer => ({
+			reviewer: toProviderAccount(reviewer.reviewer),
+			state: toProviderPullRequestReviewState[reviewer.state] ?? GitPullRequestReviewState.ReviewRequested,
+			commitOid: reviewer.commitOid,
+		}));
+}
+
+export function toReviewRequests(reviews: ProviderPullRequestReviews): PullRequestReviewer[] | undefined {
+	return reviews == null
+		? undefined
+		: reviews
+				?.filter(r => r.state === GitPullRequestReviewState.ReviewRequested)
+				.map(r => ({
+					isCodeOwner: false, // TODO: Find this value, and implement in the shared lib if needed
+					reviewer: fromProviderAccount(r.reviewer),
+					state: PullRequestReviewState.ReviewRequested,
+				}));
+}
+
+export function toCompletedReviews(reviews: ProviderPullRequestReviews): PullRequestReviewer[] | undefined {
+	return reviews == null
+		? undefined
+		: reviews
+				?.filter(
+					r =>
+						r.state !== GitPullRequestReviewState.ReviewRequested &&
+						// provider-apis' own GitHub normalizer maps only its four known states, so a review it has no
+						// member for (a real `DISMISSED` one, which its `latestReviews(first: 100)` selection does
+						// return) arrives with `state: undefined` — a value its type says cannot happen. Publishing it
+						// would put an unswitchable state on `PullRequestShape.latestReviews`, and mapping back would
+						// hit `toProviderReviews`' fallback and report a dismissed review as an outstanding request.
+						// Our own GitHub path never lands here: it carries `providerPullRequestReviewStateDismissed`.
+						fromProviderPullRequestReviewState[r.state] != null,
+				)
+				.map(r => ({
+					isCodeOwner: false, // TODO: Find this value, and implement in the shared lib if needed
+					reviewer: fromProviderAccount(r.reviewer),
+					state: fromProviderPullRequestReviewState[r.state],
+					commitOid: r.commitOid,
+				}));
+}
+
+export function toProviderReviewDecision(
+	reviewDecision?: PullRequestReviewDecision,
+	reviewers?: PullRequestReviewer[],
+): GitPullRequestReviewState | null {
+	switch (reviewDecision) {
+		case PullRequestReviewDecision.Approved:
+			return GitPullRequestReviewState.Approved;
+		case PullRequestReviewDecision.ChangesRequested:
+			return GitPullRequestReviewState.ChangesRequested;
+		case PullRequestReviewDecision.ReviewRequired:
+			return GitPullRequestReviewState.ReviewRequested;
+		default: {
+			if (reviewers?.some(r => r.state === PullRequestReviewState.ReviewRequested)) {
+				return GitPullRequestReviewState.ReviewRequested;
+			} else if (reviewers?.some(r => r.state === PullRequestReviewState.Commented)) {
+				return GitPullRequestReviewState.Commented;
+			}
+			return null;
+		}
+	}
+}
+
+export const fromPullRequestReviewDecision = {
+	[GitPullRequestReviewState.Approved]: PullRequestReviewDecision.Approved,
+	[GitPullRequestReviewState.ChangesRequested]: PullRequestReviewDecision.ChangesRequested,
+	[GitPullRequestReviewState.Commented]: undefined,
+	[GitPullRequestReviewState.ReviewRequested]: PullRequestReviewDecision.ReviewRequired,
+};

package/src/plus/integrations/providers/trello.ts

@@ -9,8 +9,8 @@ import type { ProviderAuthenticationSession } from '../authentication/models.js'
 import { toTokenWithInfo } from '../authentication/models.js';
 import { IssuesCloudHostIntegrationId } from '../constants.js';
 import { IntegrationReadUnavailableError } from '../errors.js';
+import type { IssuesForProjectOptions } from '../models/issueReads.js';
 import { IssuesIntegration } from '../models/issuesIntegration.js';
-import type { IssueFilter } from './models.js';
 import { fromProviderIssue, providersMetadata, toIssueShape } from './models.js';
 
 const metadata = providersMetadata[IssuesCloudHostIntegrationId.Trello];
@@ -95,7 +95,7 @@ export class TrelloIntegration extends IssuesIntegration<IssuesCloudHostIntegrat
 	protected override async getProviderIssuesForProject(
 		session: ProviderAuthenticationSession,
 		project: ResourceDescriptor,
-		options?: { user?: string; filters?: IssueFilter[] },
+		options?: IssuesForProjectOptions,
 	): Promise<IssueShape[] | undefined> {
 		return (await this.getProviderIssuesForProjectWithTruncation(session, project, options))?.values;
 	}
@@ -103,7 +103,7 @@ export class TrelloIntegration extends IssuesIntegration<IssuesCloudHostIntegrat
 	protected override async getProviderIssuesForProjectWithTruncation(
 		session: ProviderAuthenticationSession,
 		project: ResourceDescriptor,
-		options?: { user?: string; filters?: IssueFilter[] },
+		options?: IssuesForProjectOptions,
 	): Promise<{ values: IssueShape[]; truncated: boolean; metadata?: CollectionMetadata } | undefined> {
 		// A non-issue descriptor genuinely has nothing to read (empty), but a missing app key is a broken read.
 		if (!isIssueResourceDescriptor(project)) return undefined;
@@ -129,6 +129,7 @@ export class TrelloIntegration extends IssuesIntegration<IssuesCloudHostIntegrat
 		const result = await api.getTrelloIssuesForBoard(tokenWithInfo, appKey, project.id, {
 			assigneeLogins: options?.user != null ? [options.user] : undefined,
 			trelloBoardListsById: trelloBoardListsById,
+			sort: options?.sort,
 		});
 
 		const values = result.values.flatMap(issue => {

package/src/plus/integrations/providers/utils/providerPaging.ts

@@ -6,7 +6,7 @@ import type {
 } from '@gitkraken/provider-apis';
 import { isCancellationError } from '../../../../utils/cancellation.js';
 import { uniqueBy } from '../../../../utils/iterable.js';
-import { toCollectionScopeFailure } from '../../collectionMetadata.js';
+import { throwIfCallerContractError, toCollectionScopeFailure } from '../../collectionMetadata.js';
 import { collectionScopeKey } from '../../results.js';
 import type { ProviderApiPagedResult, ProviderHierarchyResult } from '../models.js';
 
@@ -144,6 +144,11 @@ export async function collectProviderPagedResult<T>(
 		} catch (ex) {
 			if (isCancellationError(ex)) throw ex;
 
+			// A caller-contract error is not a fact about this scope, so it is never recorded as one — see
+			// `throwIfCallerContractError`. Checked alongside cancellation because both are errors that a
+			// per-scope failure would misdescribe.
+			throwIfCallerContractError(ex);
+
 			// When the caller supplied a scope, preserve the items already fetched from that scope and record the
 			// failure in collection metadata rather than re-throwing and discarding the prefix. Callers without a
 			// scope keep the legacy throw behavior.

package/src/plus/integrations/reads/broaden.ts

@@ -33,6 +33,12 @@ import { gitHostOnlySurfaceWarning, issuesUnsupportedWarning, noConnectionWarnin
  * `includeAllAssignees: true`, which resolves to no assignee constraint at all, so unassigned issues ARE
  * included. The equivalent is an OMITTED `relationships`, not `['any-assignee']`: `assignee:*` means "has some
  * assignee" and would silently exclude every unassigned issue, which is the opposite of broadening.
+ *
+ * Takes no `sort`, unlike `listIssuesPage` and `searchIssuesPage`. One logical page here spans several orgs, each
+ * at its own provider position in a cursor bundle, so honoring an order across them would need a k-way merge with
+ * a buffer per org rather than a sort of what arrived — the page is a slice of several independent walks, not a
+ * union of one round's results. `searchIssuesPage({ repos, criteria: { sort } })` answers the ordered version of
+ * this question for a caller that knows its repositories, and is already the recommended migration above.
  */
 
 export interface BroadenIssuesOptions {

package/src/plus/integrations/reads/counts.ts

@@ -1,4 +1,5 @@
 import type { IssueSearchCriteria } from '../../../git/models/issue.js';
+import type { PullRequestSearchCriteria } from '../../../git/models/pullRequest.js';
 import { chunk } from '../../../utils/array.js';
 import { mapBounded } from '../../../utils/promise.js';
 import type { IntegrationIds } from '../constants.js';
@@ -14,12 +15,18 @@ import {
 } from '../utils/integration.utils.js';
 import type { ProviderReadContext } from './context.js';
 import { runCaptured } from './drains.js';
-import { resolveIssueSearchCriteria, resolveIssueSearchScope } from './filters.js';
+import {
+	resolveIssueSearchCriteria,
+	resolveIssueSearchScope,
+	resolvePullRequestSearchCriteria,
+	resolvePullRequestSearchScope,
+} from './filters.js';
 import {
 	gitHostOnlySurfaceWarning,
 	issuesUnsupportedWarning,
 	otherWarning,
 	unsupportedIssueSearchCriteriaWarning,
+	unsupportedPullRequestSearchCriteriaWarning,
 } from './warnings.js';
 
 /**
@@ -32,6 +39,15 @@ import {
  */
 const issueCountChunkSize = 25;
 
+/**
+ * How many pull-request scopes go into one upstream request.
+ *
+ * The same latency/complexity reasoning as {@link issueCountChunkSize}, kept slightly smaller because a pull-request
+ * scope can fan out into one aliased count PER requested state (open/closed/merged), so a chunk of scopes carries a
+ * small multiple of that many `search` aliases.
+ */
+const pullRequestCountChunkSize = 15;
+
 /**
  * One scope to count.
  *
@@ -44,7 +60,14 @@ export interface IssueCountScope {
 	/** Repositories to count over. Combines with `org`, exactly as in `searchIssuesPage`. */
 	repos?: ProviderReposInput;
 	org?: string;
-	/** Same criteria model as `searchIssuesPage`, validated against the same capability table. */
+	/**
+	 * Same criteria model as `searchIssuesPage`, validated against the same capability table.
+	 *
+	 * `criteria.sort` does not affect the count — a total is invariant under ordering — but it is still VALIDATED,
+	 * and an unsupported key refuses this scope exactly as it would refuse the read. That is the point of the
+	 * count: it previews the constraints the read will apply, so one that accepted what the read refuses would
+	 * promise a fetch that can't happen, which is worse than no preview at all.
+	 */
 	criteria?: IssueSearchCriteria;
 }
 
@@ -66,6 +89,42 @@ export interface IssueCountResult {
 	providerLimit?: number;
 }
 
+/**
+ * One scope to count pull requests over — the PR twin of {@link IssueCountScope}.
+ *
+ * `key` is caller-owned and echoed back verbatim, never reaching the provider query (the aliases are generated), so
+ * it can be any string the caller finds meaningful.
+ */
+export interface PullRequestCountScope {
+	key: string;
+	/** Repositories to count over. Combines with `org`, exactly as in `searchPullRequestsPage`. */
+	repos?: ProviderReposInput;
+	org?: string;
+	/**
+	 * Same criteria model as `searchPullRequestsPage`, validated against the same capability table — so a count
+	 * refuses exactly what the read would, and never previews a fetch that can't happen.
+	 */
+	criteria?: PullRequestSearchCriteria;
+}
+
+/** The count for one {@link PullRequestCountScope}, echoed back under the caller's own `key`. */
+export interface PullRequestCountResult {
+	key: string;
+	/**
+	 * Total matches the provider reports. `undefined` when the provider didn't report one for this scope — NEVER
+	 * zero, which is a real answer. For a multi-state scope this is the LARGEST of its per-state counts, the same
+	 * total `searchPullRequestsPage` surfaces, not their sum.
+	 */
+	count?: number;
+	/**
+	 * True when `count` exceeds the provider's own per-search result ceiling, so a full read CANNOT return
+	 * everything no matter how it is paged. This is the signal to warn before starting an expensive fetch.
+	 */
+	exceedsProviderLimit: boolean;
+	/** The ceiling itself, when the provider declares one. */
+	providerLimit?: number;
+}
+
 /**
  * Counts issues for many scopes without fetching any — the probe behind a "this will fetch ~N issues" preview.
  *
@@ -221,7 +280,7 @@ export async function countIssues(
 }
 
 /** The first key that appears twice, or `undefined` when every key is unique. */
-function findDuplicateKey(scopes: readonly IssueCountScope[]): string | undefined {
+function findDuplicateKey(scopes: readonly { key: string }[]): string | undefined {
 	const seen = new Set<string>();
 	for (const scope of scopes) {
 		if (seen.has(scope.key)) return scope.key;
@@ -283,3 +342,222 @@ function rejectScope(
 
 	return undefined;
 }
+
+/**
+ * Counts pull requests for many scopes without fetching any — the PR twin of {@link countIssues}, and the probe
+ * behind a "this will fetch ~N pull requests" preview.
+ *
+ * Identical batching, per-scope isolation, and `key`-echo contract as {@link countIssues}; see it for the cost
+ * model and the `count: undefined` ≠ zero rule. The one difference is inherent to pull requests: a scope's criteria
+ * can name several STATES, which the provider counts as independent searches — the reported `count` is the LARGEST
+ * of them (mirroring `searchPullRequestsPage`'s total), so an unpaged read still can't exceed a single search's
+ * ceiling undetected.
+ */
+export async function countPullRequests(
+	ctx: ProviderReadContext,
+	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>> {
+	const refused = (warning: ProviderWarning): ProviderResult<PullRequestCountResult> => ({
+		items: [],
+		warnings: [warning],
+		fetchFailed: true,
+	});
+
+	if (isIssuesHostIntegrationId(options.providerId)) {
+		return refused(
+			gitHostOnlySurfaceWarning(options.providerId, undefined, options.connectionId, 'Pull request counts'),
+		);
+	}
+
+	// Nothing was asked for, so nothing is missing: an empty success, not a refusal.
+	if (options.scopes.length === 0) return { items: [], warnings: [] };
+
+	const duplicateKey = findDuplicateKey(options.scopes);
+	if (duplicateKey != null) {
+		// Refuses the whole call rather than deduping: `key` exists so the caller can match results without
+		// positional bookkeeping, and two results under one key make that ambiguous for EVERY scope, not just the
+		// repeated one.
+		return refused(
+			otherWarning(
+				options.providerId,
+				undefined,
+				options.connectionId,
+				`Duplicate pull request count scope key '${duplicateKey}'; keys identify results, so each must be unique.`,
+			),
+		);
+	}
+
+	const integration = await ctx.getIntegrationForRead(options.providerId, options.connectionId, options.domain);
+	if (integration == null) {
+		// A supplied connection or domain that no longer resolves is a broken target, not an empty account.
+		const early = ctx.earlyReturnConnectionWarnings(options.providerId, options.connectionId, options.domain);
+		return { items: [], warnings: early.warnings, fetchFailed: early.fetchFailed || undefined };
+	}
+	if (!isGitHostIntegration(integration)) {
+		return refused(
+			gitHostOnlySurfaceWarning(options.providerId, undefined, options.connectionId, 'Pull request counts'),
+		);
+	}
+
+	const domain = ctx.domainForRead(integration, options.providerId, options.connectionId, options.domain);
+	const warnOnMissingSession = warnOnMissingSessionForDomain(options.providerId, options.domain);
+
+	// A provider with no filtered pull-request search has no count either: refuse ONCE for the provider rather than
+	// letting every scope repeat the same rejection. `undefined` criteria probes only the search's existence.
+	const searchSupport = resolvePullRequestSearchCriteria(options.providerId, undefined);
+	if (searchSupport.rejection != null) {
+		return refused(
+			unsupportedPullRequestSearchCriteriaWarning(
+				options.providerId,
+				domain,
+				options.connectionId,
+				searchSupport.rejection,
+			),
+		);
+	}
+
+	const providerLimit = providersMetadata[options.providerId]?.pullRequestSearchResultLimit;
+	const warnings: ProviderWarning[] = [];
+	let fetchFailed = false;
+
+	// Validate every scope first, so a refusal costs no request at all and the countable ones are still batched
+	// together.
+	const countable: PullRequestCountScope[] = [];
+	for (const scope of options.scopes) {
+		const warning = rejectPullRequestScope(options.providerId, domain, options.connectionId, scope);
+		if (warning != null) {
+			// `push`, not `appendDedupedWarning`: every rejection message embeds the scope's own key, and duplicate
+			// keys were already refused above, so no two of these can ever collapse.
+			warnings.push(warning);
+			fetchFailed = true;
+			continue;
+		}
+
+		countable.push(scope);
+	}
+
+	// Chunks are independent requests over their own slice of scopes, `runCaptured` never throws, so they run
+	// concurrently, bounded like every other fan-out on the facade. `mapBounded` returns in input order, so `items`
+	// and `warnings` stay in scope order.
+	const batches = await mapBounded(chunk(countable, pullRequestCountChunkSize), providerFanOutConcurrency, batch =>
+		runCaptured(
+			options.providerId,
+			domain,
+			options.connectionId,
+			() =>
+				integration.countPullRequestsResult(
+					batch.map(s => ({
+						repos: s.repos as ProviderRepoInput[] | undefined,
+						org: s.org,
+						criteria: s.criteria,
+					})),
+					undefined,
+					options.connectionId,
+				),
+			{ warnOnMissingSession: warnOnMissingSession },
+		).then(result => ({ batch: batch, ...result })),
+	);
+
+	const items: PullRequestCountResult[] = [];
+	for (const { batch, value, warning } of batches) {
+		if (warning != null) {
+			appendDedupedWarning(warnings, warning);
+		}
+		if (value == null) {
+			// This batch contributes nothing, but the batches around it still do. Drop only these scopes.
+			fetchFailed = true;
+			continue;
+		}
+
+		for (let i = 0; i < batch.length; i++) {
+			const count = value[i];
+			items.push({
+				key: batch[i].key,
+				count: count,
+				// Only a reported count can exceed a declared ceiling; unknown-vs-limit is not a comparison.
+				exceedsProviderLimit: count != null && providerLimit != null && count > providerLimit,
+				providerLimit: providerLimit,
+			});
+		}
+	}
+
+	// A provider that reported nothing for any scope and raised no warning: say so explicitly rather than letting it
+	// read as "every scope matched nothing".
+	if (items.length === 0 && warnings.length === 0) {
+		return refused(
+			unsupportedPullRequestSearchCriteriaWarning(options.providerId, domain, options.connectionId, {
+				reason: 'unsupported-search',
+			}),
+		);
+	}
+
+	return { items: items, warnings: warnings, fetchFailed: fetchFailed || undefined };
+}
+
+/**
+ * Why one pull-request scope can't be counted, as the warning to report — or `undefined` when it can. The PR twin
+ * of {@link rejectScope}, validating against the same {@link resolvePullRequestSearchScope} /
+ * {@link resolvePullRequestSearchCriteria} the read uses, so a count always previews the constraints the read
+ * would apply.
+ */
+function rejectPullRequestScope(
+	providerId: IntegrationIds,
+	domain: string | undefined,
+	connectionId: string | undefined,
+	scope: PullRequestCountScope,
+): ProviderWarning | undefined {
+	const scoping = resolvePullRequestSearchScope(providerId, scope.repos, scope.org, scope.criteria);
+	switch (scoping.rejection) {
+		case 'repo-ids':
+			return otherWarning(
+				providerId,
+				domain,
+				connectionId,
+				`Pull request count scope '${scope.key}' cannot be scoped by repository id; pass repository descriptors (namespace + name) instead.`,
+			);
+		case 'unscoped':
+			return otherWarning(
+				providerId,
+				domain,
+				connectionId,
+				`Pull request count scope '${scope.key}' is unscoped; pass \`repos\`, \`org\`, or at least one current-user relationship.`,
+			);
+		case 'unsupported-repository-scope':
+		case 'unsupported-organization-scope':
+			return unsupportedPullRequestSearchCriteriaWarning(providerId, domain, connectionId, {
+				reason: 'unsupported-criteria',
+				criteria: [
+					scoping.rejection === 'unsupported-repository-scope' ? 'repositoryScope' : 'organizationScope',
+				],
+			});
+	}
+
+	const resolved = resolvePullRequestSearchCriteria(providerId, scope.criteria);
+	if (resolved.rejection != null) {
+		return unsupportedPullRequestSearchCriteriaWarning(providerId, domain, connectionId, resolved.rejection);
+	}
+
+	// Count-only, with no counterpart in the read: a relationship set is an OR across several searches, which one
+	// count can't express — summing would double-count overlaps and max would under-report. Ask the caller to count
+	// each relationship as its own scope, where the keys make the OR explicit. (States are disjoint, so a scope may
+	// still name several — the provider counts them as the max, not a refusal.)
+	if ((scope.criteria?.relationships?.length ?? 0) > 1) {
+		return otherWarning(
+			providerId,
+			domain,
+			connectionId,
+			`Pull request count scope '${scope.key}' requests several relationships, which a single count can't express (they are OR-ed, so overlapping matches would be double-counted); pass one scope per relationship.`,
+		);
+	}
+
+	return undefined;
+}

package/src/plus/integrations/reads/drains.ts

@@ -70,7 +70,12 @@ export async function drainPullRequests(
 	repos: ProviderReposInput,
 	state: PullRequestStateFilter[] | undefined,
 	filters: PullRequestFilter[] | undefined,
-	includeReviewRequested: boolean,
+	/**
+	 * Breadth opt-ins that only the account-wide read can express. Grouped rather than passed positionally
+	 * because they are same-typed neighbors a transposition would silently swap, and picked from the sweep
+	 * options rather than restated so a third opt-in is declared once.
+	 */
+	accountWideOptions: Pick<PullRequestSweepOptions, 'includeReviewRequested' | 'includeReviews'> | undefined,
 	connectionId: string | undefined,
 	maxPages: number,
 	attributeUnavailableProvider: boolean,
@@ -100,6 +105,10 @@ export async function drainPullRequests(
 	// With no repos this is an account-wide "my PRs" sweep. The repo-scoped core rejects an empty `repos`
 	// input, so read the provider-native account-wide core instead.
 	const accountWide = repos.length === 0;
+	// The breadth opt-ins are only expressible on the account-wide core, so gate them here — the single place
+	// that already knows which core it is about to call.
+	const includeReviewRequested = accountWide && (accountWideOptions?.includeReviewRequested ?? false);
+	const includeReviews = accountWide && (accountWideOptions?.includeReviews ?? false);
 	/** Every cursor already followed, so a provider that cycles them can't keep the drain walking in circles. */
 	const seenCursors = new Set<string>();
 
@@ -115,7 +124,8 @@ export async function drainPullRequests(
 							cursor: pageCursor,
 							includeReviewRequested: includeReviewRequested,
 							filters: filters,
-							summary: true,
+							// Lite by default; the full projection (reviews) only when a caller opts in.
+							summary: !includeReviews,
 						},
 						connectionId,
 					)