@henryqw/pi-pr 4.0.2 → 4.0.4

package/extensions/pr-github.ts

@@ -15,7 +15,6 @@ import type {
 	PullRequestLifecycle,
 	PullRequestTarget,
 	ReviewReadiness,
-	PolicyReadiness,
 } from "./pr-routing.ts";
 
 const EXEC_TIMEOUT_MS = 10_000;
@@ -27,7 +26,6 @@ const PR_PUBLICATION_FIELDS = "number,url,state,baseRefName,headRefName,headRefO
 const PR_DISCOVERY_QUERY = "query($owner:String!,$name:String!,$qualifiedName:String!,$endCursor:String){repository(owner:$owner,name:$name){nameWithOwner ref(qualifiedName:$qualifiedName){name associatedPullRequests(first:100,after:$endCursor){totalCount edges{cursor node{__typename number url state baseRepository{nameWithOwner}headRepository{nameWithOwner}headRefName headRefOid}}pageInfo{hasNextPage startCursor endCursor}}}}}";
 const REVIEW_THREADS_QUERY = "query($id:ID!,$endCursor:String){node(id:$id){...on PullRequest{reviewThreads(first:100,after:$endCursor){nodes{isResolved}pageInfo{hasNextPage endCursor}}}}}";
 const BASE_REF_QUERY = "query($owner:String!,$name:String!,$qualifiedName:String!){repository(owner:$owner,name:$name){nameWithOwner ref(qualifiedName:$qualifiedName){name target{oid}}}}";
