@henryqw/pi-pr 4.0.2 → 4.0.4

package/extensions/pr-merge.ts

@@ -1,12 +1,14 @@
-import { inspectWorktree, type Exec, type ExecResult } from "./pr-execution.ts";
+import {
+	inspectWorktree,
+	readHead,
+	requiredOid,
+	requiredText,
+	runChecked,
+	type Exec,
+} from "./pr-execution.ts";
 import type { LocalMergeSafety } from "./pr-routing.ts";
 
-export type { Exec, ExecResult } from "./pr-execution.ts";
-
-export type MergeMethod = "merge" | "rebase" | "squash";
-
 const MERGE_PULL_REQUEST_MUTATION = "mutation($pullRequestId:ID!,$expectedHeadOid:GitObjectID!,$mergeMethod:PullRequestMergeMethod!){mergePullRequest(input:{pullRequestId:$pullRequestId,expectedHeadOid:$expectedHeadOid,mergeMethod:$mergeMethod}){pullRequest{id state}}}";
-const OID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
 
 export type InspectLocalMergeSafetyInput = {
 	exec: Exec;
@@ -15,16 +17,11 @@ export type InspectLocalMergeSafetyInput = {
 	headFetchSource: string;
 };
 
-export type MergeMethodSelectionInput = {
-	allowedMergeMethods: readonly MergeMethod[];
-	viewerDefaultMergeMethod?: MergeMethod | null;
-};
-
 export type InspectedLocalMergeSafety = LocalMergeSafety & {
 	headOid: string;
 };
 
-export type ExecuteGitHubMergeInput = MergeMethodSelectionInput & InspectLocalMergeSafetyInput & {
+export type ExecuteGitHubMergeInput = InspectLocalMergeSafetyInput & {
 	pullRequestId: string;
 	hostname: string;
 	expectedBase: {
@@ -35,62 +32,10 @@ export type ExecuteGitHubMergeInput = MergeMethodSelectionInput & InspectLocalMe
 	revalidateReadiness: (local: InspectedLocalMergeSafety) => Promise<void>;
 };
 
-function commandText(command: string, args: string[]): string {
-	return [command, ...args].join(" ");
-}
-
-function errorText(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function commandFailure(command: string, args: string[], detail: string): Error {
-	return new Error(`${commandText(command, args)} failed: ${detail}`);
-}
-
-async function runCommand(
-	exec: Exec,
-	cwd: string,
-	command: string,
-	args: string[],
-	allowedCodes: readonly number[] = [0],
-): Promise<ExecResult> {
-	let result: ExecResult;
-	try {
-		result = await exec(command, args, { cwd });
-	} catch (error) {
-		throw commandFailure(command, args, errorText(error));
-	}
-
-	if (result.killed || !allowedCodes.includes(result.code)) {
-		const detail = result.stderr.trim() || result.stdout.trim() || (result.killed ? "command was killed" : `exit code ${result.code}`);
-		throw commandFailure(command, args, detail);
-	}
-	return result;
-}
-
-function requiredText(value: unknown, label: string): string {
-	if (typeof value !== "string" || !value || value.trim() !== value || /[\u0000-\u001f\u007f]/.test(value)) {
-		throw new TypeError(`${label} must be a non-empty string`);
-	}
-	return value;
-}
-
-function requiredOid(value: unknown, label: string): string {
-	const parsed = requiredText(value, label);
-	if (!OID.test(parsed)) throw new TypeError(`${label} must be a full Git OID`);
-	return parsed;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function requiredOutput(result: ExecResult, label: string): string {
-	const output = result.stdout.trim();
-	if (!output) throw new Error(`${label} returned no output`);
-	return output;
-}
-
 function validateInspectionInput(input: InspectLocalMergeSafetyInput): void {
 	requiredText(input.cwd, "cwd");
 	requiredOid(input.expectedHead, "expected PR head");
@@ -98,76 +43,43 @@ function validateInspectionInput(input: InspectLocalMergeSafetyInput): void {
 	if (typeof input.exec !== "function") throw new TypeError("exec must be a function");
 }
 
-async function readLocalHead(exec: Exec, cwd: string): Promise<string> {
-	return requiredOid(
-		requiredOutput(await runCommand(exec, cwd, "git", ["rev-parse", "--verify", "HEAD^{commit}"]), "local HEAD"),
-		"local HEAD",
-	);
-}
-
 /** Inspect local state without changing branches, the index, or the worktree. */
 export async function inspectLocalMergeSafety(input: InspectLocalMergeSafetyInput): Promise<InspectedLocalMergeSafety> {
 	validateInspectionInput(input);
 
 	const worktree = await inspectWorktree(input.exec, { cwd: input.cwd });
-	await runCommand(input.exec, input.cwd, "git", [
+	await runChecked(input.exec, "git", [
 		"fetch",
 		"--no-write-fetch-head",
 		"--no-tags",
 		"--no-recurse-submodules",
 		input.headFetchSource,
 		input.expectedHead,
-	]);
-	await runCommand(input.exec, input.cwd, "git", ["cat-file", "-e", `${input.expectedHead}^{commit}`]);
+	], { cwd: input.cwd });
+	await runChecked(input.exec, "git", ["cat-file", "-e", `${input.expectedHead}^{commit}`], { cwd: input.cwd });
 
-	const headOid = await readLocalHead(input.exec, input.cwd);
+	const headOid = await readHead(input.exec, { cwd: input.cwd });
 	if (headOid === input.expectedHead) return { worktree, head: "equal", headOid };
 
-	const localAncestor = await runCommand(
+	const localAncestor = await runChecked(
 		input.exec,
-		input.cwd,
 		"git",
 		["merge-base", "--is-ancestor", headOid, input.expectedHead],
+		{ cwd: input.cwd },
 		[0, 1],
 	);
 	if (localAncestor.code === 0) return { worktree, head: "behind", headOid };
 
-	const expectedAncestor = await runCommand(
+	const expectedAncestor = await runChecked(
 		input.exec,
-		input.cwd,
 		"git",
 		["merge-base", "--is-ancestor", input.expectedHead, headOid],
+		{ cwd: input.cwd },
 		[0, 1],
 	);
 	return { worktree, head: expectedAncestor.code === 0 ? "ahead" : "diverged", headOid };
 }
 
-function validateMergeMethods(input: MergeMethodSelectionInput): void {
-	if (!Array.isArray(input.allowedMergeMethods)) throw new TypeError("allowedMergeMethods must be an array");
-	if (input.allowedMergeMethods.some((method) => method !== "merge" && method !== "rebase" && method !== "squash")) {
-		throw new TypeError("allowedMergeMethods contains an unsupported method");
-	}
-	if (
-		input.viewerDefaultMergeMethod !== undefined &&
-		input.viewerDefaultMergeMethod !== null &&
-		input.viewerDefaultMergeMethod !== "merge" &&
-		input.viewerDefaultMergeMethod !== "rebase" &&
-		input.viewerDefaultMergeMethod !== "squash"
-	) throw new TypeError("viewerDefaultMergeMethod is unsupported");
-}
-
-export function selectMergeMethod(input: MergeMethodSelectionInput): MergeMethod {
-	validateMergeMethods(input);
-	if (input.allowedMergeMethods.length === 1) return input.allowedMergeMethods[0]!;
-	if (input.allowedMergeMethods.includes("squash")) return "squash";
-	if (
-		input.viewerDefaultMergeMethod !== undefined &&
-		input.viewerDefaultMergeMethod !== null &&
-		input.allowedMergeMethods.includes(input.viewerDefaultMergeMethod)
-	) return input.viewerDefaultMergeMethod;
-	throw new Error("No deterministic GitHub merge method is available");
-}
-
 function validateExecuteInput(input: ExecuteGitHubMergeInput): void {
 	validateInspectionInput(input);
 	requiredText(input.pullRequestId, "pullRequestId");
@@ -216,7 +128,6 @@ function parseMergeResponse(output: string, expectedId: string): void {
 
 export async function executeGitHubMerge(input: ExecuteGitHubMergeInput): Promise<void> {
 	validateExecuteInput(input);
-	const method = selectMergeMethod(input);
 	const local = await inspectLocalMergeSafety(input);
 	if (local.worktree !== "clean" || (local.head !== "equal" && local.head !== "behind")) {
 		throw new Error(`Local merge safety check failed: worktree is ${local.worktree}, HEAD is ${local.head}`);
@@ -226,11 +137,11 @@ export async function executeGitHubMerge(input: ExecuteGitHubMergeInput): Promis
 	if (finalWorktree !== "clean") {
 		throw new Error("Final local merge safety check failed: worktree is dirty");
 	}
-	const finalHead = await readLocalHead(input.exec, input.cwd);
+	const finalHead = await readHead(input.exec, { cwd: input.cwd });
 	if (finalHead !== local.headOid) {
 		throw new Error(`Final local merge safety check failed: HEAD changed from ${local.headOid} to ${finalHead}`);
 	}
-	const merged = await runCommand(input.exec, input.cwd, "gh", [
+	const merged = await runChecked(input.exec, "gh", [
 		"api",
 		"graphql",
 		"--hostname",
@@ -242,7 +153,9 @@ export async function executeGitHubMerge(input: ExecuteGitHubMergeInput): Promis
 		"-F",
 		`expectedHeadOid=${input.expectedHead}`,
 		"-F",
-		`mergeMethod=${method.toUpperCase()}`,
-	]);
-	parseMergeResponse(requiredOutput(merged, "GitHub merge"), input.pullRequestId);
+		"mergeMethod=SQUASH",
+	], { cwd: input.cwd });
+	const output = merged.stdout.trim();
+	if (!output) throw new Error("GitHub merge returned no output");
+	parseMergeResponse(output, input.pullRequestId);
 }

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-update-branch.ts

@@ -17,7 +17,6 @@ import {
 	runChecked,
 	spawnBounded,
 	withWorktreeLock,
-	type AttemptState,
 	type Exec,
 	type ExecOptions,
 } from "./pr-execution.ts";
@@ -26,13 +25,6 @@ export type UpdateBranchPhase = "ready" | "conflict-awaiting-user" | "verified"
 
 export type UpdateBranchState = {
 	phase: UpdateBranchPhase;
-	attempts: {
-		fetchBase: AttemptState;
-		merge: AttemptState;
-		stage: AttemptState;
-		continueMerge: AttemptState;
-		push: AttemptState;
-	};
 	verifiedHead?: string;
 	conflict?: { paths: string[]; statusBaseline: string };
 };
@@ -62,7 +54,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,
 	};
 }
 
@@ -89,10 +80,7 @@ function validateDeclaredPaths(paths: readonly string[], expected: readonly stri
 }
 
 export class PullRequestBranchUpdater {
-	readonly state: UpdateBranchState = {
-		phase: "ready",
-		attempts: { fetchBase: "none", merge: "none", stage: "none", continueMerge: "none", push: "none" },
-	};
+	readonly state: UpdateBranchState = { phase: "ready" };
 
 	private readonly cwd: string;
 	private readonly authority: CurrentPullRequest;
@@ -188,26 +176,18 @@ export class PullRequestBranchUpdater {
 	}
 
 	async merge(): Promise<UpdateBranchResult> {
-		if (this.state.phase !== "ready" || this.state.attempts.fetchBase !== "none" || this.state.attempts.merge !== "none") {
-			throw new Error("Branch update merge action was already consumed");
-		}
+		if (this.state.phase !== "ready") throw new Error("Branch update merge action was already consumed");
 		return await withWorktreeLock(this.cwd, async () => {
 			await this.freshAuthority(this.authority.head.oid, true);
 			const source = await resolveRepositoryFetchSource(this.exec, this.execOptions(), {
 				host: this.authority.host,
 				repository: this.authority.base.repository,
 			});
-			this.state.attempts.fetchBase = "attempting";
-			try {
-				await runChecked(this.exec, "git", [
-					"fetch", "--no-write-fetch-head", "--no-tags", "--no-recurse-submodules", source, this.authority.base.oid,
-				], this.execOptions());
-				await runChecked(this.exec, "git", ["cat-file", "-e", `${this.authority.base.oid}^{commit}`], this.execOptions());
-				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", source, this.authority.base.oid,
+			], this.execOptions());
+			await runChecked(this.exec, "git", ["cat-file", "-e", `${this.authority.base.oid}^{commit}`], this.execOptions());
 			await this.freshAuthority(this.authority.head.oid, true);
 			if (await isAncestor(this.exec, this.execOptions(), this.authority.base.oid, this.authority.head.oid)) {
 				this.state.phase = "verified";
@@ -215,35 +195,16 @@ export class PullRequestBranchUpdater {
 				return { kind: "verified", head: this.authority.head.oid, fastForward: false };
 			}
 
-			this.state.attempts.merge = "attempting";
-			let result;
-			try {
-				result = await this.exec("git", ["merge", "--no-edit", this.authority.base.oid], this.execOptions());
-			} 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");
-			}
+			const result = await this.exec("git", ["merge", "--no-edit", this.authority.base.oid], this.execOptions());
+			if (result.killed) throw new Error("git merge was killed; its outcome is unknown");
 			if (result.code === 0) {
-				try {
-					const verified = await this.verifyMerge(this.authority.head.oid);
-					this.state.attempts.merge = "applied";
-					return { kind: "verified", ...verified };
-				} catch (error) {
-					this.state.attempts.merge = "unknown";
-					throw error;
-				}
+				const verified = await this.verifyMerge(this.authority.head.oid);
+				return { kind: "verified", ...verified };
 			}
 			try {
 				const paths = await this.captureConflict();
-				this.state.attempts.merge = "applied";
 				return { kind: "conflict", paths: [...paths] };
 			} catch (error) {
-				this.state.attempts.merge = "blocked";
-				this.state.phase = "blocked";
 				const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
 				throw new Error(`git merge failed: ${detail}; ${error instanceof Error ? error.message : String(error)}`);
 			}
@@ -262,36 +223,19 @@ export class PullRequestBranchUpdater {
 			const status = await runChecked(this.exec, "git", ["status", "--porcelain=v2", "-z", "--untracked-files=all"], this.execOptions());
 			assertOnlyDeclaredStatusChanged(this.state.conflict!.statusBaseline, status.stdout, paths);
 
-			if (this.state.attempts.stage !== "none") throw new Error("Conflict staging action was already consumed");
-			this.state.attempts.stage = "attempting";
-			try {
-				await runChecked(this.exec, "git", ["add", "--", ...paths], this.execOptions());
-				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.execOptions());
 			const unmerged = parseNulPaths((await runChecked(this.exec, "git", ["diff", "--name-only", "-z", "--diff-filter=U"], this.execOptions())).stdout, "Unmerged paths");
-			if (unmerged.length) {
-				this.state.phase = "blocked";
-				throw new Error(`Conflict paths remain unresolved: ${unmerged.join(", ")}`);
-			}
+			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.execOptions());
-				const verified = await this.verifyMerge(this.authority.head.oid);
-				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.execOptions());
+			const verified = await this.verifyMerge(this.authority.head.oid);
+			return { kind: "verified", ...verified };
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
 
 	async publish(): Promise<UpdateBranchResult> {
-		if (this.state.phase !== "verified" || !this.state.verifiedHead || this.state.attempts.push !== "none") {
+		if (this.state.phase !== "verified" || !this.state.verifiedHead) {
 			throw new Error("Branch update is not ready to publish");
 		}
 		const head = this.state.verifiedHead;
@@ -306,22 +250,16 @@ export class PullRequestBranchUpdater {
 				throw new Error("Published branch would not be a fast-forward of the frozen remote OID");
 			}
 			await this.freshAuthority(head, true);
-			this.state.attempts.push = "attempting";
-			try {
-				await runChecked(this.exec, "git", [
-					"push", "--porcelain", `--force-with-lease=refs/heads/${this.authority.target.ref}:${original}`,
-					"--recurse-submodules=no", "--", this.authority.target.fetchSource,
-					`${head}:refs/heads/${this.authority.target.ref}`,
-				], this.execOptions());
-				const remote = await readRemoteOid(this.exec, this.execOptions(), this.authority.target.fetchSource, this.authority.target.ref);
-				if (remote !== head) throw new Error("Published remote ref did not match verified HEAD");
-				this.state.attempts.push = "applied";
-				this.state.phase = "published";
-				return { kind: "published", head };
-			} 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.authority.target.ref}:${original}`,
+				"--recurse-submodules=no", "--", this.authority.target.fetchSource,
+				`${head}:refs/heads/${this.authority.target.ref}`,
+			], this.execOptions());
+			const remote = await readRemoteOid(this.exec, this.execOptions(), this.authority.target.fetchSource, this.authority.target.ref);
+			if (remote !== head) throw new Error("Published remote ref did not match verified HEAD");
+			this.state.phase = "published";
+			return { kind: "published", head };
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
 }

package/extensions/pr.ts

@@ -5,7 +5,7 @@ import {
 	type ExtensionAPI,
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth } from "@earendil-works/pi-tui";
 import { createHerdrClient } from "@henryqw/pi-herdr";
 import { Type } from "typebox";
 import { PullRequestCiFixer, type PullRequestCiFixOptions } from "./pr-ci.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;
@@ -296,14 +298,10 @@ export default function pullRequestExtension(
 	let widgetKind: "presentation" | "routing" = "presentation";
 	let routingSpinnerFrame = 0;
 	let routingSpinnerTimer: ReturnType<typeof setInterval> | undefined;
-	let routingSpinnerTui: TUI | undefined;
-	let routingSpinnerComponent: (Component & { dispose(): void }) | undefined;
 
 	const stopRoutingSpinner = (): void => {
 		if (routingSpinnerTimer !== undefined) clearInterval(routingSpinnerTimer);
 		routingSpinnerTimer = undefined;
-		routingSpinnerTui = undefined;
-		routingSpinnerComponent = undefined;
 	};
 
 	const clearWorkflow = (selected: WorkflowContext | undefined): void => {
@@ -524,42 +522,30 @@ export default function pullRequestExtension(
 		stopRoutingSpinner();
 		widgetKind = "routing";
 		routingSpinnerFrame = 0;
-		if (ctx.mode !== "tui") {
-			ctx.ui.setWidget(UI_KEY, [`${ROUTING_SPINNER_FRAMES[0]} ${ROUTING_WIDGET_TEXT}`]);
-			return;
-		}
+		const update = (): void => {
+			const frame = ROUTING_SPINNER_FRAMES[routingSpinnerFrame]!;
+			if (ctx.mode === "tui") {
+				ctx.ui.setWidget(UI_KEY, (_tui, theme) => ({
+					invalidate() {},
+					render(width) {
+						if (width <= 0) return [];
+						return [truncateToWidth(`${theme.fg("accent", frame)} ${ROUTING_WIDGET_TEXT}`, width)];
+					},
+				}));
+				return;
+			}
+			ctx.ui.setWidget(UI_KEY, [`${frame} ${ROUTING_WIDGET_TEXT}`]);
+		};
+		update();
+		if (ctx.mode !== "tui") return;
 
-		ctx.ui.setWidget(UI_KEY, (tui, theme) => {
-			let cachedWidth: number | undefined;
-			let cachedLines: string[] | undefined;
-			const component: Component & { dispose(): void } = {
-				invalidate() {
-					cachedWidth = undefined;
-					cachedLines = undefined;
-				},
-				render(width) {
-					if (width <= 0) return [];
-					if (cachedLines !== undefined && cachedWidth === width) return cachedLines;
-					const line = `${theme.fg("accent", ROUTING_SPINNER_FRAMES[routingSpinnerFrame]!)} ${ROUTING_WIDGET_TEXT}`;
-					cachedWidth = width;
-					cachedLines = [truncateToWidth(line, Math.max(1, width))];
-					return cachedLines;
-				},
-				dispose() {
-					if (routingSpinnerComponent !== component) return;
-					stopRoutingSpinner();
-					widgetKind = "presentation";
-				},
-			};
-			routingSpinnerTui = tui;
-			routingSpinnerComponent = component;
-			return component;
-		});
-		routingSpinnerTimer = setInterval(() => {
+		let spinnerTimer: ReturnType<typeof setInterval>;
+		spinnerTimer = setInterval(() => {
+			if (routingSpinnerTimer !== spinnerTimer || widgetKind !== "routing") return;
 			routingSpinnerFrame = (routingSpinnerFrame + 1) % ROUTING_SPINNER_FRAMES.length;
-			routingSpinnerComponent?.invalidate();
-			routingSpinnerTui?.requestRender();
+			update();
 		}, ROUTING_SPINNER_INTERVAL_MS);
+		routingSpinnerTimer = spinnerTimer;
 	};
 
 	const reconcileWidget = (ctx: ExtensionContext): void => {
@@ -573,7 +559,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 +570,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 +606,6 @@ export default function pullRequestExtension(
 		lastBlockedIssueKey = undefined;
 		delegatedWorkPending = false;
 		pendingWorkspaceRename = false;
-		mergeCompleted = false;
 		displayedWidget = undefined;
 		commandGeneration = 0;
 		clearWorkflow(workflowContext);
@@ -668,21 +652,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 +670,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 +766,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 +777,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 +817,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();
 			}