@henryqw/pi-pr 4.0.3 → 4.0.5

package/README.md

@@ -72,9 +72,9 @@ Each footer entry is one linked `PR #number` plus one plain-language status: `N
 | External check or commit status failed | Show `CI failed` as a no-action blocker. |
 | Changes requested or unresolved review threads | Run the package comment sweep when the same local prerequisite holds. |
 | No-action state | Report the state without taking action. |
-| Merge-ready pull request | Ask for final confirmation, recheck fresh state, and merge directly if confirmed. |
+| Merge-ready pull request | Ask for final confirmation, recheck fresh state, and squash-merge if confirmed. |
 
-`pi-pr-create` selects its base in this order: the leading `/pr --base BRANCH`, one `branch.<branch>.gh-merge-base` value, then the default branch of validated `origin`. It captures the selected base OID and merge-base. Creation requires at least one committed change ahead. Dirty work alone does not enable creation.
+`pi-pr-create` selects its base in this order: the leading `/pr --base BRANCH`, one `branch.<branch>.gh-merge-base` value, then the default branch of validated `origin`. It captures the selected base OID and merge-base. Creation requires at least one committed change ahead. Dirty work alone does not enable creation. If the current branch is the selected base, pi-pr stays silent because GitHub cannot create a pull request from a ref to itself.
 
 The base always comes from validated `origin`. The head may use that repository or a fork with the same GitHub source. Base and head must use the same GitHub host. Other fork relationships stop before mutation.
 
@@ -154,8 +154,8 @@ The GitHub response must match the observed URL, host, repository, head ref, hea
 - It does not rebase the local branch, overwrite concurrent remote updates, delete branches, or clean up worktrees. Creation uses exact leases plus ancestry checks; an empty lease is only an atomic absence check.
 - Creation, discovery, and comment-sweep pushes require one unambiguous push URL for the configured destination.
 - Presentation fetches use that exact push URL and exact advertised OID. They do not use shared fetch state.
-- Strict status checks in legacy branch protection or applicable repository rulesets require a base update.
-- Applicable ruleset restrictions intersect repository-wide merge methods. An empty intersection stops the workflow.
+- A pull request that GitHub reports as behind requires a base update.
+- Direct merges always use squash. GitHub rejects the mutation if repository policy does not allow it.
 - Before merge, `/pr` fetches the exact head OID from the validated push URL without shared fetch state.
 - A merge, rebase, cherry-pick, revert, or sequencer state blocks direct merge, even when `git status` is empty.
 - A branch update resolves the base repository ref directly. It stops if that ref moves before merge or push.

package/extensions/pr-ci.ts

@@ -149,7 +149,6 @@ function cloneAuthority(value: CurrentPullRequest): CurrentPullRequest {
 		base: { ...value.base },
 		head: { ...value.head },
 		target: { ...value.target },
-		merge: value.merge ? { ...value.merge, allowedMergeMethods: [...value.merge.allowedMergeMethods] } : null,
 	};
 }
 

package/extensions/pr-command.ts

@@ -2,10 +2,7 @@ import type {
 	ExtensionAPI,
 	ExtensionCommandContext,
 } from "@earendil-works/pi-coding-agent";
-import {
-	executeGitHubMerge,
-	selectMergeMethod,
-} from "./pr-merge.ts";
+import { executeGitHubMerge } from "./pr-merge.ts";
 import {
 	linkInferredPullRequest,
 	loadCurrentPullRequest,
@@ -184,11 +181,9 @@ async function mergePullRequest(
 	current: CurrentPullRequest,
 	load: typeof loadCurrentPullRequest,
 ): Promise<boolean> {
-	if (!current.merge) throw new Error(`PR #${current.number} merge failed: merge capabilities are unavailable`);
-	const method = selectMergeMethod(current.merge);
 	const confirmed = await ctx.ui.confirm(
 		`Merge PR #${current.number}?`,
-		`Method: ${method}.`,
+		"Method: squash.",
 	);
 	if (!confirmed) return false;
 