-const BASE_BRANCH_POLICY_QUERY = "query($owner:String!,$name:String!,$qualifiedName:String!){repository(owner:$owner,name:$name){nameWithOwner ref(qualifiedName:$qualifiedName){name branchProtectionRule{requiresStrictStatusChecks}}}}";
 const OID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
 const FAILED_CHECK_STATES = new Set([
 	"ACTION_REQUIRED",
@@ -60,7 +58,6 @@ const MERGE_STATE_VALUES = new Set([
 	"UNSTABLE",
 ]);
 const REVIEW_DECISION_VALUES = new Set(["APPROVED", "CHANGES_REQUESTED", "REVIEW_REQUIRED"]);
-const MERGE_METHODS: MergeMethod[] = ["merge", "rebase", "squash"];
 
 export class PullRequestLoadError extends Error {
 	constructor(message: string) {
@@ -75,13 +72,6 @@ export type PullRequestRef = {
 	oid: string;
 };
 
-export type MergeMethod = "merge" | "rebase" | "squash";
-
-export type PullRequestMerge = {
-	allowedMergeMethods: MergeMethod[];
-	viewerDefaultMergeMethod: MergeMethod;
-};
-
 export type CurrentPullRequest = PullRequest & {
 	id: string;
 	number: number;
@@ -92,7 +82,6 @@ export type CurrentPullRequest = PullRequest & {
 	head: PullRequestRef;
 	headFetchSource: string;
 	target: PullRequestTarget;
-	merge: PullRequestMerge | null;
 };
 
 export type CurrentPullRequestDiscovery = PullRequestDiscovery<CurrentPullRequest>;
@@ -105,6 +94,24 @@ export type PullRequestObservation = {
 
 export type PullRequestLoadContext = Pick<ExtensionContext, "cwd" | "signal">;
 
+export type PullRequestCreationPreflight = {
+	head: string;
+	base: {
+		host: string;
+		repository: string;
+		fetchSource: string;
+		ref: string;
+		oid: string;
+		mergeBase: string;
+	};
+	ahead: number;
+};
+
+type CreationIdentity = {
+	target: PullRequestTarget;
+	head: string;
+};
+
 type CommandOutput = {
 	stdout: string;
 	stderr: string;
@@ -187,6 +194,11 @@ export type BranchUpstreamTarget = {
 	remoteOid: string;
 };
 
+export type BranchUpstreamConfiguration = {
+	remote: string[];
+	merge: string[];
+};
+
 type SearchSelection =
 	| { kind: "candidate"; candidate: SearchPullRequest; pullRequest: ListedPullRequest | null }
 	| { kind: "none" }
@@ -202,11 +214,6 @@ type SearchPage = {
 	endCursor: string | null;
 };
 
-type RulesetBranchPolicy = {
-	requiresStrictStatusChecks: boolean;
-	allowedMergeMethods: MergeMethod[] | null;
-};
-
 type CheckState = {
 	state: string;
 	diagnosableFailure: boolean;
@@ -332,6 +339,12 @@ function parseCommandOutput(value: unknown, action: string): CommandOutput {
 	return { stdout, stderr, code, killed };
 }
 
+function hasExactKeys(value: Record<string, unknown>, keys: string[]): boolean {
+	const actual = Object.keys(value).sort();
+	const expected = [...keys].sort();
+	return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+
 async function invoke(
 	pi: Pick<ExtensionAPI, "exec">,
 	context: PullRequestLoadContext,
@@ -865,7 +878,6 @@ function ciStatus(checks: CheckState[]): CiStatus {
 function conditions(
 	candidate: ListedPullRequest,
 	unresolvedThreads: number,
-	requiresStrictStatusChecks: boolean,
 ): PullRequestConditions {
 	if (
 		(candidate.mergeable === "MERGEABLE" && candidate.mergeStateStatus === "DIRTY") ||
@@ -875,19 +887,17 @@ function conditions(
 		? "pending"
 		: "ready";
 	const behind = candidate.mergeStateStatus === "BEHIND";
-	const policy: PolicyReadiness = candidate.mergeable === "MERGEABLE" &&
-		(candidate.mergeStateStatus === "CLEAN" || (behind && !requiresStrictStatusChecks))
-		? "ready"
-		: "pending";
 	return {
 		draft: candidate.isDraft,
-		baseUpdateRequired: behind && requiresStrictStatusChecks,
+		baseUpdateRequired: behind,
 		conflict: candidate.mergeable === "CONFLICTING" || candidate.mergeStateStatus === "DIRTY",
 		changesRequested: candidate.reviewDecision === "CHANGES_REQUESTED",
 		unresolvedThreads,
 		ci: ciStatus(candidate.checkStates),
 		review,
-		policy,
+		policy: candidate.mergeable === "MERGEABLE" && candidate.mergeStateStatus === "CLEAN"
+			? "ready"
+			: "pending",
 	};
 }
 
@@ -954,102 +964,6 @@ function parseBaseRefOid(output: string, candidate: ListedPullRequest): string {
 	return parseBaseRefAuthority(output, candidate.base);
 }
 
-function parseLegacyBaseBranchPolicy(output: string, candidate: ListedPullRequest): boolean {
-	const value = parseJson(output, "Read base branch policy");
-	if (!isRecord(value)) fail("Read base branch policy", "invalid GitHub CLI output");
-	if (value.errors !== undefined) {
-		if (!Array.isArray(value.errors)) fail("Read base branch policy", "invalid GitHub CLI output");
-		if (value.errors.length) fail("Read base branch policy", "GitHub GraphQL returned errors");
-	}
-	const repository = isRecord(value.data) ? value.data.repository : undefined;
-	if (!isRecord(repository) || !isRecord(repository.ref)) {
-		fail("Read base branch policy", "invalid GitHub CLI output");
-	}
-	if (
-		normalizeRepository(repositoryName(repository.nameWithOwner, "Read base branch policy", "repository")) !==
-		normalizeRepository(candidate.base.repository) ||
-		text(repository.ref.name, "Read base branch policy", "ref") !== candidate.base.ref
-	) fail("Read base branch policy", "response does not match pull request base");
-	const rule = repository.ref.branchProtectionRule;
-	if (rule === null) return false;
-	if (!isRecord(rule) || typeof rule.requiresStrictStatusChecks !== "boolean") {
-		fail("Read base branch policy", "invalid GitHub CLI output");
-	}
-	return rule.requiresStrictStatusChecks;
-}
-
-function parseRulesetBaseBranchPolicy(output: string): RulesetBranchPolicy {
-	const pages = parseJson(output, "Read base branch rulesets");
-	if (!Array.isArray(pages) || !pages.length) fail("Read base branch rulesets", "invalid GitHub CLI output");
-	let requiresStrictStatusChecks = false;
-	let allowedMergeMethods: Set<MergeMethod> | null = null;
-	for (const page of pages) {
-		if (!Array.isArray(page)) fail("Read base branch rulesets", "invalid GitHub CLI output");
-		for (const rule of page) {
-			if (!isRecord(rule)) fail("Read base branch rulesets", "invalid GitHub CLI output");
-			const type = text(rule.type, "Read base branch rulesets", "rule type");
-			if (type === "required_status_checks") {
-				if (!isRecord(rule.parameters) || typeof rule.parameters.strict_required_status_checks_policy !== "boolean") {
-					fail("Read base branch rulesets", "invalid GitHub CLI output");
-				}
-				requiresStrictStatusChecks ||= rule.parameters.strict_required_status_checks_policy;
-			}
-			if (type === "pull_request") {
-				if (!isRecord(rule.parameters) || !Array.isArray(rule.parameters.allowed_merge_methods)) {
-					fail("Read base branch rulesets", "invalid GitHub CLI output");
-				}
-				const methods = rule.parameters.allowed_merge_methods;
-				if (
-					methods.some((method) => typeof method !== "string" || !MERGE_METHODS.includes(method as MergeMethod)) ||
-					new Set(methods).size !== methods.length
-				) fail("Read base branch rulesets", "invalid GitHub CLI output");
-				const restriction = new Set<MergeMethod>(methods as MergeMethod[]);
-				allowedMergeMethods = allowedMergeMethods === null
-					? restriction
-					: new Set<MergeMethod>([...allowedMergeMethods].filter((method: MergeMethod) => restriction.has(method)));
-			}
-		}
-	}
-	return {
-		requiresStrictStatusChecks,
-		allowedMergeMethods: allowedMergeMethods === null
-			? null
-			: MERGE_METHODS.filter((method) => allowedMergeMethods.has(method)),
-	};
-}
-
-function parseMergeMethodSettings(output: string, rulesetMethods: MergeMethod[] | null): PullRequestMerge {
-	const value = parseJson(output, "Read merge methods");
-	if (!isRecord(value)) fail("Read merge methods", "invalid GitHub CLI output");
-	const { mergeCommitAllowed, rebaseMergeAllowed, squashMergeAllowed } = value;
-	if (
-		typeof mergeCommitAllowed !== "boolean" || typeof rebaseMergeAllowed !== "boolean" ||
-		typeof squashMergeAllowed !== "boolean"
-	) fail("Read merge methods", "invalid GitHub CLI output");
-	let allowedMergeMethods: MergeMethod[] = [];
-	if (mergeCommitAllowed) allowedMergeMethods.push("merge");
-	if (rebaseMergeAllowed) allowedMergeMethods.push("rebase");
-	if (squashMergeAllowed) allowedMergeMethods.push("squash");
-	if (!allowedMergeMethods.length) fail("Read merge methods", "repository allows no merge method");
-	const viewerDefaultMergeMethod = value.viewerDefaultMergeMethod === "MERGE"
-		? "merge"
-		: value.viewerDefaultMergeMethod === "REBASE"
-		? "rebase"
-		: value.viewerDefaultMergeMethod === "SQUASH"
-		? "squash"
-		: fail("Read merge methods", "invalid viewerDefaultMergeMethod");
-	if (!allowedMergeMethods.includes(viewerDefaultMergeMethod)) {
-		fail("Read merge methods", "viewerDefaultMergeMethod is not allowed");
-	}
-	if (rulesetMethods !== null) {
-		allowedMergeMethods = allowedMergeMethods.filter((method) => rulesetMethods.includes(method));
-	}
-	if (!allowedMergeMethods.length) {
-		fail("Read merge methods", "repository and applicable rules allow no common merge method");
-	}
-	return { allowedMergeMethods, viewerDefaultMergeMethod };
-}
-
 export async function hasLocalCommit(
 	pi: Pick<ExtensionAPI, "exec">,
 	context: PullRequestLoadContext,
@@ -1073,6 +987,234 @@ export async function hasLocalCommit(
 	return commits[0] !== commits.at(-1);
 }
 
+function validatedCreationTarget(target: PullRequestTarget): PullRequestTarget {
+	if (!isRecord(target)) fail("Read creation target", "invalid target");
+	if (target.provenance !== "configured" && target.provenance !== "inferred") {
+		fail("Read creation target", "invalid provenance");
+	}
+	return {
+		provenance: target.provenance,
+		branch: text(target.branch, "Read creation target", "branch"),
+		remote: text(target.remote, "Read creation target", "remote"),
+		ref: text(target.ref, "Read creation target", "ref"),
+		repository: repositoryName(target.repository, "Read creation target", "repository"),
+		host: text(target.host, "Read creation target", "host").toLowerCase(),
+		fetchSource: text(target.fetchSource, "Read creation target", "fetch source"),
+		remoteOid: target.remoteOid === null ? null : oid(target.remoteOid, "Read creation target", "remote OID"),
+	};
+}
+
+function sameCreationTarget(left: PullRequestTarget, right: PullRequestTarget): boolean {
+	return left.provenance === right.provenance && left.branch === right.branch &&
+		left.remote === right.remote && left.ref === right.ref &&
+		normalizeRepository(left.repository) === normalizeRepository(right.repository) &&
+		left.host === right.host && left.fetchSource === right.fetchSource && left.remoteOid === right.remoteOid;
+}
+
+async function validateCreationRef(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	ref: string,
+): Promise<string> {
+	const requested = text(ref, "Validate creation base", "ref");
+	const checked = singleLine(
+		(await execute(pi, context, "Validate creation base", "git", ["check-ref-format", "--branch", requested])).stdout,
+		"Validate creation base",
+		"ref",
+	);
+	if (checked !== requested) fail("Validate creation base", "ref changed");
+	return requested;
+}
+
+async function captureCreationIdentity(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	target: PullRequestTarget,
+): Promise<CreationIdentity> {
+	const validatedTarget = validatedCreationTarget(target);
+	const branch = singleLine(
+		(await execute(pi, context, "Read creation branch", "git", ["branch", "--show-current"])).stdout,
+		"Read creation branch",
+		"branch",
+	);
+	if (branch !== validatedTarget.branch) fail("Read creation branch", "branch changed");
+	await validateCreationRef(pi, context, branch);
+	const head = oid(singleLine(
+		(await execute(pi, context, "Read creation HEAD", "git", ["rev-parse", "--verify", "HEAD^{commit}"])).stdout,
+		"Read creation HEAD",
+		"OID",
+	), "Read creation HEAD", "OID");
+	return { target: validatedTarget, head };
+}
+
+async function readConfiguredCreationBaseRef(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	branch: string,
+): Promise<string | null> {
+	const result = await invoke(pi, context, "Read creation base configuration", "git", [
+		"config", "--get-all", `branch.${branch}.gh-merge-base`,
+	]);
+	if (result.killed) commandFailure("Read creation base configuration", result);
+	if (result.code === 1 && result.stdout === "" && result.stderr === "") return null;
+	if (result.code !== 0) commandFailure("Read creation base configuration", result);
+	if (result.stderr !== "") fail("Read creation base configuration", "unexpected diagnostic");
+	const values = lines(result.stdout, "Read creation base configuration", "base ref");
+	if (values.length !== 1) fail("Read creation base configuration", "multiple base refs");
+	return await validateCreationRef(pi, context, values[0]!);
+}
+
+function parseDefaultCreationBaseRef(output: string): string {
+	const value = parseJson(output, "Read creation default branch");
+	if (!isRecord(value) || !hasExactKeys(value, ["defaultBranchRef"]) || !isRecord(value.defaultBranchRef) ||
+		!hasExactKeys(value.defaultBranchRef, ["name"])) {
+		fail("Read creation default branch", "invalid GitHub CLI output");
+	}
+	return text(value.defaultBranchRef.name, "Read creation default branch", "default branch ref");
+}
+
+async function readDefaultCreationBaseRef(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	origin: { repository: PushRepository },
+): Promise<string> {
+	const result = await execute(pi, context, "Read creation default branch", "gh", [
+		"repo", "view", `${origin.repository.host}/${origin.repository.nameWithOwner}`, "--json", "defaultBranchRef",
+	]);
+	if (result.stderr !== "") fail("Read creation default branch", "unexpected diagnostic");
+	return await validateCreationRef(pi, context, parseDefaultCreationBaseRef(result.stdout));
+}
+
+function parseCreationRepositoryLineage(output: string, expected: PushRepository): string {
+	const value = parseJson(output, "Read creation repository");
+	if (!isRecord(value)) fail("Read creation repository", "invalid GitHub CLI output");
+	const fullName = repositoryName(value.full_name, "Read creation repository", "full_name");
+	const url = parseHttpUrl(value.html_url, "Read creation repository", "html_url");
+	if (
+		normalizeRepository(fullName) !== expected.normalizedName || url.protocol !== "https:" || url.port ||
+		url.hostname.toLowerCase() !== expected.host || url.pathname.toLowerCase() !== `/${expected.normalizedName}`
+	) fail("Read creation repository", "response does not match repository");
+	const source = value.source;
+	if (source !== undefined && source !== null && !isRecord(source)) {
+		fail("Read creation repository", "invalid source");
+	}
+	const sourceName = source === undefined || source === null
+		? fullName
+		: repositoryName(source.full_name, "Read creation repository", "source.full_name");
+	return normalizeRepository(sourceName);
+}
+
+async function assertCreationRepositoryRelation(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	target: PullRequestTarget,
+	origin: { repository: PushRepository },
+	baseRef: string,
+): Promise<void> {
+	if (target.host !== origin.repository.host) {
+		fail("Read creation repository", "base and head hosts do not match");
+	}
+	if (normalizeRepository(target.repository) === origin.repository.normalizedName) {
+		if (target.ref === baseRef) fail("Read creation repository", "head and base refs match");
+		return;
+	}
+	const read = async (repository: PushRepository): Promise<string> => {
+		const [owner, name] = repository.nameWithOwner.split("/");
+		const result = await execute(pi, context, "Read creation repository", "gh", [
+			"api", "--hostname", origin.repository.host, `repos/${owner}/${name}`,
+		]);
+		if (result.stderr !== "") fail("Read creation repository", "unexpected diagnostic");
+		return parseCreationRepositoryLineage(result.stdout, repository);
+	};
+	const originSource = await read(origin.repository);
+	const targetSource = await read({
+		nameWithOwner: target.repository,
+		normalizedName: normalizeRepository(target.repository),
+		host: target.host,
+	});
+	if (originSource !== targetSource) fail("Read creation repository", "base and head are unrelated");
+}
+
+function parseCreationAhead(output: string): number {
+	const value = singleLine(output, "Count creation commits", "ahead count");
+	if (!/^(?:0|[1-9][0-9]*)$/.test(value)) fail("Count creation commits", "invalid ahead count");
+	const ahead = Number(value);
+	if (!Number.isSafeInteger(ahead) || ahead < 0) fail("Count creation commits", "invalid ahead count");
+	return ahead;
+}
+
+async function preflightCreation(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	target: PullRequestTarget,
+	explicitBaseRef: string | undefined,
+	identity: CreationIdentity,
+): Promise<PullRequestCreationPreflight> {
+	const validatedTarget = validatedCreationTarget(target);
+	if (!sameCreationTarget(identity.target, validatedTarget)) {
+		fail("Read creation target", "target changed");
+	}
+	const origin = await readRemoteAuthority(pi, context, "origin", true);
+	if (!origin) fail("Read creation repository", "origin is unavailable");
+	const configuredBaseRef = explicitBaseRef === undefined
+		? await readConfiguredCreationBaseRef(pi, context, identity.target.branch)
+		: await validateCreationRef(pi, context, explicitBaseRef);
+	const baseRef = configuredBaseRef ?? await readDefaultCreationBaseRef(pi, context, origin);
+	await assertCreationRepositoryRelation(pi, context, identity.target, origin, baseRef);
+	const trackingRef = `refs/remotes/origin/${baseRef}`;
+	await execute(pi, context, "Fetch creation base", "git", [
+		"fetch", "--no-write-fetch-head", "--no-tags", "--no-recurse-submodules", "--",
+		origin.fetchSource, `+refs/heads/${baseRef}:${trackingRef}`,
+	]);
+	const baseOid = oid(singleLine(
+		(await execute(pi, context, "Read creation base", "git", ["rev-parse", "--verify", `${trackingRef}^{commit}`])).stdout,
+		"Read creation base",
+		"OID",
+	), "Read creation base", "OID");
+	const mergeBase = oid(singleLine(
+		(await execute(pi, context, "Find creation merge base", "git", ["merge-base", identity.head, baseOid])).stdout,
+		"Find creation merge base",
+		"OID",
+	), "Find creation merge base", "OID");
+	const ahead = parseCreationAhead((await execute(pi, context, "Count creation commits", "git", [
+		"rev-list", "--count", `${mergeBase}..${identity.head}`,
+	])).stdout);
+	return {
+		head: identity.head,
+		base: {
+			host: origin.repository.host,
+			repository: origin.repository.nameWithOwner,
+			fetchSource: origin.fetchSource,
+			ref: baseRef,
+			oid: baseOid,
+			mergeBase,
+		},
+		ahead,
+	};
+}
+
+export async function preflightPullRequestCreation(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	target: PullRequestTarget,
+	explicitBaseRef?: string,
+): Promise<PullRequestCreationPreflight> {
+	const identity = await captureCreationIdentity(pi, context, target);
+	return await preflightCreation(pi, context, target, explicitBaseRef, identity);
+}
+
+async function creationDiscovery(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	target: PullRequestTarget,
+	explicitBaseRef: string | undefined,
+	identity?: CreationIdentity,
+): Promise<CurrentPullRequestDiscovery> {
+	const captured = identity ?? await captureCreationIdentity(pi, context, target);
+	const preflight = await preflightCreation(pi, context, target, explicitBaseRef, captured);
+	return { kind: "none", creationTarget: target, branch: { ahead: preflight.ahead } };
+}
+
 async function readRemoteAuthority(
 	pi: Pick<ExtensionAPI, "exec">,
 	context: PullRequestLoadContext,
@@ -1167,6 +1309,22 @@ async function readConfigValues(
 	}
 }
 
+export async function readBranchUpstreamConfiguration(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	branch: string,
+): Promise<BranchUpstreamConfiguration> {
+	const checkedBranch = text(branch, "Read branch upstream", "branch");
+	const [remote, merge] = await Promise.all([
+		readConfigValues(pi, context, `branch.${checkedBranch}.remote`),
+		readConfigValues(pi, context, `branch.${checkedBranch}.merge`),
+	]);
+	if (remote === null || merge === null) {
+		throw new Error("Read branch upstream failed: invalid Git configuration");
+	}
+	return { remote, merge };
+}
+
 async function readBooleanConfigValues(
 	pi: Pick<ExtensionAPI, "exec">,
 	context: PullRequestLoadContext,
@@ -1440,66 +1598,6 @@ export async function readPullRequestBaseRefOid(
 	return parseBaseRefAuthority(result.stdout, { repository, ref });
 }
 
-async function readLegacyBaseBranchPolicy(
-	pi: Pick<ExtensionAPI, "exec">,
-	context: PullRequestLoadContext,
-	candidate: ListedPullRequest,
-): Promise<boolean> {
-	const [owner, name] = candidate.base.repository.split("/");
-	const result = await execute(pi, context, "Read base branch policy", "gh", [
-		"api",
-		"graphql",
-		"--hostname",
-		candidate.url.hostname,
-		"-f",
-		`query=${BASE_BRANCH_POLICY_QUERY}`,
-		"-F",
-		`owner=${owner}`,
-		"-F",
-		`name=${name}`,
-		"-F",
-		`qualifiedName=refs/heads/${candidate.base.ref}`,
-	]);
-	return parseLegacyBaseBranchPolicy(result.stdout, candidate);
-}
-
-async function readRulesetBaseBranchPolicy(
-	pi: Pick<ExtensionAPI, "exec">,
-	context: PullRequestLoadContext,
-	candidate: ListedPullRequest,
-): Promise<RulesetBranchPolicy> {
-	const [owner, name] = candidate.base.repository.split("/");
-	const result = await execute(pi, context, "Read base branch rulesets", "gh", [
-		"api",
-		"--hostname",
-		candidate.url.hostname,
-		"--paginate",
-		"--slurp",
-		"-H",
-		"Accept: application/vnd.github+json",
-		"-H",
-		"X-GitHub-Api-Version: 2022-11-28",
-		`repos/${owner}/${name}/rules/branches/${encodeURIComponent(candidate.base.ref)}`,
-	]);
-	return parseRulesetBaseBranchPolicy(result.stdout);
-}
-
-async function readMergeMethods(
-	pi: Pick<ExtensionAPI, "exec">,
-	context: PullRequestLoadContext,
-	candidate: ListedPullRequest,
-	rulesetMethods: MergeMethod[] | null,
-): Promise<PullRequestMerge> {
-	const result = await execute(pi, context, "Read merge methods", "gh", [
-		"repo",
-		"view",
-		`${candidate.url.hostname}/${candidate.base.repository}`,
-		"--json",
-		"mergeCommitAllowed,rebaseMergeAllowed,squashMergeAllowed,viewerDefaultMergeMethod",
-	]);
-	return parseMergeMethodSettings(result.stdout, rulesetMethods);
-}
-
 async function loadPullRequestDetails(
 	pi: Pick<ExtensionAPI, "exec">,
 	context: PullRequestLoadContext,
@@ -1518,17 +1616,7 @@ async function loadPullRequestDetails(
 	const liveBaseOid = candidate.lifecycle === "open"
 		? await readBaseRefOid(pi, context, candidate)
 		: null;
-	const rulesetPolicy = candidate.lifecycle === "open"
-		? await readRulesetBaseBranchPolicy(pi, context, candidate)
-		: null;
-	const legacyStrict = candidate.lifecycle === "open" && candidate.mergeStateStatus === "BEHIND"
-		? await readLegacyBaseBranchPolicy(pi, context, candidate)
-		: false;
-	const requiresStrictStatusChecks = legacyStrict || (rulesetPolicy?.requiresStrictStatusChecks ?? false);
-	const pullRequestConditions = conditions(candidate, unresolvedThreads, requiresStrictStatusChecks);
-	const merge = candidate.lifecycle === "open"
-		? await readMergeMethods(pi, context, candidate, rulesetPolicy?.allowedMergeMethods ?? null)
-		: null;
+	const pullRequestConditions = conditions(candidate, unresolvedThreads);
 	const inspected = inspectedLocal ?? await inspectLocalMergeSafety({
 		exec: (command, args, options) => pi.exec(command, args, {
 			...options,
@@ -1553,7 +1641,6 @@ async function loadPullRequestDetails(
 		head: candidate.head,
 		headFetchSource: pushTarget.fetchSource,
 		target: publicTarget(pushTarget),
-		merge,
 	};
 }
 
@@ -1694,6 +1781,18 @@ export async function loadCurrentPullRequest(
 	context: PullRequestLoadContext,
 	inspectedLocal?: LocalMergeSafety,
 	observed?: unknown,
+	explicitCreationBase?: string,
+): Promise<CurrentPullRequestDiscovery> {
+	return await loadCurrentPullRequestInternal(pi, context, inspectedLocal, observed, explicitCreationBase);
+}
+
+async function loadCurrentPullRequestInternal(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	inspectedLocal: LocalMergeSafety | undefined,
+	observed: unknown,
+	explicitCreationBase: string | undefined,
+	creationIdentity?: CreationIdentity,
 ): Promise<CurrentPullRequestDiscovery> {
 	const read = await readPushTarget(pi, context);
 	if (read.kind === "inactive") return { kind: "inactive" };
@@ -1714,10 +1813,18 @@ export async function loadCurrentPullRequest(
 			};
 		}
 		if (inferred.kind === "none") {
+			const target = publicTarget(inferred.target);
+			if (creationIdentity === undefined) {
+				const captured = await captureCreationIdentity(pi, context, target);
+				return await loadCurrentPullRequestInternal(pi, context, inspectedLocal, observed, explicitCreationBase, captured);
+			}
+			if (!sameCreationTarget(creationIdentity.target, validatedCreationTarget(target))) {
+				fail("Read creation target", "target changed");
+			}
 			if (!canLinkTarget(await readLinkConfiguration(pi, context, inferred.target), inferred.target)) {
 				return { kind: "blocked", issue: { kind: "link-configuration", remote: inferred.target.remote } };
 			}
-			return { kind: "none", creationTarget: publicTarget(inferred.target) };
+			return await creationDiscovery(pi, context, target, explicitCreationBase, creationIdentity);
 		}
 		pushTarget = inferred.target;
 	} else {
@@ -1814,7 +1921,10 @@ export async function loadCurrentPullRequest(
 			}
 			throw error;
 		}
-		if (candidate === null) return { kind: "none", creationTarget: publicTarget(pushTarget) };
+		if (candidate === null) {
+			if (creationIdentity !== undefined) fail("Read creation target", "target changed");
+			return await creationDiscovery(pi, context, publicTarget(pushTarget), explicitCreationBase);
+		}
 	}
 
 	return {
@@ -1942,6 +2052,42 @@ function sameConfigValues(left: readonly string[], right: readonly string[]): bo
 	return left.length === right.length && left.every((value, index) => value === right[index]);
 }
 
+export async function restoreBranchUpstreamConfiguration(
+	pi: Pick<ExtensionAPI, "exec">,
+	context: PullRequestLoadContext,
+	target: Pick<BranchUpstreamTarget, "branch" | "remote" | "ref">,
+	original: BranchUpstreamConfiguration,
+): Promise<void> {
+	let incomplete = false;
+	for (const [key, expected, values] of [
+		[`branch.${target.branch}.remote`, target.remote, original.remote],
+		[`branch.${target.branch}.merge`, `refs/heads/${target.ref}`, original.merge],
+	] as const) {
+		try {
+			const current = await readConfigValues(pi, context, key);
+			if (current === null) incomplete = true;
+			else if (sameConfigValues(current, values)) continue;
+			else if (current.length === 1 && current[0] === expected) {
+				await restoreConfigValue(pi, context, key, expected, values);
+			} else incomplete = true;
+		} catch {
+			incomplete = true;
+		}
+	}
+	for (const [key, values] of [
+		[`branch.${target.branch}.remote`, original.remote],
+		[`branch.${target.branch}.merge`, original.merge],
+	] as const) {
+		try {
+			const current = await readConfigValues(pi, context, key);
+			if (current === null || !sameConfigValues(current, values)) incomplete = true;
+		} catch {
+			incomplete = true;
+		}
+	}
+	if (incomplete) throw new Error("Restore branch upstream failed and rollback was incomplete");
+}
+
 async function restoreLinkState(
 	pi: Pick<ExtensionAPI, "exec">,
 	context: PullRequestLoadContext,