@henryqw/pi-pr 4.0.2 → 4.0.3

package/README.md

@@ -42,11 +42,11 @@ GitHub, use the network, or write files.
 
 Run `/pr` in a GitHub checkout. It reads fresh pull request and local state, then runs one route. The PR hostname selects its GitHub API host, and the extension works outside Herdr.
 
-Creation accepts one optional base anchor. Use `/pr --base=<host>/<owner>/<repository>:<ref>`. All other route instructions fail instead of being ignored.
+For creation, put an optional base branch first. For example, run `/pr --base release/2026 Keep the title concise.` The base is a branch name, not a host or repository. Only creation accepts the base and remaining guidance. Other routes reject them instead of ignoring them.
 
 | Surface | Type | Purpose |
 | --- | --- | --- |
-| `/pr [--base=<host>/<owner>/<repository>:<ref>]` | command | Run the current pull request's next safe route. |
+| `/pr [--base BRANCH] [creation instructions]` | command | Run the current pull request's next safe route. |
 | Footer | ui | Show a linked `PR #number` and one plain-language status. |
 | Widget | ui | Show one action hint or transient routing status. |
 
@@ -64,7 +64,7 @@ Each footer entry is one linked `PR #number` plus one plain-language status: `N
 
 | Current condition | `/pr` route |
 | --- | --- |
-| No current-branch pull request, no published matching ref, and safe Git push configuration | Start pull-request creation. |
+| No current-branch pull request, no published matching ref, safe Git push configuration, and a commit ahead of the selected base | Start pull-request creation. |
 | One open pull request inferred from a published matching ref | Confirm the exact `remote/ref`, then link the local branch. |
 | Ambiguous or unsafe discovery | Show the blocked reason and do not mutate Git or GitHub. |
 | Base update required or merge conflict | Update from the base branch's current target when the tree is clean and local HEAD equals the PR head. |
@@ -74,11 +74,13 @@ Each footer entry is one linked `PR #number` plus one plain-language status: `N
 | 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. |
 
