@gitkraken/core-gitlens 0.5.110 → 0.5.112

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

@@ -38,7 +38,7 @@ import {
 } from '../../../git/utils/revision.utils.js';
 import { chunk } from '../../../utils/array.js';
 import { base64 } from '../../../utils/base64.js';
-import { CancellationError } from '../../../utils/cancellation.js';
+import { CancellationError, isCancellationError } from '../../../utils/cancellation.js';
 import { trace } from '../../../utils/decorators/log.js';
 import type { Event } from '../../../utils/event.js';
 import { Emitter } from '../../../utils/event.js';
@@ -231,6 +231,85 @@ title
 updatedAt
 url
 `;
+/**
+ * Stacked-pull-request selections, appended to a pull request's selection set rather than baked into
+ * the fragments below: GitHub Enterprise Server schemas lag github.com, and selecting `stack` there
+ * fails the entire query with "Field 'stack' doesn't exist on type 'PullRequest'" — which would take
+ * every PR feature down with it, not just stacks. Always add these via `gqlPullRequestStackFragmentFor`.
+ */
+const gqlPullRequestStackFragment = `
+stack {
+	id
+	number
+	size
+	baseRefName
+}
+stackEntry {
+	position
+}
+`;
+
+function gqlPullRequestStackFragmentFor(options?: { baseUrl?: string }): string {
+	return isGitHubDotCom(options) ? gqlPullRequestStackFragment : '';
+}
+
+/** One layer of a stack, as returned by the stacks REST API. Ordered bottom to top. */
+export interface GitHubStackLayer {
+	number: number;
+	state: string;
+	draft?: boolean;
+	merged_at?: string | null;
+	head: { ref: string; sha: string };
+}
+
+export interface GitHubStackResource {
+	id: string;
+	number: number;
+	/** The stack's trunk — what the bottom member targets. */
+	base: { ref: string; sha?: string };
+	/** False once every member has merged; such a stack can no longer be extended. */
+	open?: boolean;
+	/** Members ordered bottom to top. */
+	pull_requests: GitHubStackLayer[];
+}
+
+/** Result of the asynchronous merge used for stacked pull requests. */
+interface GitHubAsyncMergeResult {
+	status: 'pending' | 'merged' | 'enqueued' | 'failed';
+	/** Everything but `status` is nested here — flattening it silently loses the poll ticket. */
+	details?: {
+		/** Always present; on `failed` it is the only explanation of why. */
+		message?: string;
+		/** Only while `pending` — the ticket to poll. */
+		uuid?: string;
+		/** Only once `merged`. */
+		sha?: string;
+		merge_method?: string;
+		merge_action?: string;
+		expected_head_sha?: string;
+	};
+}
+
+/**
+ * A 409 means a merge request is already in flight and carries its ticket, so it resumes rather than fails.
+ *
+ * The body has to be dug out of `original`: `requestCore` routes every 4xx through `handleRequestError`,
+ * which re-wraps octokit's `RequestError` in a `RequestClientError` carrying only `message` and `original`.
+ */
+function getAsyncMergeUuidFromConflict(ex: unknown): string | undefined {
+	const err = (RequestClientError.is(ex) ? ex.original : ex) as
+		| { status?: number; response?: { data?: GitHubAsyncMergeResult } }
+		| undefined;
+	if (err?.status !== 409) return undefined;
+
+	return err.response?.data?.details?.uuid;
+}
+
+const asyncMergePollIntervalMs = 2000;
+/** A stack merges one layer at a time and GitHub only promises "a few minutes", so the ceiling is
+ *  generous — giving up early would report a failure for a merge still in progress. */
+const maxAsyncMergePolls = 300;
+
 const gqlPullRequestLiteFragment = `
 ${gqlIssueOrPullRequestFragment}
 author {
@@ -295,6 +374,7 @@ assignees(first: 25) {
 		url
 	}
 }
+changedFiles
 checksUrl
 deletions
 mergeable