@@ -204,8 +199,6 @@ async function mergePullRequest(
 		expectedHead: current.head.oid,
 		expectedBase: current.base,
 		headFetchSource: current.headFetchSource,
-		allowedMergeMethods: current.merge.allowedMergeMethods,
-		viewerDefaultMergeMethod: current.merge.viewerDefaultMergeMethod,
 		revalidateReadiness: async (local) => {
 			const discovery = await load(pi, ctx, local);
 			if (discovery.kind !== "current") {
@@ -218,11 +211,6 @@ async function mergePullRequest(
 			if (deriveNextStep(discovery) !== "merge") {
 				throw new Error(`PR #${fresh.number} merge cancelled: pull request is no longer merge-ready`);
 			}
-			if (!fresh.merge) throw new Error(`PR #${fresh.number} merge failed: merge capabilities are unavailable`);
-			const freshMethod = selectMergeMethod(fresh.merge);
-			if (freshMethod !== method) {
-				throw new Error(`PR #${fresh.number} merge cancelled: merge method changed from ${method} to ${freshMethod}`);
-			}
 		},
 	});
 	return true;

package/extensions/pr-comment-sweep.ts

@@ -42,10 +42,6 @@ import {
 	type ExecOptions,
 } from "./pr-execution.ts";
 
-export const PR_COMMENT_SWEEP_ACTIONS = [
-	"start", "resume", "show", "record", "publish", "refresh", "resolve", "finalize",
-] as const;
-export type PrCommentSweepAction = (typeof PR_COMMENT_SWEEP_ACTIONS)[number];
 export const SWEEP_RECOVERY_MAX_BYTES = 1024 * 1024;
 
 const STATE_VERSION = 1;
@@ -140,16 +136,6 @@ export type PullRequestCommentSweepOptions = {
 	newRunId?: () => string;
 	pause?: (milliseconds: number) => Promise<void>;
 };
-export type PrCommentSweepRequest =
-	| { action: "start" }
-	| { action: "resume" }
-	| { action: "show"; guard: SweepRunGuard; id: string }
-	| { action: "record"; guard: SweepRunGuard; ledger: SweepLedgerEntry[]; ownedPaths?: string[] }
-	| { action: "publish"; guard: SweepRunGuard }
-	| { action: "refresh"; guard: SweepRunGuard }
-	| { action: "resolve"; guard: SweepRunGuard; threadIds: string[] }
-	| { action: "finalize"; guard: SweepRunGuard; projection: SweepFinalProjection; checks: SweepCheck[] };
-
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -1086,17 +1072,4 @@ export class PullRequestCommentSweep {
 			return { kind: "finalized", pullRequestUrl: state.authority.url, head: state.publicationHead, checks: checks.length };
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
-
-	async action(request: PrCommentSweepRequest): Promise<SweepStatus | FeedbackItem | { kind: "finalized"; pullRequestUrl: string; head: string; checks: number }> {
-		switch (request.action) {
-			case "start": return await this.start();
-			case "resume": return await this.resume();
-			case "show": return await this.show(request.guard, request.id);
-			case "record": return await this.record(request.guard, request.ledger, request.ownedPaths);
-			case "publish": return await this.publish(request.guard);
-			case "refresh": return await this.refresh(request.guard);
-			case "resolve": return await this.resolve(request.guard, request.threadIds);
-			case "finalize": return await this.finalize(request.guard, request.projection, request.checks);
-		}
-	}
 }

package/extensions/pr-create.ts

@@ -6,14 +6,11 @@ import {
 	loadCurrentPullRequest,
 	loadPullRequestPublication,
 	preflightPullRequestCreation,
-	readBranchUpstreamConfiguration,
 	readPullRequestBaseRefOid,
 	readTrackingOid,
 	readValidatedRemoteAuthority,
-	restoreBranchUpstreamConfiguration,
 	setBranchUpstream,
 	verifyBranchUpstream,
-	type BranchUpstreamConfiguration,
 	type BranchUpstreamTarget,
 	type PullRequestLoadContext,
 	type PullRequestPublication,
@@ -31,7 +28,6 @@ import {
 	runChecked,
 	spawnBounded,
 	withWorktreeLock,
-	type AttemptState,
 	type Exec,
 	type ExecOptions,
 } from "./pr-execution.ts";
@@ -61,22 +57,11 @@ type CrossRepositoryCreateAuthority = {
 
 export type CreatePullRequestState = {
 	phase: CreatePhase;
-	attempts: {
-		fetchBase: AttemptState;
-		merge: AttemptState;
-		stage: AttemptState;
-		continueMerge: AttemptState;
-		push: AttemptState;
-		fetchTracking: AttemptState;
-		setUpstream: AttemptState;
-		pullRequest: AttemptState;
-	};
 	base?: CreateBaseAuthority;
 	createAuthority?: CrossRepositoryCreateAuthority;
 	mergeHead?: string;
 	publicationHead?: string;
 	conflict?: { paths: string[]; statusBaseline: string; originalHead: string };
-	originalUpstream?: BranchUpstreamConfiguration;
 	url?: string;
 };
 
@@ -102,11 +87,6 @@ function sameTarget(left: PullRequestTarget, right: PullRequestTarget, expectedR
 		left.fetchSource === right.fetchSource && right.remoteOid === expectedRemoteOid;
 }
 
-function sameUpstreamConfiguration(left: BranchUpstreamConfiguration, right: BranchUpstreamConfiguration): boolean {
-	return left.remote.length === right.remote.length && left.remote.every((value, index) => value === right.remote[index]) &&
-		left.merge.length === right.merge.length && left.merge.every((value, index) => value === right.merge[index]);
-}
-
 function line(output: string, label: string): string {
 	const normalized = output.replace(/\r\n/g, "\n");
 	const values = normalized.endsWith("\n") ? normalized.slice(0, -1).split("\n") : normalized.split("\n");
@@ -198,17 +178,12 @@ function resolvedPaths(paths: readonly string[], expected: readonly string[]): s
 }
 
 export class PullRequestCreator {
-	readonly state: CreatePullRequestState = {
-		phase: "unprepared",
-		attempts: {
-			fetchBase: "none", merge: "none", stage: "none", continueMerge: "none", push: "none",
-			fetchTracking: "none", setUpstream: "none", pullRequest: "none",
-		},
-	};
+	readonly state: CreatePullRequestState = { phase: "unprepared" };
 
 	private readonly cwd: string;
 	private readonly target: PullRequestTarget;
 	private readonly noTarget: boolean;
+	private noTargetUpstreamConfigured = false;
 	private readonly signal?: AbortSignal;
 	private readonly agentDir?: string;
 	private readonly exec: Exec;
@@ -283,7 +258,7 @@ export class PullRequestCreator {
 	}
 
 	async prepare(explicitBase?: string): Promise<CreatePullRequestResult> {
-		if (this.state.phase !== "unprepared" || this.state.attempts.fetchBase !== "none") {
+		if (this.state.phase !== "unprepared") {
 			throw new Error("PR creation prepare action was already consumed");
 		}
 		return await withWorktreeLock(this.cwd, async () => {
@@ -306,17 +281,11 @@ export class PullRequestCreator {
 				oid: base.oid,
 				fetchSource: base.fetchSource,
 			};
-			this.state.attempts.fetchBase = "attempting";
-			try {
-				await runChecked(this.exec, "git", [
-					"fetch", "--no-write-fetch-head", "--no-tags", "--no-recurse-submodules", base.fetchSource, base.oid,
-				], this.options());
-				await runChecked(this.exec, "git", ["cat-file", "-e", `${base.oid}^{commit}`], this.options());
-				this.state.attempts.fetchBase = "applied";
-			} catch (error) {
-				this.state.attempts.fetchBase = "unknown";
-				throw error;
-			}
+			this.state.phase = "blocked";
+			await runChecked(this.exec, "git", [
+				"fetch", "--no-write-fetch-head", "--no-tags", "--no-recurse-submodules", base.fetchSource, base.oid,
+			], this.options());
+			await runChecked(this.exec, "git", ["cat-file", "-e", `${base.oid}^{commit}`], this.options());
 			await this.freshNone();
 			if (await readHead(this.exec, this.options()) !== preflight.head) {
 				throw new Error("PR creation cancelled: local HEAD changed during prepare");
@@ -358,7 +327,7 @@ export class PullRequestCreator {
 	}
 
 	async merge(): Promise<CreatePullRequestResult> {
-		if (this.state.phase !== "prepared" || !this.state.base || this.state.attempts.merge !== "none") {
+		if (this.state.phase !== "prepared" || !this.state.base) {
 			throw new Error("PR creation is not prepared for merge");
 		}
 		return await withWorktreeLock(this.cwd, async () => {
@@ -370,35 +339,17 @@ export class PullRequestCreator {
 				this.state.mergeHead = originalHead;
 				return { kind: "verified", head: originalHead, fastForward: false };
 			}
-			this.state.attempts.merge = "attempting";
-			let result;
-			try {
-				result = await this.exec("git", ["merge", "--no-edit", this.state.base!.oid], this.options());
-			} catch (error) {
-				this.state.attempts.merge = "unknown";
-				throw error;
-			}
-			if (result.killed) {
-				this.state.attempts.merge = "unknown";
-				throw new Error("git merge was killed; its outcome is unknown");
-			}
+			this.state.phase = "blocked";
+			const result = await this.exec("git", ["merge", "--no-edit", this.state.base!.oid], this.options());
+			if (result.killed) throw new Error("git merge was killed; its outcome is unknown");
 			if (result.code === 0) {
-				try {
-					const verified = await this.verifyMerge(originalHead);
-					this.state.attempts.merge = "applied";
-					return { kind: "verified", ...verified };
-				} catch (error) {
-					this.state.attempts.merge = "unknown";
-					throw error;
-				}
+				const verified = await this.verifyMerge(originalHead);
+				return { kind: "verified", ...verified };
 			}
 			try {
 				const paths = await this.captureConflict(originalHead);
-				this.state.attempts.merge = "applied";
 				return { kind: "conflict", paths };
 			} catch (error) {
-				this.state.attempts.merge = "blocked";
-				this.state.phase = "blocked";
 				throw new Error(`git merge failed: ${result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`}; ${error instanceof Error ? error.message : String(error)}`);
 			}
 		}, { agentDir: this.agentDir, signal: this.signal });
@@ -408,9 +359,6 @@ export class PullRequestCreator {
 		if (this.state.phase !== "conflict-awaiting-user" || !this.state.conflict || !this.state.base) {
 			throw new Error("PR creation has no conflict awaiting continuation");
 		}
-		if (this.state.attempts.stage !== "none" || this.state.attempts.continueMerge !== "none") {
-			throw new Error("PR creation conflict continuation was already consumed");
-		}
 		const paths = resolvedPaths(pathsInput, this.state.conflict.paths);
 		return await withWorktreeLock(this.cwd, async () => {
 			await this.freshNone();
@@ -420,94 +368,34 @@ export class PullRequestCreator {
 			if (mergeHead !== this.state.base!.oid) throw new Error("PR creation merge context changed");
 			const status = await runChecked(this.exec, "git", ["status", "--porcelain=v2", "-z", "--untracked-files=all"], this.options());
 			assertOnlyDeclaredStatusChanged(this.state.conflict!.statusBaseline, status.stdout, paths);
-			this.state.attempts.stage = "attempting";
-			try {
-				await runChecked(this.exec, "git", ["add", "--", ...paths], this.options());
-				this.state.attempts.stage = "applied";
-			} catch (error) {
-				this.state.attempts.stage = "unknown";
-				throw error;
-			}
+			this.state.phase = "blocked";
+			await runChecked(this.exec, "git", ["add", "--", ...paths], this.options());
 			const unmerged = parseNulPaths((await runChecked(this.exec, "git", ["diff", "--name-only", "-z", "--diff-filter=U"], this.options())).stdout, "Unmerged paths");
 			if (unmerged.length) throw new Error(`Conflict paths remain unresolved: ${unmerged.join(", ")}`);
-			this.state.attempts.continueMerge = "attempting";
-			try {
-				await runChecked(this.exec, "git", ["-c", "core.editor=true", "merge", "--continue"], this.options());
-				const verified = await this.verifyMerge(this.state.conflict!.originalHead);
-				this.state.attempts.continueMerge = "applied";
-				return { kind: "verified", ...verified };
-			} catch (error) {
-				this.state.attempts.continueMerge = "unknown";
-				throw error;
-			}
+			await runChecked(this.exec, "git", ["-c", "core.editor=true", "merge", "--continue"], this.options());
+			const verified = await this.verifyMerge(this.state.conflict!.originalHead);
+			return { kind: "verified", ...verified };
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
 
-	private upstreamTarget(head: string): BranchUpstreamTarget {
-		return {
+	private async configureNoTargetUpstream(head: string): Promise<void> {
+		const target: BranchUpstreamTarget = {
 			branch: this.target.branch,
 			remote: this.target.remote,
 			ref: this.target.ref,
 			fetchSource: this.target.fetchSource,
 			remoteOid: head,
 		};
-	}
-
-	private async captureNoTargetUpstream(): Promise<void> {
-		if (!this.noTarget || this.state.originalUpstream !== undefined) return;
-		this.state.originalUpstream = await readBranchUpstreamConfiguration(this.pi(), this.context(), this.target.branch);
-	}
-
-	private async fetchNoTargetTracking(head: string): Promise<void> {
-		if (this.state.attempts.fetchTracking === "applied") return;
-		if (this.state.attempts.fetchTracking !== "none" && this.state.attempts.fetchTracking !== "unknown") {
-			throw new Error("PR creation tracking fetch cannot be retried");
-		}
-		const target = this.upstreamTarget(head);
-		this.state.attempts.fetchTracking = "attempting";
-		try {
-			await fetchBranchTrackingRef(this.pi(), this.context(), target);
-			if (await readTrackingOid(this.pi(), this.context(), branchTrackingRef(target)) !== head) {
-				throw new Error("Fetched tracking ref did not match published HEAD");
-			}
-			this.state.attempts.fetchTracking = "applied";
-		} catch (error) {
-			this.state.attempts.fetchTracking = "unknown";
-			throw error;
-		}
-	}
-
-	private async configureNoTargetUpstream(head: string): Promise<void> {
-		const original = this.state.originalUpstream;
-		if (!original) throw new Error("PR creation original branch upstream is unavailable");
-		if (!sameUpstreamConfiguration(
-			await readBranchUpstreamConfiguration(this.pi(), this.context(), this.target.branch),
-			original,
-		)) {
-			throw new Error("PR creation cancelled: branch upstream changed before setup");
-		}
-		await this.fetchNoTargetTracking(head);
-		const target = this.upstreamTarget(head);
-		this.state.attempts.setUpstream = "attempting";
-		try {
-			await setBranchUpstream(this.pi(), this.context(), target);
-			await verifyBranchUpstream(this.pi(), this.context(), target);
-			this.state.attempts.setUpstream = "applied";
-		} catch (error) {
-			this.state.attempts.setUpstream = "unknown";
-			const rollbackContext = { cwd: this.cwd, signal: new AbortController().signal };
-			try {
-				await restoreBranchUpstreamConfiguration(this.pi(), rollbackContext, target, original);
-			} catch {
-				this.state.phase = "blocked";
-				throw new Error("PR creation upstream setup failed and rollback was incomplete");
-			}
-			throw error;
+		await fetchBranchTrackingRef(this.pi(), this.context(), target);
+		if (await readTrackingOid(this.pi(), this.context(), branchTrackingRef(target)) !== head) {
+			throw new Error("Fetched tracking ref did not match published HEAD");
 		}
+		await setBranchUpstream(this.pi(), this.context(), target);
+		await verifyBranchUpstream(this.pi(), this.context(), target);
 	}
 
 	async push(): Promise<CreatePullRequestResult> {
-		if (this.state.phase !== "verified" || !this.state.base || this.state.attempts.push !== "none") {
+		if (this.state.phase !== "verified" || !this.state.base) {
 			throw new Error("PR creation is not ready to push");
 		}
 		return await withWorktreeLock(this.cwd, async () => {
@@ -525,31 +413,27 @@ export class PullRequestCreator {
 			await this.freshNone();
 			if (await this.liveBase() !== this.state.base!.oid) throw new Error("PR creation cancelled: frozen base moved");
 			if (await this.requireCleanHead() !== head) throw new Error("PR creation cancelled: local HEAD changed before push");
-			if (this.noTarget) await this.captureNoTargetUpstream();
 			this.state.publicationHead = head;
-			this.state.attempts.push = "attempting";
-			try {
-				await runChecked(this.exec, "git", [
-					"push", "--porcelain", `--force-with-lease=refs/heads/${this.target.ref}:${original ?? ""}`,
-					"--recurse-submodules=no", "--", this.target.fetchSource, `${head}:refs/heads/${this.target.ref}`,
-				], this.options());
-				if (await readRemoteOid(this.exec, this.options(), this.target.fetchSource, this.target.ref) !== head) {
-					throw new Error("Published remote ref did not match captured HEAD");
-				}
-				this.state.attempts.push = "applied";
-			} catch (error) {
-				this.state.attempts.push = "unknown";
-				throw error;
+			this.state.phase = "blocked";
+			await runChecked(this.exec, "git", [
+				"push", "--porcelain", `--force-with-lease=refs/heads/${this.target.ref}:${original ?? ""}`,
+				"--recurse-submodules=no", "--", this.target.fetchSource, `${head}:refs/heads/${this.target.ref}`,
+			], this.options());
+			if (await readRemoteOid(this.exec, this.options(), this.target.fetchSource, this.target.ref) !== head) {
+				throw new Error("Published remote ref did not match captured HEAD");
 			}
 			this.state.phase = "pushed";
-			if (this.noTarget) await this.fetchNoTargetTracking(head);
+			if (this.noTarget) {
+				await this.configureNoTargetUpstream(head);
+				this.noTargetUpstreamConfigured = true;
+			}
 			return { kind: "pushed", head };
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
 
 	private async publishedAuthority(): Promise<void> {
 		const head = this.state.publicationHead!;
-		if (this.noTarget && this.state.attempts.setUpstream !== "applied") {
+		if (this.noTarget && !this.noTargetUpstreamConfigured) {
 			const branch = line((await runChecked(this.exec, "git", ["branch", "--show-current"], this.options())).stdout, "current branch");
 			const authority = await readValidatedRemoteAuthority(this.pi(), this.context(), this.target.remote);
 			if (branch !== this.target.branch || authority.host !== this.target.host ||
@@ -587,16 +471,9 @@ export class PullRequestCreator {
 	}
 
 	async publish(titleInput: string, body: string): Promise<CreatePullRequestResult> {
-		const retryingUpstream = this.noTarget && this.state.attempts.pullRequest === "applied";
-		if (
-			this.state.phase !== "pushed" || !this.state.base || !this.state.publicationHead ||
-			(this.state.attempts.pullRequest !== "none" && !retryingUpstream)
-		) {
+		if (this.state.phase !== "pushed" || !this.state.base || !this.state.publicationHead) {
 			throw new Error("PR creation is not ready to publish metadata");
 		}
-		if (this.noTarget && !this.state.originalUpstream) {
-			throw new Error("PR creation original branch upstream is unavailable");
-		}
 		const title = requiredText(titleInput, "pull request title");
 		if (Buffer.byteLength(title, "utf8") > MAX_TITLE_BYTES) throw new Error(`Pull request title exceeds ${MAX_TITLE_BYTES} bytes`);
 		if (typeof body !== "string" || body.includes("\0") || Buffer.byteLength(body, "utf8") > MAX_BODY_BYTES) {
@@ -609,63 +486,42 @@ export class PullRequestCreator {
 			if (before && (before.base.repository.toLowerCase() !== this.state.base!.repository.toLowerCase() || before.base.ref !== this.state.base!.ref)) {
 				throw new Error("Exact-head pull request targets a different base");
 			}
-			let after: PullRequestPublication;
-			if (retryingUpstream) {
-				if (!before || before.title !== title || before.body !== body) {
-					throw new Error("Published pull request changed before upstream completion");
-				}
-				after = before;
-			} else {
-				const repository = `${this.state.base!.host}/${this.state.base!.repository}`;
-				const sameRepository = this.state.base!.repository.toLowerCase() === this.target.repository.toLowerCase();
-				const organizationAuthority = !sameRepository && this.state.createAuthority?.headOwnerType === "Organization"
-					? this.state.createAuthority
-					: undefined;
-				if (!sameRepository && !this.state.createAuthority) {
-					throw new Error("Cross-repository PR creation was not preflighted before push");
-				}
-				const args = before
-					? ["pr", "edit", String(before.number), "--repo", repository, "--title", title, "--body-file", "-"]
-					: organizationAuthority
-					? [
-						"api", "graphql", "--hostname", this.state.base!.host,
-						"-f", `query=${CREATE_PULL_REQUEST_MUTATION}`,
-						"-f", `repositoryId=${organizationAuthority.baseRepositoryId}`,
-						"-f", `baseRefName=${this.state.base!.ref}`,
-						"-f", `headRepositoryId=${organizationAuthority.headRepositoryId}`,
-						"-f", `headRefName=${this.target.ref}`,
-						"-f", `title=${title}`,
-						"-f", `body=${body}`,
-					]
-					: [
-						"pr", "create", "--repo", repository, "--head",
-						sameRepository ? this.target.ref : `${this.target.repository.split("/")[0]}:${this.target.ref}`,
-						"--base", this.state.base!.ref, "--title", title, "--body-file", "-",
-					];
-				this.state.attempts.pullRequest = "attempting";
-				try {
-					const created = await runChecked(this.exec, "gh", args, this.options({ stdin: organizationAuthority ? undefined : body }));
-					if (!before && organizationAuthority) {
-						parseCreatedUrl(created.stdout, this.state.base!.host, this.state.base!.repository);
-					}
-				} catch (error) {
-					this.state.attempts.pullRequest = "unknown";
-					throw error;
-				}
-				try {
-					const refreshed = await this.exactCandidate();
-					if (!refreshed || refreshed.base.repository.toLowerCase() !== this.state.base!.repository.toLowerCase() ||
-						refreshed.base.ref !== this.state.base!.ref || refreshed.title !== title || refreshed.body !== body) {
-						throw new Error("Published pull request did not retain canonical identity, title, and body");
-					}
-					after = refreshed;
-					this.state.attempts.pullRequest = "applied";
-				} catch (error) {
-					this.state.attempts.pullRequest = "unknown";
-					throw error;
-				}
+			const repository = `${this.state.base!.host}/${this.state.base!.repository}`;
+			const sameRepository = this.state.base!.repository.toLowerCase() === this.target.repository.toLowerCase();
+			const organizationAuthority = !sameRepository && this.state.createAuthority?.headOwnerType === "Organization"
+				? this.state.createAuthority
+				: undefined;
+			if (!sameRepository && !this.state.createAuthority) {
+				throw new Error("Cross-repository PR creation was not preflighted before push");
+			}
+			const args = before
+				? ["pr", "edit", String(before.number), "--repo", repository, "--title", title, "--body-file", "-"]
+				: organizationAuthority
+				? [
+					"api", "graphql", "--hostname", this.state.base!.host,
+					"-f", `query=${CREATE_PULL_REQUEST_MUTATION}`,
+					"-f", `repositoryId=${organizationAuthority.baseRepositoryId}`,
+					"-f", `baseRefName=${this.state.base!.ref}`,
+					"-f", `headRepositoryId=${organizationAuthority.headRepositoryId}`,
+					"-f", `headRefName=${this.target.ref}`,
+					"-f", `title=${title}`,
+					"-f", `body=${body}`,
+				]
+				: [
+					"pr", "create", "--repo", repository, "--head",
+					sameRepository ? this.target.ref : `${this.target.repository.split("/")[0]}:${this.target.ref}`,
+					"--base", this.state.base!.ref, "--title", title, "--body-file", "-",
+				];
+			this.state.phase = "blocked";
+			const created = await runChecked(this.exec, "gh", args, this.options({ stdin: organizationAuthority ? undefined : body }));
+			if (!before && organizationAuthority) {
+				parseCreatedUrl(created.stdout, this.state.base!.host, this.state.base!.repository);
+			}
+			const after = await this.exactCandidate();
+			if (!after || after.base.repository.toLowerCase() !== this.state.base!.repository.toLowerCase() ||
+				after.base.ref !== this.state.base!.ref || after.title !== title || after.body !== body) {
+				throw new Error("Published pull request did not retain canonical identity, title, and body");
 			}
-			if (this.noTarget) await this.configureNoTargetUpstream(this.state.publicationHead!);
 			this.state.phase = "published";
 			this.state.url = after.url.href;
 			return { kind: "published", url: after.url.href };