-`pi-pr-create` accepts an anchored base from `/pr --base=...`. Otherwise, it finds one unique parent from validated `origin` refs and commit history. The parent can be a feature branch.
+`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.
 
-It merges the parent's captured commit before validation and push. It resolves clear conflicts and stops when the base or conflict intent is ambiguous.
+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.
 
-It honors an existing configured push target. Without one, it pushes a captured OID to the local branch ref on `origin` and sets upstream.
+It merges the captured base commit before validation and push. It resolves clear conflicts and stops when the base or conflict intent is ambiguous.
+
+A configured target never changes branch upstream settings. Without a target, the helper pushes the captured OID to the local branch ref on validated `origin` and fetches its tracking ref. It leaves upstream unset. It creates or updates and validates the exact PR before it sets and verifies upstream. A failed setup rolls back only unchanged helper-owned settings. If configuration changed concurrently, it stops without overwriting it. Retrying `publish` resumes setup without another push or PR mutation.
 
 Without a configured push target, discovery checks validated remotes for the same branch ref. One exact open PR becomes an inferred target. `/pr` names the exact `remote/ref` and asks before linking it. The extension revalidates the branch, PR, remote OID, and Git configuration before mutation. It rolls back its upstream and remote-tracking changes if final verification fails.
 
@@ -145,7 +147,7 @@ The GitHub response must match the observed URL, host, repository, head ref, hea
 
 ## Limits and recovery
 
-- `/pr` accepts only the optional anchored creation base described above. It does not open a browser.
+- `/pr` accepts creation syntax only as a leading `--base BRANCH`, followed by optional creation guidance. It does not open a browser.
 - It does not run `/done` or `/sweep`.
 - Polling does not auto-triage comments or start a workflow. The package comment sweep runs only when an explicit `/pr` selects it.
 - It does not enable auto-merge or add a merge queue.

package/extensions/pr-command.ts

@@ -26,8 +26,6 @@ const WORKFLOWS: Record<WorkflowNextStep, { command: string; action: string }> =
 	sweep: { command: "skill:pi-pr-comment-sweep", action: "start" },
 	"fix-ci": { command: "skill:pi-pr-fix-ci", action: "collect" },
 };
-const CREATE_BASE = /^--base=([a-z0-9](?:[a-z0-9.-]*[a-z0-9])?\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+:[^\s\0]+)$/;
-
 export type WorkflowReservation =
 	| { route: "create"; target: PullRequestTarget; base?: string }
 	| { route: Exclude<WorkflowNextStep, "create">; pullRequest: CurrentPullRequest };
@@ -62,21 +60,30 @@ export type PrCommandDependencies = {
 	releaseWorkflow?: (runId: string, invocation?: PrCommandInvocation) => void;
 };
 
-function createBase(instructions: string): string | undefined {
-	if (!instructions) return undefined;
-	const match = CREATE_BASE.exec(instructions);
-	if (!match) throw new Error("PR creation accepts only --base=<host>/<owner>/<repository>:<ref>");
-	return match[1]!;
+type ParsedPrArguments = {
+	base?: string;
+	instructions: string;
+};
+
+function parsePrArguments(args: string): ParsedPrArguments {
+	const leading = args.trimStart();
+	if (leading.startsWith("--base=")) throw new Error("/pr base syntax is --base <branch>");
+	if (!leading.startsWith("--base") || !/^--base(?:\s|$)/.test(leading)) {
+		return { instructions: args.trim() };
+	}
+	const value = /^--base\s+(\S+)/.exec(leading);
+	if (!value) throw new Error("/pr --base requires a branch");
+	return { base: value[1]!, instructions: leading.slice(value[0].length).trim() };
 }
 
 function workflowReservation(
 	nextStep: WorkflowNextStep,
 	discovery: Awaited<ReturnType<typeof loadCurrentPullRequest>>,
+	base: string | undefined,
 	instructions: string,
 ): WorkflowReservation {
 	if (nextStep === "create") {
 		if (discovery.kind !== "none") throw new Error("/pr create failed: creation target is unavailable");
-		const base = createBase(instructions);
 		return { route: "create", target: discovery.creationTarget, ...(base === undefined ? {} : { base }) };
 	}
 	if (instructions) throw new Error("The current /pr helper route does not accept instructions");
@@ -104,6 +111,7 @@ async function dispatchWorkflow(
 	reserve: NonNullable<PrCommandDependencies["reserveWorkflow"]>,
 	markPromptQueued: NonNullable<PrCommandDependencies["markWorkflowPromptQueued"]>,
 	release: NonNullable<PrCommandDependencies["releaseWorkflow"]>,
+	instructions: string,
 ): Promise<void> {
 	const workflow = packageWorkflowCommand(pi, route);
 	let runId: string | undefined;
@@ -117,7 +125,7 @@ async function dispatchWorkflow(
 			? { deliverAs: "followUp" as const, expandPromptTemplates: true }
 			: { expandPromptTemplates: true };
 		invocation?.assertCurrent();
-		pi.sendUserMessage(`/${identity.skill} runId=${identity.runId} action=${identity.action}`, options);
+		pi.sendUserMessage(`/${identity.skill} runId=${identity.runId} action=${identity.action}${instructions ? ` ${instructions}` : ""}`, options);
 	} catch (error) {
 		if (runId !== undefined) release(runId, invocation);
 		throw error;
@@ -258,11 +266,14 @@ export function createPrCommandHandler(
 		const commandInvocation = onRouteResolved && "assertCurrent" in onRouteResolved
 			? onRouteResolved as PrCommandInvocation
 			: undefined;
-		const instructions = args.trim();
-		const discovery = await load(pi, ctx);
+		const { base, instructions } = parsePrArguments(args);
+		const discovery = await load(pi, ctx, undefined, undefined, base);
 		commandInvocation?.assertCurrent();
 		const nextStep = deriveNextStep(discovery);
 		onRouteResolved?.(nextStep);
+		if (base !== undefined && nextStep !== "create") {
+			throw new Error("/pr --base is accepted only for pull request creation");
+		}
 		if (instructions && !(nextStep in WORKFLOWS)) {
 			throw new Error("The current /pr route does not accept instructions");
 		}
@@ -289,8 +300,18 @@ export function createPrCommandHandler(
 
 		if (!(nextStep in WORKFLOWS)) throw new Error(`/pr cannot dispatch route ${nextStep}`);
 		const route = nextStep as WorkflowNextStep;
-		const reservation = workflowReservation(route, discovery, instructions);
-		await dispatchWorkflow(pi, ctx, route, reservation, commandInvocation, reserve, markPromptQueued, release);
+		const reservation = workflowReservation(route, discovery, base, instructions);
+		await dispatchWorkflow(
+			pi,
+			ctx,
+			route,
+			reservation,
+			commandInvocation,
+			reserve,
+			markPromptQueued,
+			release,
+			route === "create" ? instructions : "",
+		);
 		return nextStep;
 	};
 }

package/extensions/pr-create.ts

@@ -5,11 +5,15 @@ import {
 	findExactHeadPullRequests,
 	loadCurrentPullRequest,
 	loadPullRequestPublication,
+	preflightPullRequestCreation,
+	readBranchUpstreamConfiguration,
 	readPullRequestBaseRefOid,
 	readTrackingOid,
 	readValidatedRemoteAuthority,
+	restoreBranchUpstreamConfiguration,
 	setBranchUpstream,
 	verifyBranchUpstream,
+	type BranchUpstreamConfiguration,
 	type BranchUpstreamTarget,
 	type PullRequestLoadContext,
 	type PullRequestPublication,
@@ -24,7 +28,6 @@ import {
 	readRemoteOid,
 	requiredOid,
 	requiredText,
-	resolveRepositoryFetchSource,
 	runChecked,
 	spawnBounded,
 	withWorktreeLock,
@@ -33,8 +36,6 @@ import {
 	type ExecOptions,
 } from "./pr-execution.ts";
 
-const BASE_RERUN = "Rerun /pr --base=<host>/<owner>/<repository>:<ref>";
-const MAX_REMOTE_BRANCHES = 128;
 const MAX_TITLE_BYTES = 256;
 const MAX_BODY_BYTES = 64 * 1024;
 const CREATE_AUTHORITY_QUERY = "query($baseOwner:String!,$baseName:String!,$headOwner:String!,$headName:String!){base:repository(owner:$baseOwner,name:$baseName){id nameWithOwner}head:repository(owner:$headOwner,name:$headName){id nameWithOwner owner{__typename}}createInput:__type(name:\"CreatePullRequestInput\"){inputFields{name}}}";
@@ -75,6 +76,7 @@ export type CreatePullRequestState = {
 	mergeHead?: string;
 	publicationHead?: string;
 	conflict?: { paths: string[]; statusBaseline: string; originalHead: string };
+	originalUpstream?: BranchUpstreamConfiguration;
 	url?: string;
 };
 
@@ -100,6 +102,11 @@ 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");
@@ -107,16 +114,6 @@ function line(output: string, label: string): string {
 	return values[0];
 }
 
-function configuredValues(output: string): string[] {
-	if (output === "") return [];
-	const normalized = output.replace(/\r\n/g, "\n");
-	const values = normalized.endsWith("\n") ? normalized.slice(0, -1).split("\n") : normalized.split("\n");
-	if (values.some((value) => !value) || new Set(values).size !== values.length) {
-		throw new Error("Git configuration returned invalid values");
-	}
-	return values;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -191,14 +188,6 @@ function parseCreatedUrl(output: string, host: string, baseRepository: string):
 	return url;
 }
 
-function parseExplicitBase(value: string): Omit<CreateBaseAuthority, "oid" | "fetchSource"> {
-	const match = /^([a-z0-9](?:[a-z0-9.-]*[a-z0-9])?)\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+):(.+)$/.exec(value);
-	if (!match || match[2] === "." || match[2] === ".." || match[3] === "." || match[3] === "..") {
-		throw new Error(`Invalid base authority. ${BASE_RERUN}`);
-	}
-	return { host: match[1]!.toLowerCase(), repository: `${match[2]}/${match[3]}`, ref: requiredText(match[4], "base ref") };
-}
-
 function resolvedPaths(paths: readonly string[], expected: readonly string[]): string[] {
 	if (!Array.isArray(paths)) throw new TypeError("resolvedPaths must be an array");
 	const parsed = parseNulPaths(`${paths.join("\0")}${paths.length ? "\0" : ""}`, "Resolved conflict paths");
@@ -224,6 +213,7 @@ export class PullRequestCreator {
 	private readonly agentDir?: string;
 	private readonly exec: Exec;
 	private readonly load: Load;
+	private explicitBase?: string;
 
 	constructor(options: CreatePullRequestOptions) {
 		if (!options.target || options.target.remoteOid !== null && !requiredOid(options.target.remoteOid, "remote OID")) {
@@ -257,7 +247,7 @@ export class PullRequestCreator {
 	}
 
 	private async freshNone(): Promise<void> {
-		const discovery = await this.load(this.pi(), this.context());
+		const discovery = await this.load(this.pi(), this.context(), undefined, undefined, this.explicitBase);
 		if (discovery.kind !== "none" || !sameTarget(this.target, discovery.creationTarget)) {
 			throw new Error("PR creation cancelled: fresh complete discovery is no longer none");
 		}
@@ -265,71 +255,6 @@ export class PullRequestCreator {
 		if (branch !== this.target.branch) throw new Error("PR creation cancelled: current branch changed");
 	}
 
-	private async originAuthority() {
-		return await readValidatedRemoteAuthority(this.pi(), this.context(), "origin");
-	}
-
-	private async inferBaseRef(): Promise<{ authority: Awaited<ReturnType<PullRequestCreator["originAuthority"]>>; ref: string }> {
-		const authority = await this.originAuthority();
-		await runChecked(this.exec, "git", [
-			"fetch", "--prune", "--no-write-fetch-head", "--no-tags", "--no-recurse-submodules",
-			authority.fetchSource, "+refs/heads/*:refs/remotes/origin/*",
-		], this.options());
-		const refs = await runChecked(this.exec, "git", [
-			"for-each-ref", "--format=%(refname)%09%(objectname)%09%(symref)", "refs/remotes/origin",
-		], this.options());
-		const rows = configuredValues(refs.stdout);
-		if (rows.length > MAX_REMOTE_BRANCHES) throw new Error(`${BASE_RERUN}; more than ${MAX_REMOTE_BRANCHES} base candidates exist`);
-		const originOwnsTarget = authority.host === this.target.host &&
-			authority.repository.toLowerCase() === this.target.repository.toLowerCase();
-		const candidates: Array<{ ref: string; score: number }> = [];
-		for (const row of rows) {
-			const parts = row.split("\t");
-			if (parts.length !== 3) throw new Error(`Base inference is unsafe. ${BASE_RERUN}`);
-			const prefix = "refs/remotes/origin/";
-			if (!parts[0]!.startsWith(prefix)) throw new Error(`Base inference is unsafe. ${BASE_RERUN}`);
-			const ref = parts[0]!.slice(prefix.length);
-			if (ref === "HEAD" || originOwnsTarget && ref === this.target.ref) continue;
-			if (!ref || parts[2] !== "") throw new Error(`Base inference is unsafe. ${BASE_RERUN}`);
-			const oid = requiredOid(parts[1], "remote base OID");
-			const distance = line((await runChecked(this.exec, "git", ["rev-list", "--left-right", "--count", `HEAD...${oid}`], this.options())).stdout, "base distance");
-			const counts = /^(\d+)\s+(\d+)$/.exec(distance);
-			if (!counts) throw new Error(`Base inference is unsafe. ${BASE_RERUN}`);
-			const score = Number(counts[1]) + Number(counts[2]);
-			if (!Number.isSafeInteger(score)) throw new Error(`Base inference is unsafe. ${BASE_RERUN}`);
-			candidates.push({ ref, score });
-		}
-		if (!candidates.length) throw new Error(`Base cannot be inferred. ${BASE_RERUN}`);
-		const minimum = Math.min(...candidates.map(({ score }) => score));
-		const nearest = candidates.filter(({ score }) => score === minimum);
-		if (nearest.length !== 1) throw new Error(`Base is ambiguous. ${BASE_RERUN}`);
-		return { authority, ref: nearest[0]!.ref };
-	}
-
-	private async resolveBase(explicit?: string): Promise<Omit<CreateBaseAuthority, "oid">> {
-		if (explicit !== undefined) {
-			const parsed = parseExplicitBase(explicit);
-			if (parsed.host !== this.target.host.toLowerCase()) {
-				throw new Error("PR creation base and head must use the same GitHub host");
-			}
-			await runChecked(this.exec, "git", ["check-ref-format", "--branch", parsed.ref], this.options());
-			return { ...parsed, fetchSource: await resolveRepositoryFetchSource(this.exec, this.options(), parsed) };
-		}
-		const configured = await runChecked(this.exec, "git", [
-			"config", "--get-all", `branch.${this.target.branch}.gh-merge-base`,
-		], this.options(), [0, 1]);
-		const values = configured.code === 1 && configured.stdout === "" ? [] : configuredValues(configured.stdout);
-		if (values.length > 1) throw new Error(`Configured base is ambiguous. ${BASE_RERUN}`);
-		if (values.length === 1) {
-			await runChecked(this.exec, "git", ["check-ref-format", "--branch", values[0]!], this.options());
-			const authority = await this.originAuthority();
-			return { ...authority, ref: values[0]! };
-		}
-		const inferred = await this.inferBaseRef();
-		await runChecked(this.exec, "git", ["check-ref-format", "--branch", inferred.ref], this.options());
-		return { ...inferred.authority, ref: inferred.ref };
-	}
-
 	private async liveBase(): Promise<string> {
 		if (!this.state.base) throw new Error("PR creation base is unavailable");
 		return await readPullRequestBaseRefOid(this.pi(), this.context(), this.state.base);
@@ -362,36 +287,50 @@ export class PullRequestCreator {
 			throw new Error("PR creation prepare action was already consumed");
 		}
 		return await withWorktreeLock(this.cwd, async () => {
+			this.explicitBase = explicitBase;
 			await this.freshNone();
-			const base = await this.resolveBase(explicitBase);
-			if (base.host !== this.target.host.toLowerCase()) {
-				throw new Error("PR creation base and head must use the same GitHub host");
+			const preflight = await preflightPullRequestCreation(
+				this.pi(),
+				this.context(),
+				this.target,
+				this.explicitBase,
+			);
+			if (preflight.ahead === 0) {
+				throw new Error("PR creation requires at least one commit ahead of the selected base");
 			}
-			const oid = await readPullRequestBaseRefOid(this.pi(), this.context(), base);
-			this.state.base = { ...base, oid };
+			const { base } = preflight;
+			this.state.base = {
+				host: base.host,
+				repository: base.repository,
+				ref: base.ref,
+				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, oid,
+					"fetch", "--no-write-fetch-head", "--no-tags", "--no-recurse-submodules", base.fetchSource, base.oid,
 				], this.options());
-				await runChecked(this.exec, "git", ["cat-file", "-e", `${oid}^{commit}`], 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;
 			}
 			await this.freshNone();
-			if (await this.liveBase() !== oid) throw new Error("PR creation cancelled: base ref moved during prepare");
-			const mergeBase = requiredOid(line((await runChecked(this.exec, "git", ["merge-base", "HEAD", oid], this.options())).stdout, "merge base"), "merge base");
+			if (await readHead(this.exec, this.options()) !== preflight.head) {
+				throw new Error("PR creation cancelled: local HEAD changed during prepare");
+			}
+			if (await this.liveBase() !== base.oid) throw new Error("PR creation cancelled: base ref moved during prepare");
 			this.state.phase = "prepared";
-			return { kind: "prepared", base: { ...this.state.base }, mergeBase };
+			return { kind: "prepared", base: { ...this.state.base }, mergeBase: base.mergeBase };
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
 
 	private async verifyMerge(originalHead: string): Promise<{ head: string; fastForward: boolean }> {
 		const base = this.state.base!;
 		const head = await readHead(this.exec, this.options());
-		const commits = line((await runChecked(this.exec, "git", ["rev-list", "--parents", "-n", "1", "HEAD"], this.options())).stdout, "merge parents")
+		const commits = line((await runChecked(this.exec, "git", ["rev-list", "--parents", "-n", "1", head], this.options())).stdout, "merge parents")
 			.split(" ").map((value, index) => requiredOid(value, index ? "merge parent" : "merged HEAD"));
 		if (commits[0] !== head) throw new Error("PR creation merge verification returned a different HEAD");
 		let fastForward = false;
@@ -504,14 +443,27 @@ export class PullRequestCreator {
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
 
-	private async configureNoTargetUpstream(head: string): Promise<void> {
-		const target: BranchUpstreamTarget = {
+	private upstreamTarget(head: string): BranchUpstreamTarget {
+		return {
 			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);
@@ -523,6 +475,19 @@ export class PullRequestCreator {
 			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);
@@ -530,6 +495,13 @@ export class PullRequestCreator {
 			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;
 		}
 	}
@@ -553,6 +525,7 @@ 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 {
@@ -569,7 +542,7 @@ export class PullRequestCreator {
 				throw error;
 			}
 			this.state.phase = "pushed";
-			if (this.noTarget) await this.configureNoTargetUpstream(head);
+			if (this.noTarget) await this.fetchNoTargetTracking(head);
 			return { kind: "pushed", head };
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
@@ -587,7 +560,7 @@ export class PullRequestCreator {
 			}
 			return;
 		}
-		const discovery = await this.load(this.pi(), this.context());
+		const discovery = await this.load(this.pi(), this.context(), undefined, undefined, this.explicitBase);
 		if (discovery.kind === "none") {
 			if (!sameTarget(this.target, discovery.creationTarget, head)) throw new Error("Published target authority changed");
 			return;
@@ -614,9 +587,16 @@ export class PullRequestCreator {
 	}
 
 	async publish(titleInput: string, body: string): Promise<CreatePullRequestResult> {
-		if (this.state.phase !== "pushed" || !this.state.base || !this.state.publicationHead || this.state.attempts.pullRequest !== "none") {
+		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)
+		) {
 			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) {
@@ -629,56 +609,66 @@ 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");
 			}
-			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);
+			let after: PullRequestPublication;
+			if (retryingUpstream) {
+				if (!before || before.title !== title || before.body !== body) {
+					throw new Error("Published pull request changed before upstream completion");
 				}
-			} catch (error) {
-				this.state.attempts.pullRequest = "unknown";
-				throw error;
-			}
-			try {
-				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");
+				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;
 				}
-				this.state.attempts.pullRequest = "applied";
-				this.state.phase = "published";
-				this.state.url = after.url.href;
-				return { kind: "published", url: after.url.href };
-			} catch (error) {
-				this.state.attempts.pullRequest = "unknown";
-				throw error;
 			}
+			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 };
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
 }

package/extensions/pr-github.ts

@@ -105,6 +105,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 +205,11 @@ export type BranchUpstreamTarget = {
 	remoteOid: string;
 };
 
+export type BranchUpstreamConfiguration = {
+	remote: string[];
+	merge: string[];
+};
+
 type SearchSelection =
 	| { kind: "candidate"; candidate: SearchPullRequest; pullRequest: ListedPullRequest | null }
 	| { kind: "none" }
@@ -332,6 +355,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,
@@ -1050,27 +1079,232 @@ function parseMergeMethodSettings(output: string, rulesetMethods: MergeMethod[]
 	return { allowedMergeMethods, viewerDefaultMergeMethod };
 }
 
-export async function hasLocalCommit(
+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,
-): Promise<boolean> {
+	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 current branch", "git", ["branch", "--show-current"])).stdout,
-		"Read current branch",
+		(await execute(pi, context, "Read creation branch", "git", ["branch", "--show-current"])).stdout,
+		"Read creation branch",
 		"branch",
 	);
-	const output = (await execute(pi, context, "Read branch history", "git", [
-		"reflog",
-		"show",
-		"--format=%H",
-		`refs/heads/${branch}`,
-	])).stdout.replace(/\r\n/g, "\n");
-	const entries = output.split("\n");
-	if (entries.at(-1) === "") entries.pop();
-	if (!entries.length) fail("Read branch history", "missing branch creation entry");
-	const commits = entries.map((entry) => oid(entry, "Read branch history", "commit"));
-	// ponytail: reflog expiry can hide old branch history; resolve the PR base if this becomes observable.
-	return commits[0] !== commits.at(-1);
+	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(
@@ -1167,6 +1401,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,
@@ -1694,6 +1944,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 +1976,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 +2084,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 +2215,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,

package/extensions/pr-routing.ts

@@ -38,6 +38,10 @@ export type PullRequestTarget = {
 	remoteOid: string | null;
 };
 
+export type BranchCreationState = {
+	ahead: number;
+};
+
 export type DiscoveryIssue =
 	| { kind: "detached-head" }
 	| { kind: "target-invalid" }
@@ -50,7 +54,7 @@ export type DiscoveryIssue =
 
 export type PullRequestDiscovery<T extends PullRequest = PullRequest> =
 	| { kind: "current"; pullRequest: T }
-	| { kind: "none"; creationTarget: PullRequestTarget }
+	| { kind: "none"; creationTarget: PullRequestTarget; branch: BranchCreationState }
 	| { kind: "blocked"; issue: DiscoveryIssue }
 	| { kind: "inactive" };
 
@@ -87,7 +91,7 @@ export function derivePullRequestNextStep(pullRequest: PullRequest): Exclude<Nex
 export function deriveNextStep(discovery: PullRequestDiscovery<PullRequest & { target: PullRequestTarget }>): NextStep {
 	if (discovery.kind === "inactive") return "none";
 	if (discovery.kind === "blocked") return "blocked";
-	if (discovery.kind === "none") return "create";
+	if (discovery.kind === "none") return discovery.branch.ahead > 0 ? "create" : "none";
 	if (discovery.pullRequest.target.provenance === "inferred") {
 		return discovery.pullRequest.lifecycle === "open" ? "link-branch" : "none";
 	}

package/extensions/pr-ui.ts

@@ -114,7 +114,6 @@ function widgetText(input: PrDisplayInput, nextStep: NextStep): string | undefin
 
 export function projectPrDisplay(
 	discovery: PullRequestDiscovery<PrDisplayInput>,
-	hasLocalCommit = false,
 ): PrDisplay {
 	const nextStep = deriveNextStep(discovery);
 	if (discovery.kind === "inactive") return { nextStep };
@@ -132,7 +131,7 @@ export function projectPrDisplay(
 	if (discovery.kind === "none") {
 		return {
 			nextStep,
-			widget: hasLocalCommit ? "Run /pr to create pull request" : undefined,
+			widget: nextStep === "create" ? "Run /pr to create pull request" : undefined,
 		};
 	}
 

package/extensions/pr.ts

@@ -19,7 +19,6 @@ import {
 } from "./pr-command.ts";
 import { PullRequestCreator, type CreatePullRequestOptions } from "./pr-create.ts";
 import {
-	hasLocalCommit,
 	loadCurrentPullRequest,
 	parsePullRequestObservation,
 	pullRequestObservation,
@@ -161,7 +160,6 @@ type WorkflowContext =
 
 type PullRequestExtensionDependencies = {
 	loadCurrentPullRequest?: typeof loadCurrentPullRequest;
-	hasLocalCommit?: typeof hasLocalCommit;
 	createPrCommandHandler?: typeof createPrCommandHandler;
 	createBranchUpdater?: (options: UpdateBranchOptions) => UpdateBranchWorkflow;
 	createPullRequestCreator?: (options: CreatePullRequestOptions) => CreateWorkflow;
@@ -255,7 +253,6 @@ export default function pullRequestExtension(
 	};
 
 	const discover = dependencies.loadCurrentPullRequest ?? loadCurrentPullRequest;
-	const detectLocalCommit = dependencies.hasLocalCommit ?? hasLocalCommit;
 	const createCommandHandler = dependencies.createPrCommandHandler ?? createPrCommandHandler;
 	const createBranchUpdater = dependencies.createBranchUpdater ?? ((options) => new PullRequestBranchUpdater(options));
 	const createPullRequestCreator = dependencies.createPullRequestCreator ?? ((options) => new PullRequestCreator(options));
@@ -265,9 +262,15 @@ export default function pullRequestExtension(
 	const newRunId = dependencies.newRunId ?? randomUUID;
 	let context: ExtensionContext | undefined;
 	let observation: PullRequestObservation | undefined;
-	const load: typeof loadCurrentPullRequest = async (api, loadContext, inspectedLocal) => {
+	const load: typeof loadCurrentPullRequest = async (
+		api,
+		loadContext,
+		inspectedLocal,
+		_observed,
+		explicitCreationBase,
+	) => {
 		const generation = sessionGeneration;
-		const discovery = await discover(api, loadContext, inspectedLocal, observation);
+		const discovery = await discover(api, loadContext, inspectedLocal, observation, explicitCreationBase);
 		if (generation !== sessionGeneration) return discovery;
 		if (discovery.kind === "current") {
 			const current = pullRequestObservation(discovery.pullRequest);
@@ -288,7 +291,6 @@ export default function pullRequestExtension(
 	let lastBlockedIssueKey: string | undefined;
 	let delegatedWorkPending = false;
 	let pendingWorkspaceRename = false;
-	let mergeCompleted = false;
 	let displayedWidget: PrDisplay | undefined;
 	let commandGeneration = 0;
 	let workflowContext: WorkflowContext | undefined;
@@ -573,7 +575,6 @@ export default function pullRequestExtension(
 	const render = (
 		ctx: ExtensionContext,
 		discovery: Awaited<ReturnType<typeof loadCurrentPullRequest>>,
-		localCommit: boolean,
 	): void => {
 		if (discovery.kind === "inactive") {
 			if (timer !== undefined) clearInterval(timer);
@@ -585,7 +586,7 @@ export default function pullRequestExtension(
 			reconcileWidget(ctx);
 			return;
 		}
-		const display = projectPrDisplay(discovery, localCommit);
+		const display = projectPrDisplay(discovery);
 		const footer = formatPrFooter(display, ctx.ui.theme);
 		if ((discovery.kind === "current" || discovery.kind === "blocked") && footer === undefined) {
 			throw new Error("Pull request display is missing a footer");
@@ -621,7 +622,6 @@ export default function pullRequestExtension(
 		lastBlockedIssueKey = undefined;
 		delegatedWorkPending = false;
 		pendingWorkspaceRename = false;
-		mergeCompleted = false;
 		displayedWidget = undefined;
 		commandGeneration = 0;
 		clearWorkflow(workflowContext);
@@ -668,21 +668,17 @@ export default function pullRequestExtension(
 		active = controller;
 		try {
 			let discovery: Awaited<ReturnType<typeof loadCurrentPullRequest>>;
-			let localCommit = false;
 			try {
 				discovery = await load(pi, loadContext);
 				if (controller.signal.aborted || sessionGeneration !== generation) return;
-				if (discovery.kind === "none") {
-					localCommit = !mergeCompleted && await detectLocalCommit(pi, loadContext);
-				}
 			} catch {
-				// Keep an established display. A cold Git-worktree failure gets a sanitized placeholder.
+				// Keep an established footer. A refresh failure must not leave a stale action hint.
 				if (!controller.signal.aborted && sessionGeneration === generation) {
+					displayedWidget = undefined;
+					reconcileWidget(ctx);
 					if (!displayEstablished) {
 						const unavailable = unavailablePrDisplay();
-						displayedWidget = undefined;
 						ctx.ui.setStatus(UI_KEY, formatPrFooter(unavailable, ctx.ui.theme));
-						reconcileWidget(ctx);
 						displayEstablished = true;
 					}
 					reportRefreshFailure();
@@ -690,7 +686,7 @@ export default function pullRequestExtension(
 				return;
 			}
 			if (controller.signal.aborted || sessionGeneration !== generation) return;
-			render(ctx, discovery, localCommit);
+			render(ctx, discovery);
 			refreshFailureReported = false;
 
 			const pullRequest = discovery.kind === "current" ? discovery.pullRequest : undefined;
@@ -786,7 +782,6 @@ export default function pullRequestExtension(
 		if (!isBashToolResult(event)) return;
 		const command = event.input.command;
 		if (typeof command === "string" && (GH_PR_CREATE.test(command) || GIT_COMMIT.test(command) || GIT_PUSH.test(command))) {
-			if (GIT_COMMIT.test(command)) mergeCompleted = false;
 			await refresh().catch(reportRefreshFailure);
 		}
 	});
@@ -798,7 +793,7 @@ export default function pullRequestExtension(
 		releaseWorkflow,
 	});
 	pi.registerCommand("pr", {
-		description: "[--base=<host>/<owner>/<repository>:<ref>] — Run the current branch pull request next step",
+		description: "[--base <branch>] [instructions] — Run the current branch pull request next step",
 		handler: async (args, ctx) => {
 			if (!ctx.hasUI || !context) return;
 			const generation = sessionGeneration;
@@ -838,7 +833,6 @@ export default function pullRequestExtension(
 				if (nextStep === "create") ctx.ui.setStatus(UI_KEY, undefined);
 				reconcileWidget(ctx);
 			} else {
-				if (nextStep === "merge") mergeCompleted = true;
 				activeInvocations.delete(invocation);
 				refreshInBackground();
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-pr",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "description": "Run /pr to safely discover or link the current pull request, then create, update, address feedback, fix CI, or merge when ready.",
   "keywords": [
     "pi-package",

package/skills/pi-pr-create/SKILL.md

@@ -5,12 +5,12 @@ description: Prepare and publish the current branch pull request with determinis
 
 # Pi PR Create
 
-Use the `pi_pr_create` helper for base, merge, push, upstream, and GitHub mechanics. Do not reproduce its checks or commands with shell tools.
+Use only `pi_pr_create` for base selection, merge, push, upstream, and GitHub work. Do not repeat its Git or GitHub checks with shell tools.
 
-Use the prepared base and merge-base to inspect the live change. Separate pending work into coherent commits. Preserve coherent existing staging. Exclude `.context/` and unrelated changes. Stop when changes cannot be separated safely.
+Start with the prompted `prepare` action. It uses the saved branch base: explicit `/pr --base BRANCH`, one `branch.<branch>.gh-merge-base` value, then validated `origin` default. It requires a committed change ahead. Dirty work alone cannot start this route. The base is always `origin`; fork heads must share its GitHub source and host. Apply trailing prompt guidance only to the PR content.
 
-If the helper reports conflicts, inspect only its returned paths and bounded conflict hunks. Resolve only clear intent, then declare the complete resolved path set to the helper. Ask the user when the correct behavior is unclear.
+After `prepare`, inspect the returned base and merge-base. Separate and commit coherent pending work. Preserve coherent staging. Exclude `.context/` and unrelated changes. Stop when separation is unsafe.
 
-Choose and run the smallest relevant validation after the helper verifies the merge. Stop on failure.
+Use this action order: `prepare`, `merge`, optional `continue`, `push`, then `publish`. On conflict, inspect only returned paths and bounded hunks. Give `continue` every resolved path. Run the smallest relevant validation after the helper verifies the merge.
 
-Write a concise Conventional Commit title. Write a body with `Summary` and `Testing` sections that matches the live diff and checks. Give both to the helper only after it has published the captured head. Reply with only the helper's validated pull request URL.
+Give `publish` a concise Conventional Commit title and a body with `Summary` and `Testing`. It validates the exact PR before no-target upstream setup. If that setup fails after publication, retry `publish` with the same title and body. Do not push again or create another PR. Reply only with the validated PR URL.