@@ -324,6 +404,7 @@ reviewRequests(first: 25) {
 	}
 }
 commits(last: 1) {
+	totalCount
 	nodes {
 		commit {
 			statusCheckRollup {
@@ -415,6 +496,7 @@ export class GitHubApi {
 
 		interface QueryResult {
 			viewer: {
+				databaseId: number | null;
 				name: string | null;
 				email: string | null;
 				login: string | null;
@@ -425,6 +507,7 @@ export class GitHubApi {
 		try {
 			const query = `query getCurrentAccount($avatarSize: Int) {
 	viewer {
+		databaseId
 		name
 		email
 		login
@@ -437,7 +520,10 @@ export class GitHubApi {
 
 			return {
 				provider: provider,
-				id: rsp.viewer.login,
+				// `id` is the provider's own id, as it is for every other provider, and `username` the handle
+				// filters and viewer matching key on. Falls back to the login only when GitHub omits the
+				// database id, which leaves the two equal rather than leaving `id` empty.
+				id: rsp.viewer.databaseId != null ? String(rsp.viewer.databaseId) : rsp.viewer.login,
 				name: rsp.viewer.name ?? undefined,
 				email: rsp.viewer.email ?? undefined,
 				// If we are GitHub Enterprise, we may need to convert the avatar URL since it might require authentication
@@ -997,6 +1083,7 @@ export class GitHubApi {
 	repository(name: $repo, owner: $owner) {
 		pullRequest(number: $number) {
 			${gqlPullRequestLiteFragment}
+			${gqlPullRequestStackFragmentFor(options)}
 		}
 	}
 }`;
@@ -1077,6 +1164,7 @@ export class GitHubApi {
 			associatedPullRequests(first: $limit, orderBy: {field: UPDATED_AT, direction: DESC}, states: $include) {
 				nodes {
 					${gqlPullRequestLiteFragment}
+					${gqlPullRequestStackFragmentFor(options)}
 				}
 			}
 		}
@@ -1170,6 +1258,7 @@ export class GitHubApi {
 				associatedPullRequests(first: 2, orderBy: {field: UPDATED_AT, direction: DESC}) {
 					nodes {
 						${gqlPullRequestLiteFragment}
+						${gqlPullRequestStackFragmentFor(options)}
 					}
 				}
 			}
@@ -3307,6 +3396,40 @@ export class GitHubApi {
 		scope: ScopedLogger | undefined,
 		cancellation?: AbortSignal | undefined,
 	): Promise<Endpoints[R]['response']> {
+		return (await this.requestCore(
+			provider,
+			token,
+			route,
+			options,
+			scope,
+			cancellation,
+		)) as Endpoints[R]['response'];
+	}
+
+	/**
+	 * REST call for routes `@octokit/types` doesn't describe yet — currently the stacked-pull-request
+	 * merge APIs, which are in public preview and absent from the generated endpoint map. Prefer
+	 * `request` for anything typed.
+	 */
+	private async requestPreview<T>(
+		provider: Provider | undefined,
+		token: GitHubTokenInfo,
+		route: string,
+		options: RequestParameters | undefined,
+		scope: ScopedLogger | undefined,
+		cancellation?: AbortSignal | undefined,
+	): Promise<T> {
+		return (await this.requestCore(provider, token, route, options, scope, cancellation)) as T;
+	}
+
+	private async requestCore(
+		provider: Provider | undefined,
+		token: GitHubTokenInfo,
+		route: string,
+		options: RequestParameters | undefined,
+		scope: ScopedLogger | undefined,
+		cancellation?: AbortSignal | undefined,
+	): Promise<unknown> {
 		const { accessToken } = token;
 		try {
 			let signal: AbortSignal | undefined;
@@ -3320,15 +3443,15 @@ export class GitHubApi {
 			// Retry transient gateway/network failures on idempotent reads only
 			const method = route.split(' ', 1)[0].toUpperCase();
 			const retryable = method === 'GET' || method === 'HEAD';
-			return (await this.requestWithRetries(
+			return await this.requestWithRetries(
 				() =>
 					this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () =>
-						this.getDefaults(accessToken, request)(route as string, options),
+						this.getDefaults(accessToken, request)(route, options),
 					),
 				retryable,
 				signal,
 				scope,
-			)) as Endpoints[R]['response'];
+			);
 		} catch (ex) {
 			if (ex instanceof RequestError || ex.name === 'AbortError') {
 				this.handleRequestError(provider, token, ex, scope);
@@ -3620,6 +3743,7 @@ export class GitHubApi {
 			nodes {
 				...on PullRequest {
 					${options?.summary ? gqlPullRequestLiteFragment : gqlPullRequestFragment}
+					${gqlPullRequestStackFragmentFor(options)}
 				}
 			}
 		}
@@ -4503,6 +4627,7 @@ export class GitHubApi {
 				nodes {
 					... on PullRequest {
 						${gqlPullRequestFragment}
+						${gqlPullRequestStackFragmentFor(options)}
 					}
 				}
 			}`,
@@ -4655,6 +4780,7 @@ export class GitHubApi {
 		nodes {
 			...on PullRequest {
 				${gqlPullRequestFragment}
+				${gqlPullRequestStackFragmentFor(options)}
 			}
 		}
 	}
@@ -4714,6 +4840,164 @@ export class GitHubApi {
 		}
 	}
 
+	/**
+	 * Every stack in the repository, each with its members bottom to top.
+	 *
+	 * One request regardless of how many pull requests are involved — which is what makes it the right
+	 * shape for list surfaces, whose pull requests arrive through the shared providers API and so carry no
+	 * stack membership of their own. Callers join the result by pull request number.
+	 *
+	 * A `404` means the repository isn't enrolled in the stacked-pull-requests preview; that's reported as
+	 * `undefined` rather than an error, since "no stacks" and "not available" both mean nothing to show.
+	 */
+	@trace({
+		args: (provider, token, owner, repo) => ({
+			provider: provider.name,
+			token: `<token:${token.microHash}>`,
+			owner: owner,
+			repo: repo,
+		}),
+	})
+	async getRepositoryStacks(
+		provider: Provider,
+		token: GitHubTokenInfo,
+		owner: string,
+		repo: string,
+		options?: { baseUrl?: string },
+		cancellation?: AbortSignal,
+	): Promise<GitHubStackResource[] | undefined> {
+		const scope = getScopedLogger();
+
+		try {
+			const rsp = await this.requestPreview<{ data: GitHubStackResource[] }>(
+				provider,
+				token,
+				'GET /repos/{owner}/{repo}/stacks',
+				{ owner: owner, repo: repo, baseUrl: options?.baseUrl },
+				scope,
+				cancellation,
+			);
+
+			return rsp.data;
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+
+			Logger.warn(scope, `Unable to list stacks for ${owner}/${repo}: ${ex}`);
+			return undefined;
+		}
+	}
+
+	/**
+	 * Merges a stacked pull request, and with it every layer below it.
+	 *
+	 * Stacks cannot go through `mergePullRequest` — GitHub rejects stacked pull requests on the legacy
+	 * synchronous merge endpoints and mutations. The replacement is asynchronous: submit, then poll a
+	 * ticket until it reaches a terminal state.
+	 */
+	@trace({
+		args: (provider, token, owner, repo, pullNumber, expectedSourceSha) => ({
+			provider: provider.name,
+			token: `<token:${token.microHash}>`,
+			owner: owner,
+			repo: repo,
+			pullNumber: pullNumber,
+			expectedSourceSha: expectedSourceSha,
+		}),
+	})
+	async mergeStackedPullRequest(
+		provider: Provider,
+		token: GitHubTokenInfo,
+		owner: string,
+		repo: string,
+		pullNumber: number,
+		expectedSourceSha: string,
+		options?: { mergeMethod?: PullRequestMergeMethod; baseUrl?: string },
+		cancellation?: AbortSignal,
+	): Promise<boolean> {
+		const scope = getScopedLogger();
+
+		try {
+			let uuid: string | undefined;
+
+			try {
+				const submitted = await this.requestPreview<{ data: GitHubAsyncMergeResult }>(
+					provider,
+					token,
+					'PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge-async',
+					{
+						owner: owner,
+						repo: repo,
+						pull_number: pullNumber,
+						sha: expectedSourceSha,
+						merge_method: options?.mergeMethod,
+						baseUrl: options?.baseUrl,
+					},
+					scope,
+					cancellation,
+				);
+
+				// Already merged or rejected outright — nothing to poll for. `enqueued` lands via the merge
+				// queue, which can take several merge groups to settle, so it's transitional like `pending`.
+				if (submitted.data.status !== 'pending' && submitted.data.status !== 'enqueued') {
+					if (submitted.data.status === 'failed') {
+						Logger.warn(
+							scope,
+							`Stacked merge refused: ${submitted.data.details?.message ?? 'no reason given'}`,
+						);
+					}
+					return submitted.data.status === 'merged';
+				}
+
+				uuid = submitted.data.details?.uuid;
+			} catch (ex) {
+				// A merge request is already in flight (a retry, or a double-click) — adopt its ticket and
+				// poll that instead of reporting a failure for a merge that is actually running.
+				uuid = getAsyncMergeUuidFromConflict(ex);
+				if (uuid == null) throw ex;
+			}
+
+			if (uuid == null) return false;
+
+			// The stack merges server-side one layer at a time, so this can take a while. Poll on a
+			// fixed interval and give up rather than hang forever if the ticket never settles.
+			for (let attempt = 0; attempt < maxAsyncMergePolls; attempt++) {
+				if (cancellation?.aborted) throw new CancellationError();
+
+				await new Promise(resolve => setTimeout(resolve, asyncMergePollIntervalMs));
+
+				const polled = await this.requestPreview<{ data: GitHubAsyncMergeResult }>(
+					provider,
+					token,
+					'GET /repos/{owner}/{repo}/pulls/{pull_number}/merge-async/{uuid}',
+					{
+						owner: owner,
+						repo: repo,
+						pull_number: pullNumber,
+						uuid: uuid,
+						baseUrl: options?.baseUrl,
+					},
+					scope,
+					cancellation,
+				);
+
+				if (polled.data.status === 'pending' || polled.data.status === 'enqueued') continue;
+
+				if (polled.data.status === 'failed') {
+					Logger.warn(scope, `Stacked merge failed: ${polled.data.details?.message ?? 'no reason given'}`);
+				}
+				return polled.data.status === 'merged';
+			}
+
+			Logger.warn(scope, `Timed out waiting for stacked merge of ${owner}/${repo}#${pullNumber}`);
+			return false;
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+
+			Logger.error(ex, scope);
+			throw this.handleException(ex, provider, scope);
+		}
+	}
+
 	@trace({
 		args: (provider, token, nodeId, expectedSourceSha) => ({
 			provider: provider.name,
@@ -4732,7 +5016,7 @@ export class GitHubApi {
 	): Promise<boolean> {
 		const scope = getScopedLogger();
 		interface QueryResult {
-			pullRequest: GitHubPullRequestLite | null | undefined;
+			mergePullRequest: { pullRequest: { id: string } | null | undefined } | null | undefined;
 		}
 
 		let githubMergeStrategy;
@@ -4780,7 +5064,7 @@ export class GitHubApi {
 				cancellation,
 			);
 
-			return rsp?.pullRequest?.id === nodeId;
+			return rsp?.mergePullRequest?.pullRequest?.id === nodeId;
 		} catch (ex) {
 			throw this.handleException(ex, provider, scope);
 		}

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

@@ -2,7 +2,7 @@ import type { Endpoints } from '@octokit/types';
 import { GitFileIndexStatus } from '../../git/models/fileStatus.js';
 import type { IssueLabel } from '../../git/models/issue.js';
 import { Issue, RepositoryAccessLevel } from '../../git/models/issue.js';
-import type { PullRequestMember, PullRequestState } from '../../git/models/pullRequest.js';
+import type { PullRequestMember, PullRequestStackInfo, PullRequestState } from '../../git/models/pullRequest.js';
 import {
 	PullRequest,
 	PullRequestMergeableState,
@@ -165,6 +165,20 @@ export interface GitHubPullRequestLite extends Omit<GitHubIssueOrPullRequest, '_
 		url: string;
 		viewerPermission: GitHubViewerPermission;
 	};
+
+	/** Only selected against github.com — GitHub Enterprise Server schemas lag and reject the field. */
+	stack?: GitHubPullRequestStack | null;
+	/** Only selected against github.com — see `stack`. */
+	stackEntry?: { position: number } | null;
+}
+
+/** GitHub's stacked-pull-request object. Read-only; all stack mutations are REST-only. */
+export interface GitHubPullRequestStack {
+	id: string;
+	number: number;
+	size: number;
+	/** The branch the bottom of the stack targets — the stack's trunk. */
+	baseRefName: string;
 }
 
 export interface GitHubIssue extends Omit<GitHubIssueOrPullRequest, '__typename'> {
@@ -206,6 +220,7 @@ export interface GitHubPullRequest extends GitHubPullRequestLite {
 	assignees: {
 		nodes: GitHubMember[];
 	};
+	changedFiles: number;
 	checksUrl: string;
 	deletions: number;
 	mergeable: GitHubPullRequestMergeableState;
@@ -226,6 +241,7 @@ export interface GitHubPullRequest extends GitHubPullRequestLite {
 		}[];
 	};
 	commits: {
+		totalCount: number;
 		nodes: {
 			commit: {
 				statusCheckRollup: {
@@ -250,7 +266,13 @@ export type GitHubViewerPermission =
 function fromGitHubMemberOrGhost(member: GitHubMember | null | undefined): PullRequestMember {
 	if (member == null) return { id: 'ghost', name: 'ghost' };
 
-	return { id: member.login, name: member.login, avatarUrl: member.avatarUrl, url: member.url };
+	return {
+		id: member.login,
+		name: member.login,
+		username: member.login,
+		avatarUrl: member.avatarUrl,
+		url: member.url,
+	};
 }
 
 export function fromGitHubPullRequestLite(pr: GitHubPullRequestLite, provider: Provider): PullRequest {
@@ -299,6 +321,7 @@ export function fromGitHubPullRequestLite(pr: GitHubPullRequestLite, provider: P
 			isCrossRepository: pr.isCrossRepository,
 		},
 		pr.isDraft,
+		// The lite fragment selects nothing between `isDraft` and `stack`.
 		undefined, // additions
 		undefined, // deletions
 		undefined, // commentsCount
@@ -310,10 +333,26 @@ export function fromGitHubPullRequestLite(pr: GitHubPullRequestLite, provider: P
 		undefined, // statusCheckRollupState
 		undefined, // project
 		undefined, // version
+		undefined, // commitCount
+		fromGitHubPullRequestStack(pr),
+		undefined, // filesChanged
 		pr.body ?? undefined,
 	);
 }
 
+/** Both fields are absent on GitHub Enterprise Server (never selected) and `null` when unstacked. */
+function fromGitHubPullRequestStack(pr: GitHubPullRequestLite): PullRequestStackInfo | undefined {
+	if (pr.stack == null || pr.stackEntry == null) return undefined;
+
+	return {
+		id: pr.stack.id,
+		number: pr.stack.number,
+		size: pr.stack.size,
+		position: pr.stackEntry.position,
+		baseRef: pr.stack.baseRefName,
+	};
+}
+
 export function fromGitHubIssueOrPullRequestState(state: GitHubPullRequestState): PullRequestState {
 	return state === 'MERGED' ? 'merged' : state === 'CLOSED' ? 'closed' : 'opened';
 }
@@ -482,6 +521,7 @@ export function fromGitHubPullRequest(pr: GitHubPullRequest, provider: Provider)
 							reviewer: {
 								id: r.requestedReviewer.login,
 								name: r.requestedReviewer.login,
+								username: r.requestedReviewer.login,
 								avatarUrl: r.requestedReviewer.avatarUrl,
 								url: r.requestedReviewer.url,
 							},
@@ -498,12 +538,16 @@ export function fromGitHubPullRequest(pr: GitHubPullRequest, provider: Provider)
 		pr.assignees.nodes.map(r => ({
 			id: r.login,
 			name: r.login,
+			username: r.login,
 			avatarUrl: r.avatarUrl,
 			url: r.url,
 		})),
 		fromGitHubPullRequestStatusCheckRollupState(pr.commits.nodes?.[0]?.commit.statusCheckRollup?.state),
 		undefined, // project
 		undefined, // version
+		pr.commits.totalCount,
+		fromGitHubPullRequestStack(pr),
+		pr.changedFiles,
 		pr.body ?? undefined,
 	);
 }
@@ -529,12 +573,14 @@ export function fromGitHubIssue(value: GitHubIssue, provider: Provider): Issue {
 			: {
 					id: value.author.login,
 					name: value.author.login,
+					username: value.author.login,
 					avatarUrl: value.author.avatarUrl,
 					url: value.author.url,
 				},
 		value.assignees.nodes.map(assignee => ({
 			id: assignee.login,
 			name: assignee.login,
+			username: assignee.login,
 			avatarUrl: assignee.avatarUrl,
 			url: assignee.url,
 		})),

package/src/plus/git-github/providers/github/status.ts

@@ -44,6 +44,7 @@ export class StatusGitSubProvider implements GitStatusSubProvider {
 			unstaged?: boolean;
 			untracked?: boolean;
 			throwOnError?: boolean;
+			priority?: GitCommandPriority;
 		},
 		_cancellation?: AbortSignal,
 	): Promise<boolean> {

package/src/plus/integrations/context.ts

@@ -155,6 +155,10 @@ export interface IntegrationCacheProvider {
 		cacheable: Cacheable<Account>,
 		options?: CacheExpiryOptions & { connectionId?: string; etag?: string },
 	): CacheResult<Account>;
+	/** Evicts every cached pull request. A merge invalidates more than the merged pull request alone —
+	 *  a stacked merge lands every layer below it and retargets every layer above — and no caller can
+	 *  name that full set. */
+	deletePullRequests(): void;
 }
 
 /**

package/src/plus/integrations/index.ts

@@ -73,6 +73,8 @@ const uncachedIntegrationCacheProvider: IntegrationCacheProvider = {
 	getIssueOrPullRequest: (_id, _type, _resource, _integration, loader) => loadUncached(loader),
 	getIssue: (_id, _resource, _integration, loader) => loadUncached(loader),
 	getCurrentAccount: (_integration, loader) => loadUncached(loader),
+	// Nothing is cached, so there is nothing to evict.
+	deletePullRequests: () => {},
 };
 
 function toIntegrationCacheProvider(cache: IntegrationManagerCacheProvider | undefined): IntegrationCacheProvider {

package/src/plus/integrations/models/gitHostIntegration.ts

@@ -7,11 +7,13 @@ import type {
 	PullRequest,
 	PullRequestMergeMethod,
 	PullRequestSearchCriteria,
+	PullRequestStackInfo,
 	PullRequestStateFilter,
 } from '../../../git/models/pullRequest.js';
 import type { RepositoryMetadata } from '../../../git/models/repositoryMetadata.js';
 import type { ResourceDescriptor } from '../../../git/models/resourceDescriptor.js';
 import type { PullRequestUrlIdentity } from '../../../git/utils/pullRequest.utils.js';
+import { isCancellationError } from '../../../utils/cancellation.js';
 import { gate } from '../../../utils/decorators/gate.js';
 import { trace } from '../../../utils/decorators/log.js';
 import { first } from '../../../utils/iterable.js';
@@ -267,6 +269,14 @@ export abstract class GitHostIntegration<
 		connectionId?: string;
 	}): Promise<ProviderRepository | undefined>;
 
+	/** Stack membership for every stacked pull request in the repository, keyed by pull request number.
+	 *  Only hosts with a stacks concept implement this (currently GitHub). */
+	getStacksByPullRequestNumber?(
+		owner: string,
+		repo: string,
+		cancellation?: AbortSignal,
+	): Promise<Map<number, PullRequestStackInfo> | undefined>;
+
 	protected abstract getProviderDefaultBranch(
 		{ accessToken }: ProviderAuthenticationSession,
 		repo: T,
@@ -514,7 +524,11 @@ export abstract class GitHostIntegration<
 		options?: { cursor?: string },
 	): Promise<ProviderHierarchyResult<ProviderRepository> | undefined>;
 
-	async mergePullRequest(pr: PullRequest, options?: { mergeMethod?: PullRequestMergeMethod }): Promise<boolean> {
+	async mergePullRequest(
+		pr: PullRequest,
+		options?: { mergeMethod?: PullRequestMergeMethod },
+		cancellation?: AbortSignal,
+	): Promise<boolean> {
 		const scope = getScopedLogger();
 
 		const connected = this.maybeConnected ?? (await this.isConnected());
@@ -523,12 +537,20 @@ export abstract class GitHostIntegration<
 		await this.refreshSessionIfExpired(scope);
 
 		try {
-			const result = await this.mergeProviderPullRequest(this._session!, pr, options);
+			const result = await this.mergeProviderPullRequest(this._session!, pr, options, cancellation);
 			this.resetRequestExceptionCount('mergePullRequest');
 			return result;
 		} catch (ex) {
+			if (isCancellationError(ex)) return false;
+
 			this.handleProviderException('mergePullRequest', ex, { scope: scope });
 			return false;
+		} finally {
+			// A merge attempt just changed the state of more than this pull request on the server (a
+			// stacked merge lands every layer below and retargets every layer above) whether it succeeded
+			// or failed partway through — so cached pull requests can't be trusted either way. Without
+			// this, ref pills and branch enrichment keep serving the pre-merge object until its expiry.
+			this.ctx.cache.deletePullRequests();
 		}
 	}
 
@@ -536,6 +558,7 @@ export abstract class GitHostIntegration<
 		session: ProviderAuthenticationSession,
 		pr: PullRequest,
 		options?: { mergeMethod?: PullRequestMergeMethod },
+		cancellation?: AbortSignal,
 	): Promise<boolean>;
 
 	@trace()