@henryqw/pi-pr 6.2.6 → 6.2.9

package/README.md

@@ -40,7 +40,7 @@ Run `/pr` in a GitHub checkout. It reads fresh local and GitHub state, takes the
 | Footer | ui | Linked PR number and plain-language status. |
 | Widget | ui | Action hint or transient routing status. |
 
-`/pr` accepts no flags, prose, or base argument. Start with the command, not a helper skill or tool: direct calls cannot establish route authority. The helper run is bound to the current session and worktree.
+`/pr` accepts no flags, prose, or base argument. Start with the command, not a helper skill or tool: direct calls cannot establish route authority. The helper run is bound to the current session and worktree. Its agent tools use plain-object parameter schemas so providers that omit root-union tools can expose them; action-specific arguments are still checked before the workflow runs.
 
 ## Flow
 
@@ -82,5 +82,5 @@ In-progress feedback sweeps keep private recovery under `<agent-dir>/config/pi-p
 - `/pr` does not open a browser, run `/done` or `/sweep`, enable auto-merge, or use a merge queue. It only starts workflows when explicitly invoked.
 - Pushes use a saved exact remote OID lease and revalidate the destination. Concurrent updates block publication instead of being overwritten. Creation does not change the base branch, and a configured push target does not change upstream settings.
 - Direct merge requires a clean, safe local Git state and fresh matching head; it always squashes. GitHub repository policy may still reject it. No branch or worktree is deleted.
-- A Git operation in progress blocks direct merge. An unverified conflict rebase needs manual recovery; a verified rebase can resume through `/pr`. Branches with merge commits since the fork point require manual rebase resolution.
+- A Git operation in progress blocks direct merge. An unverified conflict rebase needs manual recovery; a verified rebase can resume through `/pr`. Rebasing leaves other local branch refs unchanged, even with `rebase.updateRefs=true`. Branches with merge commits since the fork point require manual rebase resolution.
 - Only authenticated GitHub.com and GitHub Enterprise repositories are supported. Resolve ambiguous remotes, unrelated local changes, or GitHub blockers before retrying `/pr`.

package/extensions/pr-ci.ts

@@ -108,13 +108,9 @@ type CiEvidence = {
 	failures: CiFailureEvidence[];
 };
 
-type CiPushAttempt = "before-launch" | "applied" | "not-applied" | "unknown";
 type CiFixPhase = "ready" | "collecting" | "collected" | "published" | "blocked";
 
-type CiFixState = {
-	phase: CiFixPhase;
-	pushAttempt: CiPushAttempt;
-};
+type CiFixState = { phase: CiFixPhase };
 
 export type PullRequestCiFixOptions = {
 	cwd: string;
@@ -293,7 +289,7 @@ function errorMessage(error: unknown): string {
 }
 
 export class PullRequestCiFixer {
-	readonly state: CiFixState = { phase: "ready", pushAttempt: "before-launch" };
+	readonly state: CiFixState = { phase: "ready" };
 
 	private readonly cwd: string;
 	private readonly authority: CurrentPullRequest;
@@ -301,20 +297,16 @@ export class PullRequestCiFixer {
 	private readonly agentDir?: string;
 	private readonly exec: Exec;
 	private readonly load: Load;
-	private collectConsumed = false;
-	private publishConsumed = false;
 	private collectedFingerprint?: string;
 
 	constructor(options: PullRequestCiFixOptions) {
-		if (!options.authority || options.authority.target.provenance !== "configured") {
+		if (options.authority.target.provenance !== "configured") {
 			throw new TypeError("CI repair requires a configured failed pull request with a clean equal local HEAD");
 		}
-		const head = requiredOid(options.authority.head.oid, "pull request head OID");
-		const remote = options.authority.target.remoteOid === null
-			? null
-			: requiredOid(options.authority.target.remoteOid, "remote OID");
-		if (remote !== head) throw new TypeError("CI repair requires the pull request head to match the configured remote OID");
-		this.cwd = requiredText(options.cwd, "cwd");
+		if (options.authority.target.remoteOid !== options.authority.head.oid) {
+			throw new TypeError("CI repair requires the pull request head to match the configured remote OID");
+		}
+		this.cwd = options.cwd;
 		this.authority = cloneCurrentPullRequest(options.authority);
 		this.signal = options.signal;
 		this.agentDir = options.agentDir;
@@ -331,7 +323,7 @@ export class PullRequestCiFixer {
 	}
 
 	private context(): PullRequestLoadContext {
-		return { cwd: this.cwd, signal: this.signal ?? new AbortController().signal };
+		return { cwd: this.cwd, signal: this.signal };
 	}
 
 	private async freshAuthority(requireOriginalLocal: boolean): Promise<CurrentPullRequest> {
@@ -619,8 +611,7 @@ export class PullRequestCiFixer {
 	}
 
 	async collect(): Promise<CiEvidence> {
-		if (this.collectConsumed || this.state.phase !== "ready") throw new Error("CI evidence collect action was already consumed");
-		this.collectConsumed = true;
+		if (this.state.phase !== "ready") throw new Error("CI evidence collect action was already consumed");
 		this.state.phase = "collecting";
 		try {
 			const before = await this.readSnapshot(true);
@@ -699,7 +690,6 @@ export class PullRequestCiFixer {
 		if (repairHead === original || !(await isAncestor(this.exec, this.options(), original, repairHead))) {
 			throw new Error("CI repair HEAD must be a new descendant of the frozen pull request head");
 		}
-		if (await readHead(this.exec, this.options()) !== repairHead) throw new Error("CI repair HEAD changed before push");
 		return repairHead;
 	}
 
@@ -714,8 +704,7 @@ export class PullRequestCiFixer {
 	}
 
 	async publish(): Promise<CiPublishResult> {
-		if (this.publishConsumed || this.state.phase !== "collected") throw new Error("CI repair publish action is unavailable or was already consumed");
-		this.publishConsumed = true;
+		if (this.state.phase !== "collected") throw new Error("CI repair publish action is unavailable or was already consumed");
 		try {
 			return await withWorktreeLock(this.cwd, async () => {
 				const repairHead = await this.validatePublishAuthority();
@@ -741,19 +730,15 @@ export class PullRequestCiFixer {
 						this.authority.target.ref,
 					);
 				} catch (error) {
-					this.state.pushAttempt = "unknown";
 					throw new Error(`CI repair push outcome is unknown: ${errorMessage(error)}`);
 				}
 				if (postcondition === repairHead) {
-					this.state.pushAttempt = "applied";
 					this.state.phase = "published";
 					return { kind: "published", head: repairHead, attempt: "applied" };
 				}
 				if (postcondition === original) {
-					this.state.pushAttempt = "not-applied";
 					throw new Error(`CI repair push was not applied${pushError ? `: ${errorMessage(pushError)}` : ""}`);
 				}
-				this.state.pushAttempt = "unknown";
 				throw new Error("CI repair push outcome is unknown: remote target has an unexpected OID");
 			}, { agentDir: this.agentDir, signal: this.signal });
 		} catch (error) {

package/extensions/pr-command.ts

@@ -25,6 +25,7 @@ const WORKFLOWS: Record<WorkflowNextStep, string> = {
 	sweep: "skill:pi-pr-comment-sweep",
 	"fix-ci": "skill:pi-pr-fix-ci",
 };
+export const WORKFLOW_ROUTES: ReadonlySet<string> = new Set(Object.keys(WORKFLOWS));
 type WorkflowReservation =
 	| { route: "create"; target: PullRequestTarget }
 	| { route: Exclude<WorkflowNextStep, "create">; pullRequest: CurrentPullRequest };

package/extensions/pr-comment-sweep.ts

@@ -43,6 +43,7 @@ import {
 	requiredOid,
 	requiredText,
 	runChecked,
+	validatePaths,
 	withWorktreeLock,
 	type AttemptState,
 } from "./pr-execution.ts";
@@ -190,20 +191,12 @@ function authorityFromCurrent(pullRequest: CurrentPullRequest) {
 	if (pullRequest.lifecycle !== "open" || pullRequest.target.provenance !== "configured") {
 		throw new Error("Comment sweep requires a configured open pull request");
 	}
-	const feedback = feedbackAuthorityFromCurrent(pullRequest);
-	const remoteOid = requiredOid(pullRequest.target.remoteOid, "remote lease OID");
+	const { branch, remote, ref, repository, host, fetchSource, remoteOid } = pullRequest.target;
+	if (remoteOid === null) throw new Error("Comment sweep requires a published remote lease");
 	return {
-		...feedback,
-		headFetchSource: requiredText(pullRequest.headFetchSource, "head fetch source"),
-		target: {
-			branch: requiredText(pullRequest.target.branch, "target branch"),
-			remote: requiredText(pullRequest.target.remote, "target remote"),
-			ref: requiredText(pullRequest.target.ref, "target ref"),
-			repository: requiredText(pullRequest.target.repository, "target repository"),
-			host: requiredText(pullRequest.target.host, "target host").toLowerCase(),
-			fetchSource: requiredText(pullRequest.target.fetchSource, "target fetch source"),
-			remoteOid,
-		},
+		...feedbackAuthorityFromCurrent(pullRequest),
+		headFetchSource: pullRequest.headFetchSource,
+		target: { branch, remote, ref, repository, host, fetchSource, remoteOid },
 	};
 }
 
@@ -270,8 +263,7 @@ function feedbackMatchesAuthority(snapshot: FeedbackSnapshot, authority: SweepAu
 
 function parseOwnedPaths(value: unknown): string[] {
 	if (!Array.isArray(value) || value.some((path) => typeof path !== "string")) throw new Error("ownedPaths must be an array of paths");
-	const encoded = value.length ? `${value.join("\0")}\0` : "";
-	return parseNulPaths(encoded, "Sweep owned paths");
+	return validatePaths(value as string[], "Sweep owned paths");
 }
 
 function parseLedgerEntry(value: unknown, label: string): SweepLedgerEntry {
@@ -635,7 +627,7 @@ export class PullRequestCommentSweep {
 	private readonly pause?: (milliseconds: number) => Promise<void>;
 
 	constructor(options: PullRequestCommentSweepOptions) {
-		this.cwd = requiredText(options.cwd, "cwd");
+		this.cwd = options.cwd;
 		this.suppliedAuthority = options.authority ? authorityFromCurrent(options.authority) : undefined;
 		this.signal = options.signal;
 		this.agentDir = options.agentDir;
@@ -654,7 +646,7 @@ export class PullRequestCommentSweep {
 	}
 
 	private context(): PullRequestLoadContext {
-		return { cwd: this.cwd, signal: this.signal ?? new AbortController().signal };
+		return { cwd: this.cwd, signal: this.signal };
 	}
 
 	private async location(): Promise<{ root: string; id: string; path: string }> {
@@ -1011,7 +1003,6 @@ export class PullRequestCommentSweep {
 
 	async commit(guard: SweepRunGuard, message: string): Promise<{ head: string }> {
 		requiredText(message, "commit message");
-		if (message.length > 256) throw new Error("commit message exceeds 256 characters");
 		return await withWorktreeLock(this.cwd, async () => {
 			const location = await this.location();
 			const state = await this.loadState(location);
@@ -1144,7 +1135,7 @@ export class PullRequestCommentSweep {
 		}, { agentDir: this.agentDir, signal: this.signal });
 	}
 
-	async resolve(guard: SweepRunGuard, threadIdsInput?: string[]): Promise<SweepStatus> {
+	async resolve(guard: SweepRunGuard): Promise<SweepStatus> {
 		return await withWorktreeLock(this.cwd, async () => {
 			const location = await this.location();
 			const state = await this.loadState(location);
@@ -1155,31 +1146,19 @@ export class PullRequestCommentSweep {
 			if (state.attempts.resolutions.some(({ state: attempt }) => attempt !== "applied")) {
 				throw new Error("Comment sweep has an unreconciled thread mutation; use resume");
 			}
-			if (threadIdsInput !== undefined && (!Array.isArray(threadIdsInput) || threadIdsInput.length > FEEDBACK_MAX_RECORDS)) {
-				throw new Error("threadIds must be a bounded array");
-			}
 			const ledger = new Map(state.ledger.map((entry) => [entry.id, entry]));
-			const threadIds = (threadIdsInput ?? state.feedback.snapshot.reviewThreads.filter((thread) =>
+			const threadIds = state.feedback.snapshot.reviewThreads.filter((thread) =>
 				!thread.isResolved && ["addressed", "non-actionable"].includes(ledger.get(thread.id)?.disposition ?? "blocked") &&
 				!thread.comments.some((comment) => ledger.get(comment.id)?.disposition === "blocked")
-			).map(({ id }) => id)).map((id, index) => requiredText(id, `thread ID ${index + 1}`));
-			if (new Set(threadIds).size !== threadIds.length) throw new Error("threadIds contain duplicates");
+			).map(({ id }) => id);
 			for (const threadId of threadIds) {
-				const thread = state.feedback.snapshot.reviewThreads.find(({ id }) => id === threadId);
-				const disposition = ledger.get(threadId)?.disposition;
-				if (!thread || thread.isResolved || ledger.get(threadId)?.kind !== "thread" ||
-					(disposition !== "addressed" && disposition !== "non-actionable")) {
-					throw new Error(`Only addressed or non-actionable unresolved review thread IDs may be resolved: ${threadId}`);
-				}
 				if (state.attempts.resolutions.some((attempt) => attempt.generation === state.feedback.generation && attempt.threadId === threadId && attempt.step === "resolve")) {
 					throw new Error(`Review thread resolution was already attempted: ${threadId}`);
 				}
-				if (disposition === "non-actionable" && !ledger.get(threadId)!.note.trim()) {
+				const entry = ledger.get(threadId)!;
+				if (entry.disposition === "non-actionable" && !entry.note.trim()) {
 					throw new Error(`Non-actionable review thread needs a reason: ${threadId}`);
 				}
-				if (thread.comments.some((comment) => ledger.get(comment.id)?.disposition === "blocked")) {
-					throw new Error(`Review thread has blocked child feedback: ${threadId}`);
-				}
 			}
 			const hasReply = (threadId: string) => state.attempts.resolutions.some((attempt) =>
 				attempt.threadId === threadId && attempt.step === "reply" && attempt.state === "applied" &&

package/extensions/pr-create.ts

@@ -25,13 +25,12 @@ import {
 	inspectWorktreeState,
 	parseNulPaths,
 	parseStatusSnapshot,
-	validateResolvedConflictPaths,
+	validatePaths,
 	isAncestor,
 	isRecord,
 	parseSingleOutputLine,
 	readHead,
 	readRemoteOid,
-	requiredOid,
 	requiredText,
 	runChecked,
 	withWorktreeLock,
@@ -173,7 +172,6 @@ export class PullRequestCreator {
 	private readonly load: Load;
 
 	constructor(options: CreatePullRequestOptions) {
-		if (options.target.remoteOid !== null) requiredOid(options.target.remoteOid, "remote OID");
 		this.cwd = options.cwd;
 		this.target = { ...options.target };
 		this.noTarget = options.target.provenance === "inferred" && options.target.remoteOid === null;
@@ -192,7 +190,7 @@ export class PullRequestCreator {
 	}
 
 	private context(): PullRequestLoadContext {
-		return { cwd: this.cwd, signal: this.signal ?? new AbortController().signal };
+		return { cwd: this.cwd, signal: this.signal };
 	}
 
 	private async freshNone() {
@@ -282,8 +280,7 @@ export class PullRequestCreator {
 			if (await inspectWorktreeState(this.exec, this.options()) === "operation") throw new Error("Git operation in progress");
 			const head = await readHead(this.exec, this.options());
 			const status = (await runChecked(this.exec, "git", ["status", "--porcelain=v2", "-z", "--untracked-files=all"], this.options())).stdout;
-			const paths = [...parseStatusSnapshot(status).keys()];
-			parseNulPaths(paths.map((path) => `${path}\0`).join(""), "Pending paths");
+			const paths = validatePaths([...parseStatusSnapshot(status).keys()], "Pending paths");
 			this.state.pending = { head, status };
 			return { paths, head };
 		}, { agentDir: this.agentDir, signal: this.signal });
@@ -291,7 +288,7 @@ export class PullRequestCreator {
 
 	async commit(pathsInput: string[], message: string): Promise<{ head: string }> {
 		if (this.state.phase !== "prepared" || !this.state.pending) throw new Error("PR creation has no inspected pending work");
-		const paths = validateResolvedConflictPaths(pathsInput, []);
+		const paths = validatePaths(pathsInput, "Commit paths");
 		if (!paths.length || paths.some((path) => !parseStatusSnapshot(this.state.pending!.status).has(path))) {
 			throw new Error("Commit paths must be reviewed pending paths");
 		}

package/extensions/pr-execution.ts

@@ -111,12 +111,9 @@ export async function withWorktreeLock<T>(
 	options: { agentDir?: string; signal?: AbortSignal } = {},
 ): Promise<T> {
 	options.signal?.throwIfAborted();
-	const rootResult = await runChecked(spawnBounded, "git", ["rev-parse", "--show-toplevel"], {
-		cwd: requiredText(cwd, "cwd"),
-		signal: options.signal,
-	});
+	const rootResult = await runChecked(spawnBounded, "git", ["rev-parse", "--show-toplevel"], { cwd, signal: options.signal });
 	const root = parseSingleOutputLine(rootResult.stdout, "Git worktree root resolution");
-	const canonical = requiredText(await realpath(root), "canonical Git worktree root");
+	const canonical = await realpath(root);
 	const lockNamespace = resolve(extensionConfigDir("pi-pr", options.agentDir));
 	const lockDirectory = join(lockNamespace, "worktree-locks");
 	const identity = createHash("sha256").update(canonical).digest("hex");
@@ -147,7 +144,11 @@ export async function withWorktreeLock<T>(
 export function parseNulPaths(output: string, label: string): string[] {
 	if (output === "") return [];
 	if (!output.endsWith("\0")) throw new Error(`${label} returned malformed paths`);
-	const paths = output.slice(0, -1).split("\0");
+	return validatePaths(output.slice(0, -1).split("\0"), label);
+}
+
+/** Reject unsafe, oversized, or duplicate repository-relative paths. */
+export function validatePaths(paths: readonly string[], label: string): string[] {
 	let bytes = 0;
 	if (paths.length > MAX_CONFLICT_PATHS) throw new Error(`${label} returned more than ${MAX_CONFLICT_PATHS} paths`);
 	for (const path of paths) {
@@ -160,16 +161,7 @@ export function parseNulPaths(output: string, label: string): string[] {
 	}
 	if (bytes > MAX_CONFLICT_PATHS_BYTES) throw new Error(`${label} returned too much path data`);
 	if (new Set(paths).size !== paths.length) throw new Error(`${label} returned duplicate paths`);
-	return paths;
-}
-
-export function validateResolvedConflictPaths(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");
-	if (expected.some((path) => !parsed.includes(path))) {
-		throw new Error("Resolved paths must include every original conflict path");
-	}
-	return parsed;
+	return [...paths];
 }
 
 function statusPath(record: string): { path: string; rename: boolean } {

package/extensions/pr-feedback-attention.ts

@@ -45,8 +45,7 @@ export async function needsFeedbackAttention(
 	const { cwd, agentDir, signal } = options;
 	const exec = options.exec ?? spawnBounded;
 	const snapshot = await collectPullRequestFeedback(feedbackAuthorityFromCurrent(current), { exec, cwd, signal });
-	const discovery = await (options.load ?? loadCurrentPullRequest)(extensionExecApi(exec, cwd, signal),
-		{ cwd, signal: signal ?? new AbortController().signal });
+	const discovery = await (options.load ?? loadCurrentPullRequest)(extensionExecApi(exec, cwd, signal), { cwd, signal });
 	if (discovery.kind !== "current" || !samePullRequestSnapshot(current, discovery.pullRequest) ||
 		current.base.oid !== discovery.pullRequest.base.oid) {
 		throw new Error("Feedback discovery cancelled: pull request authority changed");

package/extensions/pr-github.ts

@@ -116,7 +116,7 @@ export type PullRequestObservation = {
 	target: { repository: string; branch: string; remote: string; ref: string };
 };
 
-export type PullRequestLoadContext = Pick<ExtensionContext, "cwd" | "signal">;
+export type PullRequestLoadContext = { cwd: string; signal?: AbortSignal };
 
 type PullRequestCreationPreflight = {
 	head: string;
@@ -764,17 +764,20 @@ function parseSearchPage(output: string, pushTarget: Pick<PushTarget, "repositor
 	};
 }
 
-function matchingSearchPullRequests(candidates: PullRequestCandidate[], pushTarget: PushTarget): PullRequestCandidate[] {
-	return candidates.filter((candidate) =>
-		candidate.url.hostname.toLowerCase() === pushTarget.repository.host &&
-		candidate.headRepository !== null &&
-		normalizeRepository(candidate.headRepository) === pushTarget.repository.normalizedName &&
-		candidate.headRef === pushTarget.ref
-	);
+function matchesPushTarget(
+	url: URL,
+	headRepository: string | null,
+	headRef: string,
+	pushTarget: Pick<PushTarget, "repository" | "ref">,
+): boolean {
+	return url.hostname.toLowerCase() === pushTarget.repository.host && headRepository !== null &&
+		normalizeRepository(headRepository) === pushTarget.repository.normalizedName && headRef === pushTarget.ref;
 }
 
 function selectSearchPullRequest(candidates: PullRequestCandidate[], pushTarget: PushTarget): SearchSelection {
-	const matching = matchingSearchPullRequests(candidates, pushTarget);
+	const matching = candidates.filter((candidate) =>
+		matchesPushTarget(candidate.url, candidate.headRepository, candidate.headRef, pushTarget)
+	);
 	const open = matching.filter((candidate) => candidate.lifecycle === "open");
 	if (open.length > 1) return { kind: "ambiguous", urls: open.map(({ url }) => url) };
 	if (open.length === 1) {
@@ -830,33 +833,6 @@ function parsePullRequestPublication(output: string, expectedUrl: URL): PullRequ
 	};
 }
 
-function selectPullRequest(
-	candidates: ListedPullRequest[],
-	pushTarget: PushTarget,
-): ListedPullRequest | null {
-	const matching = candidates.filter((candidate) =>
-		candidate.url.hostname.toLowerCase() === pushTarget.repository.host &&
-		normalizeRepository(candidate.head.repository) === pushTarget.repository.normalizedName &&
-		candidate.head.ref === pushTarget.ref,
-	);
-	const open = matching.filter((candidate) => candidate.lifecycle === "open");
-	if (open.length > 1) fail("Find pull requests", "multiple open pull requests match current push target");
-	if (open.length === 1) {
-		if (pushTarget.remoteHeadOid === null) fail("Find pull requests", "remote push ref is absent for open pull request");
-		if (open[0].head.oid !== pushTarget.remoteHeadOid) {
-			fail("Find pull requests", "open pull request head does not match remote push ref");
-		}
-		return open[0];
-	}
-	if (pushTarget.remoteHeadOid === null) return null;
-
-	const historical = matching.filter((candidate) =>
-		candidate.lifecycle !== "open" && candidate.head.oid === pushTarget.remoteHeadOid
-	);
-	if (historical.length > 1) fail("Find pull requests", "multiple historical pull requests match remote push ref");
-	return historical[0] ?? null;
-}
-
 function ciStatus(checks: CheckState[]): CiStatus {
 	if (!checks.length) return "none";
 	let failed = false;
@@ -958,27 +934,6 @@ function parseBaseRefAuthority(
 	return oid(repository.ref.target.oid, "Read base ref", "target OID");
 }
 
-function parseBaseRefOid(output: string, candidate: ListedPullRequest): string {
-	return parseBaseRefAuthority(output, candidate.base);
-}
-
-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 &&
@@ -1006,20 +961,19 @@ async function captureCreationIdentity(
 	context: PullRequestLoadContext,
 	target: PullRequestTarget,
 ): Promise<CreationIdentity> {
-	const validatedTarget = validatedCreationTarget(target);
 	const branch = singleLine(
 		(await execute(pi, context, "Read creation branch", "git", ["branch", "--show-current"])).stdout,
 		"Read creation branch",
 		"branch",
 	);
-	if (branch !== validatedTarget.branch) fail("Read creation branch", "branch changed");
+	if (branch !== target.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 };
+	return { target, head };
 }
 
 async function readConfiguredCreationBaseRef(
@@ -1139,20 +1093,12 @@ async function inspectCreationWorktree(
 async function preflightCreation(
 	pi: Pick<ExtensionAPI, "exec">,
 	context: PullRequestLoadContext,
-	target: PullRequestTarget,
-	explicitBaseRef: string | undefined,
 	identity: CreationIdentity,
 ): Promise<CreationPreflightResult> {
-	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);
+	const baseRef = await readConfiguredCreationBaseRef(pi, context, identity.target.branch) ??
+		await readDefaultCreationBaseRef(pi, context, origin);
 	const relation = await inspectCreationRepositoryRelation(pi, context, identity.target, origin, baseRef);
 	const worktree = await inspectCreationWorktree(pi, context);
 	if (relation === "same-ref") return { kind: relation, worktree };
@@ -1196,10 +1142,9 @@ export async function preflightPullRequestCreation(
 	pi: Pick<ExtensionAPI, "exec">,
 	context: PullRequestLoadContext,
 	target: PullRequestTarget,
-	explicitBaseRef?: string,
 ): Promise<PullRequestCreationPreflight> {
 	const identity = await captureCreationIdentity(pi, context, target);
-	const result = await preflightCreation(pi, context, target, explicitBaseRef, identity);
+	const result = await preflightCreation(pi, context, identity);
 	if (result.kind === "same-ref") fail("Read creation repository", "head and base refs match");
 	return result.preflight;
 }
@@ -1208,11 +1153,10 @@ 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 result = await preflightCreation(pi, context, target, explicitBaseRef, captured);
+	const result = await preflightCreation(pi, context, captured);
 	return {
 		kind: "none",
 		creationTarget: target,
@@ -1569,7 +1513,7 @@ async function readBaseRefOid(
 		"-F",
 		`qualifiedName=refs/heads/${candidate.base.ref}`,
 	]);
-	return parseBaseRefOid(result.stdout, candidate);
+	return parseBaseRefAuthority(result.stdout, candidate.base);
 }
 
 export async function readPullRequestBaseRefOid(
@@ -1730,14 +1674,11 @@ export async function findExactHeadPullRequests(
 	const host = text(target.host, "Find pull requests", "host").toLowerCase();
 	const repository = repositoryName(target.repository, "Find pull requests", "head repository");
 	const ref = text(target.ref, "Find pull requests", "head ref");
-	const candidates = await enumerateSearchPullRequests(pi, context, {
-		repository: { host, nameWithOwner: repository, normalizedName: normalizeRepository(repository) },
-		ref,
-	});
+	const pushTarget = { repository: { host, nameWithOwner: repository, normalizedName: normalizeRepository(repository) }, ref };
+	const candidates = await enumerateSearchPullRequests(pi, context, pushTarget);
 	if (candidates === null) return fail("Find pull requests", "published head ref is unavailable");
 	return candidates.filter((candidate) =>
-		candidate.lifecycle === "open" && candidate.headRepository !== null &&
-		normalizeRepository(candidate.headRepository) === normalizeRepository(repository) && candidate.headRef === ref
+		candidate.lifecycle === "open" && matchesPushTarget(candidate.url, candidate.headRepository, candidate.headRef, pushTarget)
 	);
 }
 
@@ -1774,9 +1715,8 @@ export async function loadCurrentPullRequest(
 	context: PullRequestLoadContext,
 	inspectedLocal?: LocalMergeSafety,
 	observed?: unknown,
-	explicitCreationBase?: string,
 ): Promise<CurrentPullRequestDiscovery> {
-	return await loadCurrentPullRequestInternal(pi, context, inspectedLocal, observed, explicitCreationBase);
+	return await loadCurrentPullRequestInternal(pi, context, inspectedLocal, observed);
 }
 
 async function loadCurrentPullRequestInternal(
@@ -1784,7 +1724,6 @@ async function loadCurrentPullRequestInternal(
 	context: PullRequestLoadContext,
 	inspectedLocal: LocalMergeSafety | undefined,
 	observed: unknown,
-	explicitCreationBase: string | undefined,
 	creationIdentity?: CreationIdentity,
 ): Promise<CurrentPullRequestDiscovery> {
 	const read = await readPushTarget(pi, context);
@@ -1809,15 +1748,13 @@ async function loadCurrentPullRequestInternal(
 			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");
+				return await loadCurrentPullRequestInternal(pi, context, inspectedLocal, observed, captured);
 			}
+			if (!sameCreationTarget(creationIdentity.target, 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 await creationDiscovery(pi, context, target, explicitCreationBase, creationIdentity);
+			return await creationDiscovery(pi, context, target, creationIdentity);
 		}
 		pushTarget = inferred.target;
 	} else {
@@ -1860,64 +1797,32 @@ async function loadCurrentPullRequestInternal(
 	if (search.kind === "target-invalid") {
 		return { kind: "blocked", issue: { kind: "target-invalid" } };
 	}
-	const candidates = search.kind === "candidate" && search.pullRequest !== null ? [search.pullRequest] : [];
-	let candidate: ListedPullRequest | null;
+	// The loaded view may differ from the search candidate; it must still match the push target exactly.
+	const loaded = search.kind === "candidate" ? search.pullRequest : null;
+	const matches = loaded !== null && matchesPushTarget(loaded.url, loaded.head.repository, loaded.head.ref, pushTarget);
+	const oidMismatch = (url: URL): CurrentPullRequestDiscovery => ({
+		kind: "blocked",
+		issue: { kind: "candidate-oid-mismatch", remote: pushTarget.remote, urls: [url] },
+	});
+	let candidate: ListedPullRequest;
 	if (pushTarget.provenance === "inferred") {
-		const matching = candidates.filter((item) =>
-			item.lifecycle === "open" &&
-			item.url.hostname.toLowerCase() === pushTarget.repository.host &&
-			normalizeRepository(item.head.repository) === pushTarget.repository.normalizedName &&
-			item.head.ref === pushTarget.ref
-		);
-		if (matching.length > 1) {
-			return {
-				kind: "blocked",
-				issue: { kind: "candidate-prs-ambiguous", urls: matching.map(({ url }) => url).sort((a, b) => a.href.localeCompare(b.href)) },
-			};
-		}
-		if (matching.length === 0) {
+		if (!matches || loaded.lifecycle !== "open") {
 			return { kind: "blocked", issue: { kind: "published-without-pr", remote: pushTarget.remote } };
 		}
-		candidate = matching[0];
-		if (candidate.head.oid !== pushTarget.remoteHeadOid) {
-			return {
-				kind: "blocked",
-				issue: { kind: "candidate-oid-mismatch", remote: pushTarget.remote, urls: [candidate.url] },
-			};
-		}
+		if (loaded.head.oid !== pushTarget.remoteHeadOid) return oidMismatch(loaded.url);
 		if (!canLinkTarget(await readLinkConfiguration(pi, context, pushTarget), pushTarget)) {
 			return { kind: "blocked", issue: { kind: "link-configuration", remote: pushTarget.remote } };
 		}
+		candidate = loaded;
+	} else if (matches && loaded.lifecycle === "open") {
+		if (pushTarget.remoteHeadOid === null) return { kind: "blocked", issue: { kind: "target-invalid" } };
+		if (loaded.head.oid !== pushTarget.remoteHeadOid) return oidMismatch(loaded.url);
+		candidate = loaded;
+	} else if (matches && loaded.head.oid === pushTarget.remoteHeadOid) {
+		candidate = loaded;
 	} else {
-		try {
-			candidate = selectPullRequest(candidates, pushTarget);
-		} catch (error) {
-			if (!(error instanceof PullRequestLoadError)) throw error;
-			const matching = candidates.filter((item) =>
-				normalizeRepository(item.head.repository) === pushTarget.repository.normalizedName && item.head.ref === pushTarget.ref
-			);
-			const urls = matching.map(({ url }) => url).sort((a, b) => a.href.localeCompare(b.href));
-			if (error.message.includes("multiple ")) {
-				return {
-					kind: "blocked",
-					issue: { kind: "candidate-prs-ambiguous", urls },
-				};
-			}
-			if (error.message.includes("does not match remote push ref")) {
-				return {
-					kind: "blocked",
-					issue: { kind: "candidate-oid-mismatch", remote: pushTarget.remote, urls },
-				};
-			}
-			if (error.message.includes("remote push ref is absent")) {
-				return { kind: "blocked", issue: { kind: "target-invalid" } };
-			}
-			throw error;
-		}
-		if (candidate === null) {
-			if (creationIdentity !== undefined) fail("Read creation target", "target changed");
-			return await creationDiscovery(pi, context, publicTarget(pushTarget), explicitCreationBase);
-		}
+		if (creationIdentity !== undefined) fail("Read creation target", "target changed");
+		return await creationDiscovery(pi, context, publicTarget(pushTarget));
 	}
 
 	return {

package/extensions/pr-merge.ts

@@ -3,8 +3,6 @@ import {
 	inspectWorktree,
 	isRecord,
 	readHead,
-	requiredOid,
-	requiredText,
 	runChecked,
 } from "./pr-execution.ts";
 import type { LocalMergeSafety } from "./pr-routing.ts";
@@ -33,17 +31,8 @@ type ExecuteGitHubMergeInput = InspectLocalMergeSafetyInput & {
 	revalidateReadiness: (local: InspectedLocalMergeSafety) => Promise<void>;
 };
 
-function validateInspectionInput(input: InspectLocalMergeSafetyInput): void {
-	requiredText(input.cwd, "cwd");
-	requiredOid(input.expectedHead, "expected PR head");
-	requiredText(input.headFetchSource, "PR head fetch source");
-	if (typeof input.exec !== "function") throw new TypeError("exec must be a function");
-}
-
 /** 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 runChecked(input.exec, "git", [
 		"fetch",
@@ -77,17 +66,6 @@ export async function inspectLocalMergeSafety(input: InspectLocalMergeSafetyInpu
 	return { worktree, head: expectedAncestor.code === 0 ? "ahead" : "diverged", headOid };
 }
 
-function validateExecuteInput(input: ExecuteGitHubMergeInput): void {
-	validateInspectionInput(input);
-	requiredText(input.pullRequestId, "pullRequestId");
-	requiredText(input.hostname, "hostname");
-	if (!isRecord(input.expectedBase)) throw new TypeError("expectedBase must be an object");
-	requiredText(input.expectedBase.repository, "expected base repository");
-	requiredText(input.expectedBase.ref, "expected base ref");
-	requiredText(input.expectedBase.oid, "expected base OID");
-	if (typeof input.revalidateReadiness !== "function") throw new TypeError("revalidateReadiness must be a function");
-}
-
 function parseGraphQLResponse(output: string, action: string): Record<string, unknown> {
 	let value: unknown;
 	try {
@@ -124,7 +102,6 @@ function parseMergeResponse(output: string, expectedId: string): void {
 }
 
 export async function executeGitHubMerge(input: ExecuteGitHubMergeInput): Promise<void> {
-	validateExecuteInput(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}`);

package/extensions/pr-publish-work.ts

@@ -1,6 +1,6 @@
 import { spawnBounded, type Exec } from "@henryqw/pi-process";
 import { cloneCurrentPullRequest, loadCurrentPullRequest, readValidatedRemoteAuthority, samePullRequestSnapshot, type CurrentPullRequest } from "./pr-github.ts";
-import { extensionExecApi, inspectWorktree, inspectWorktreeState, isAncestor, parseNulPaths, parseStatusSnapshot, readHead, readRemoteOid, requiredText, runChecked, validateResolvedConflictPaths, withWorktreeLock } from "./pr-execution.ts";
+import { extensionExecApi, inspectWorktree, inspectWorktreeState, isAncestor, parseNulPaths, parseStatusSnapshot, readHead, readRemoteOid, requiredText, runChecked, validatePaths, withWorktreeLock } from "./pr-execution.ts";
 
 type Check = { command: string; args: string[] };
 type Options = { cwd: string; authority: CurrentPullRequest; signal?: AbortSignal; agentDir?: string; exec?: Exec; loadCurrentPullRequest?: typeof loadCurrentPullRequest };
@@ -33,12 +33,11 @@ export class PullRequestWorkPublisher {
 
 	private async authorityCheck(): Promise<void> {
 		const { cwd, signal } = this.options;
-		const discovery = await this.load(extensionExecApi(this.exec, cwd, signal), { cwd, signal: signal ?? new AbortController().signal });
+		const discovery = await this.load(extensionExecApi(this.exec, cwd, signal), { cwd, signal });
 		if (discovery.kind !== "current" || !samePullRequestSnapshot(this.authority, discovery.pullRequest)) {
 			throw new Error("Local publication cancelled: PR identity or remote head changed");
 		}
-		const remote = await readValidatedRemoteAuthority(extensionExecApi(this.exec, cwd, signal),
-			{ cwd, signal: signal ?? new AbortController().signal }, this.authority.target.remote);
+		const remote = await readValidatedRemoteAuthority(extensionExecApi(this.exec, cwd, signal), { cwd, signal }, this.authority.target.remote);
 		if (remote.fetchSource !== this.authority.target.fetchSource || remote.host !== this.authority.target.host ||
 			remote.repository.toLowerCase() !== this.authority.target.repository.toLowerCase()) {
 			throw new Error("Local publication cancelled: push destination changed");
@@ -60,8 +59,7 @@ export class PullRequestWorkPublisher {
 				throw new Error("Local HEAD is not a descendant of the published PR head");
 			}
 			const status = (await runChecked(this.exec, "git", ["status", "--porcelain=v2", "-z", "--untracked-files=all"], this.execOptions())).stdout;
-			const paths = [...parseStatusSnapshot(status).keys()];
-			parseNulPaths(paths.map((path) => `${path}\0`).join(""), "Pending paths");
+			const paths = validatePaths([...parseStatusSnapshot(status).keys()], "Pending paths");
 			this.initialHead = head;
 			this.status = status;
 			return { paths, head };
@@ -70,7 +68,7 @@ export class PullRequestWorkPublisher {
 
 	async commit(pathsInput: string[], message: string): Promise<{ head: string }> {
 		if (!this.initialHead || this.status === undefined || this.consumed) throw new Error("Pending changes must be inspected first");
-		const paths = validateResolvedConflictPaths(pathsInput, []);
+		const paths = validatePaths(pathsInput, "Commit paths");
 		if (!paths.length || paths.some((path) => !parseStatusSnapshot(this.status!).has(path))) {
 			throw new Error("Commit paths must be reviewed pending paths");
 		}
@@ -94,10 +92,6 @@ export class PullRequestWorkPublisher {
 
 	async validate(checks: Check[]): Promise<{ head: string; checks: number }> {
 		if (!this.initialHead || this.validatedHead) throw new Error("Local publication validation is unavailable");
-		if (!Array.isArray(checks) || checks.length > 32 || checks.some(({ command, args }) =>
-			typeof command !== "string" || !command || !Array.isArray(args) || args.some((arg) => typeof arg !== "string"))) {
-			throw new Error("Invalid validation commands");
-		}
 		return await withWorktreeLock(this.options.cwd, async () => {
 			await this.authorityCheck();
 			if (await inspectWorktree(this.exec, this.execOptions()) !== "clean") throw new Error("Unrelated pending changes remain; ask about ownership before publishing");

package/extensions/pr-update-branch.ts

@@ -24,7 +24,7 @@ import {
 	requiredOid,
 	resolveRepositoryFetchSource,
 	runChecked,
-	validateResolvedConflictPaths,
+	validatePaths,
 	withWorktreeLock,
 } from "./pr-execution.ts";
 
@@ -60,6 +60,8 @@ function sameAuthority(frozen: CurrentPullRequest, fresh: CurrentPullRequest): b
 type RebaseRecovery = { version: 1; phase: "pending" | "verified" | "published"; identity: string;
 	original: string; remote: string; verified: string | null };
 
+const isOid = (value: unknown): value is string => typeof value === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(value);
+
 function recoveryIdentity(pr: CurrentPullRequest): string {
 	return JSON.stringify([pr.id, pr.number, pr.url.href, pr.host, pr.base.repository, pr.base.ref, pr.base.oid,
 		pr.head.repository, pr.head.ref, pr.target.provenance, pr.target.branch, pr.target.remote,
@@ -83,9 +85,7 @@ async function readRecovery(path: string, signal?: AbortSignal): Promise<RebaseR
 	if (!isRecord(record) || Object.keys(record).sort().join(",") !== "identity,original,phase,remote,verified,version" ||
 		record.version !== 1 || !["pending", "verified", "published"].includes(record.phase as string) ||
 		typeof record.identity !== "string" || record.identity.length > 2048 ||
-		typeof record.original !== "string" || !/^[0-9a-f]{40}$|^[0-9a-f]{64}$/.test(record.original) ||
-		typeof record.remote !== "string" || !/^[0-9a-f]{40}$|^[0-9a-f]{64}$/.test(record.remote) ||
-		(record.verified !== null && (typeof record.verified !== "string" || !/^[0-9a-f]{40}$|^[0-9a-f]{64}$/.test(record.verified))) ||
+		!isOid(record.original) || !isOid(record.remote) || (record.verified !== null && !isOid(record.verified)) ||
 		(record.phase === "pending" && record.verified !== null) ||
 		(record.phase !== "pending" && record.verified === null)) {
 		throw new Error(`Invalid branch update recovery is preserved at ${path}`);
@@ -142,7 +142,7 @@ export class PullRequestBranchUpdater {
 	}
 
 	private context(): PullRequestLoadContext {
-		return { cwd: this.cwd, signal: this.signal ?? new AbortController().signal };
+		return { cwd: this.cwd, signal: this.signal };
 	}
 
 	private async freshAuthority(expectedHead: string, requireClean: boolean, published = false): Promise<CurrentPullRequest> {
@@ -257,7 +257,7 @@ export class PullRequestBranchUpdater {
 			if (mergeCommits) throw new Error("Branch update cannot rebase a branch with merge commits; preserve its resolutions manually");
 			await this.freshAuthority(this.authority.head.oid, true);
 			await this.writeRecovery("pending", null);
-			const result = await this.exec("git", ["-c", "core.editor=true", "-c", "rebase.backend=merge", "rebase", "--no-autostash", "--onto", this.authority.base.oid, mergeBase], this.execOptions());
+			const result = await this.exec("git", ["-c", "core.editor=true", "-c", "rebase.backend=merge", "-c", "rebase.updateRefs=false", "rebase", "--no-autostash", "--onto", this.authority.base.oid, mergeBase], this.execOptions());
 			if (result.killed) throw new Error("git rebase was killed; its outcome is unknown");
 			if (result.code === 0) return await this.verifyRebase();
 			try {
@@ -272,7 +272,10 @@ export class PullRequestBranchUpdater {
 		if (this.state.phase !== "conflict-awaiting-user" || !this.state.conflict) {
 			throw new Error("Branch rebase has no conflict awaiting continuation");
 		}
-		const paths = validateResolvedConflictPaths(resolvedPaths, this.state.conflict.paths);
+		const paths = validatePaths(resolvedPaths, "Resolved conflict paths");
+		if (this.state.conflict.paths.some((path) => !paths.includes(path))) {
+			throw new Error("Resolved paths must include every original conflict path");
+		}
 		return await withWorktreeLock(this.cwd, async () => {
 			const discovery = await this.load(this.pi(), this.context());
 			if (discovery.kind !== "current" || !sameAuthority(this.authority, discovery.pullRequest)) {
@@ -289,7 +292,7 @@ export class PullRequestBranchUpdater {
 			await runChecked(this.exec, "git", ["--literal-pathspecs", "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) throw new Error(`Conflict paths remain unresolved: ${unmerged.join(", ")}`);
-			const result = await this.exec("git", ["-c", "core.editor=true", "rebase", "--continue"], this.execOptions());
+			const result = await this.exec("git", ["-c", "core.editor=true", "-c", "rebase.updateRefs=false", "rebase", "--continue"], this.execOptions());
 			if (result.killed) throw new Error("git rebase continuation was killed; its outcome is unknown");
 			if (result.code === 0) return await this.verifyRebase();
 			return await this.captureConflict();

package/extensions/pr.ts

@@ -8,12 +8,14 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import { createHerdrClient } from "@henryqw/pi-herdr";
-import { Type } from "typebox";
+import { Type, type Static, type TObject, type TSchema, type TUnion } from "typebox";
+import { Check, Errors } from "typebox/value";
 import { PullRequestCiFixer, type PullRequestCiFixOptions } from "./pr-ci.ts";
 import { PullRequestCommentSweep, type PullRequestCommentSweepOptions } from "./pr-comment-sweep.ts";
 import { needsFeedbackAttention } from "./pr-feedback-attention.ts";
 import {
 	createPrCommandHandler,
+	WORKFLOW_ROUTES,
 	type PrCommandDependencies,
 	type PrCommandInvocation,
 	type WorkflowPromptIdentity,
@@ -48,7 +50,6 @@ const OBSERVATION_ENTRY = "pi-pr-observation";
 const GH_PR_CREATE = /(?:^|[;&|]\s*|\n\s*)gh\s+pr\s+create(?=\s|$|[;&|])/;
 const GIT_COMMIT = /(?:^|[;&|]\s*|\n\s*)git\s+commit(?=\s|$|[;&|])/;
 const GIT_PUSH = /(?:^|[;&|]\s*|\n\s*)git\s+push(?=\s|$|[;&|])/;
-const WORKFLOW_ROUTES = new Set(["create", "publish-work", "update-branch", "sweep", "fix-ci"]);
 const DELEGATED_TOOLS = new Set(["delegate_task"]);
 const CLOSED = { additionalProperties: false } as const;
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
@@ -76,13 +77,38 @@ const SweepChecks = Type.Array(Type.Object({
 	args: Type.Array(Type.String({ maxLength: 4_096 }), { maxItems: 256 }),
 }, CLOSED), { maxItems: 32 });
 
-// OpenAI-compatible endpoints require an object root even when every union variant is an object.
-const UpdateBranchParameters = Type.Union([
+// Strict OpenAI-compatible endpoints reject a parameters root without type "object", and Claude Code
+// drops tools whose root is a union. Register a flat object root derived from the per-action variants
+// and enforce the exact variant at execution (also after any before_tool argument replacement).
+function flatRoot(actions: TUnion<TObject[]>): TObject {
+	const properties = new Map<string, TSchema[]>();
+	const requiredCount = new Map<string, number>();
+	for (const variant of actions.anyOf) {
+		for (const [key, schema] of Object.entries(variant.properties)) {
+			const seen = properties.get(key) ?? [];
+			if (!seen.some((candidate) => JSON.stringify(candidate) === JSON.stringify(schema))) seen.push(schema);
+			properties.set(key, seen);
+			if (variant.required?.includes(key)) requiredCount.set(key, (requiredCount.get(key) ?? 0) + 1);
+		}
+	}
+	return Type.Object(Object.fromEntries([...properties].map(([key, schemas]) => {
+		const schema = schemas.length === 1 ? schemas[0]! : Type.Union(schemas);
+		return [key, requiredCount.get(key) === actions.anyOf.length ? schema : Type.Optional(schema)];
+	})), CLOSED);
+}
+
+function checkedAction<T extends TUnion<TObject[]>>(actions: T, args: unknown): Static<T> {
+	if (Check(actions, args)) return args as Static<T>;
+	const issue = [...Errors(actions, args)][0];
+	throw new Error(`Tool arguments do not match one action${issue ? `: ${issue.message}` : ""}`);
+}
+
+const UpdateBranchActions = Type.Union([
 	Type.Object({ runId: RouteRunId, action: Type.Literal("rebase") }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("continue"), resolvedPaths: ResolvedPaths }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("publish") }, CLOSED),
-], { type: "object" });
-const CreateParameters = Type.Union([
+]);
+const CreateActions = Type.Union([
 	Type.Object({ runId: RouteRunId, action: Type.Literal("prepare") }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("inspect") }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("commit"), ownedPaths: OwnedPaths, message: Type.String({ minLength: 1, maxLength: 256 }) }, CLOSED),
@@ -94,8 +120,8 @@ const CreateParameters = Type.Union([
 		title: Type.String({ minLength: 1, maxLength: 256 }),
 		body: Type.String({ maxLength: 65_536 }),
 	}, CLOSED),
-], { type: "object" });
-const SweepParameters = Type.Union([
+]);
+const SweepActions = Type.Union([
 	Type.Object({ runId: RouteRunId, action: Type.Literal("start") }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("resume") }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("show"), guard: SweepGuard, id: Type.String({ minLength: 1, maxLength: 1_024 }) }, CLOSED),
@@ -111,17 +137,17 @@ const SweepParameters = Type.Union([
 	Type.Object({ runId: RouteRunId, action: Type.Literal("refresh"), guard: SweepGuard }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("resolve"), guard: SweepGuard }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("finalize"), guard: SweepGuard, checks: SweepChecks }, CLOSED),
-], { type: "object" });
-const WorkParameters = Type.Union([
+]);
+const WorkActions = Type.Union([
 	Type.Object({ runId: RouteRunId, action: Type.Literal("inspect") }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("commit"), ownedPaths: OwnedPaths, message: Type.String({ minLength: 1, maxLength: 256 }) }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("validate"), checks: SweepChecks }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("publish") }, CLOSED),
-], { type: "object" });
-const FixCiParameters = Type.Union([
+]);
+const FixCiActions = Type.Union([
 	Type.Object({ runId: RouteRunId, action: Type.Literal("collect") }, CLOSED),
 	Type.Object({ runId: RouteRunId, action: Type.Literal("publish") }, CLOSED),
-], { type: "object" });
+]);
 
 type UpdateBranchWorkflow = Pick<PullRequestBranchUpdater, "state" | "recoveryLaunchAction" | "rebase" | "continue" | "publish">;
 type CreateWorkflow = Pick<PullRequestCreator, "state" | "prepare" | "inspect" | "commit" | "verify" | "push" | "publish">;
@@ -247,15 +273,9 @@ 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,
-		_observed,
-		explicitCreationBase,
-	) => {
+	const load: typeof loadCurrentPullRequest = async (api, loadContext, inspectedLocal) => {
 		const generation = sessionGeneration;
-		const discovery = await discover(api, loadContext, inspectedLocal, observation, explicitCreationBase);
+		const discovery = await discover(api, loadContext, inspectedLocal, observation);
 		if (generation !== sessionGeneration) return discovery;
 		if (discovery.kind === "current") {
 			const current = pullRequestObservation(discovery.pullRequest);
@@ -302,7 +322,6 @@ export default function pullRequestExtension(
 		invocation.assertCurrent();
 		if (workflowContext) throw new Error(`PR workflow ${workflowContext.runId} is still active`);
 		const runId = newRunId();
-		if (!UUID.test(runId)) throw new Error("PR workflow runId generator returned an invalid UUID");
 		const common: WorkflowContextBase = {
 			runId,
 			sessionGeneration: invocation.sessionGeneration,
@@ -432,6 +451,8 @@ export default function pullRequestExtension(
 			selected.controller.signal.throwIfAborted();
 			if (worktree !== selected.worktree) throw new Error("PR workflow worktree is wrong or stale");
 			selected.usedSinceSettlement = true;
+			// Drained follow-ups need not emit before_agent_start; this run has been consumed.
+			selected.queuedPrompt = undefined;
 			return toolResult(await action(selected as Extract<WorkflowContext, { route: Route }>));
 		} finally {
 			signal?.removeEventListener("abort", abortRun);
@@ -442,9 +463,10 @@ export default function pullRequestExtension(
 		name: "pi_pr_update_branch",
 		label: "Update PR Branch",
 		description: "Run one guarded action for the /pr branch-update route.",
-		parameters: UpdateBranchParameters,
+		parameters: flatRoot(UpdateBranchActions),
 		executionMode: "sequential",
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+		async execute(_toolCallId, raw, signal, _onUpdate, ctx) {
+			const params = checkedAction(UpdateBranchActions, raw);
 			return executeWorkflowAction(params.runId, "update-branch", ctx, signal, async (selected) => {
 				switch (params.action) {
 					case "rebase": return await selected.workflow.rebase();
@@ -463,9 +485,10 @@ export default function pullRequestExtension(
 		name: "pi_pr_create",
 		label: "Create Pull Request",
 		description: "Run one guarded action for the /pr creation route.",
-		parameters: CreateParameters,
+		parameters: flatRoot(CreateActions),
 		executionMode: "sequential",
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+		async execute(_toolCallId, raw, signal, _onUpdate, ctx) {
+			const params = checkedAction(CreateActions, raw);
 			return executeWorkflowAction(params.runId, "create", ctx, signal, async (selected) => {
 				switch (params.action) {
 					case "prepare": return await selected.workflow.prepare();
@@ -487,9 +510,10 @@ export default function pullRequestExtension(
 		name: "pi_pr_publish_work",
 		label: "Publish PR Work",
 		description: "Inspect, commit, validate, and publish only reviewed local work for the /pr route.",
-		parameters: WorkParameters,
+		parameters: flatRoot(WorkActions),
 		executionMode: "sequential",
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+		async execute(_toolCallId, raw, signal, _onUpdate, ctx) {
+			const params = checkedAction(WorkActions, raw);
 			return executeWorkflowAction(params.runId, "publish-work", ctx, signal, async (selected) => {
 				switch (params.action) {
 					case "inspect": return await selected.workflow.inspect();
@@ -509,9 +533,10 @@ export default function pullRequestExtension(
 		name: "pi_pr_sweep",
 		label: "Sweep PR Feedback",
 		description: "Run one guarded action for the /pr feedback route.",
-		parameters: SweepParameters,
+		parameters: flatRoot(SweepActions),
 		executionMode: "sequential",
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+		async execute(_toolCallId, raw, signal, _onUpdate, ctx) {
+			const params = checkedAction(SweepActions, raw);
 			return executeWorkflowAction(params.runId, "sweep", ctx, signal, async (selected) => {
 				switch (params.action) {
 					case "start": return await selected.workflow.start();
@@ -536,9 +561,10 @@ export default function pullRequestExtension(
 		name: "pi_pr_fix_ci",
 		label: "Fix PR CI",
 		description: "Run one guarded action for the /pr failed-CI route.",
-		parameters: FixCiParameters,
+		parameters: flatRoot(FixCiActions),
 		executionMode: "sequential",
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+		async execute(_toolCallId, raw, signal, _onUpdate, ctx) {
+			const params = checkedAction(FixCiActions, raw);
 			return executeWorkflowAction(params.runId, "fix-ci", ctx, signal, async (selected) => {
 				switch (params.action) {
 					case "collect": return await selected.workflow.collect();
@@ -622,9 +648,6 @@ export default function pullRequestExtension(
 		}
 		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");
-		}
 		displayedWidget = display.widget === undefined ? undefined : display;
 		ctx.ui.setStatus(UI_KEY, footer);
 		reconcileWidget(ctx);
@@ -672,25 +695,15 @@ export default function pullRequestExtension(
 		const category = error instanceof GitHubRateLimitError ? "quota" : "generic";
 		if (!ctx || reportedRefreshFailure === category || reportedRefreshFailure === "quota") return;
 		reportedRefreshFailure = category;
-		try {
-			ctx.ui.notify(
-				error instanceof GitHubRateLimitError
-					? error.message
-					: "PR status refresh failed: status unavailable",
-				"error",
-			);
-		} catch {
-			console.error("PR status refresh failed and could not be reported");
-		}
+		ctx.ui.notify(
+			error instanceof GitHubRateLimitError ? error.message : "PR status refresh failed: status unavailable",
+			"error",
+		);
 	};
 
 	const reportHerdrRenameFailure = (ctx: ExtensionContext, error: unknown): void => {
-		try {
-			const message = error instanceof Error ? error.message : String(error);
-			ctx.ui.notify(`Herdr workspace rename failed: ${message.slice(0, 500)}`, "warning");
-		} catch (reportError) {
-			console.error("Herdr workspace rename failed and could not be reported", error, reportError);
-		}
+		const message = error instanceof Error ? error.message : String(error);
+		ctx.ui.notify(`Herdr workspace rename failed: ${message.slice(0, 500)}`, "warning");
 	};
 
 	const refresh = async (): Promise<void> => {
@@ -783,7 +796,8 @@ export default function pullRequestExtension(
 
 	pi.on("agent_before_settle", async (event, ctx) => {
 		const selected = workflowContext;
-		if (event.outcome !== "completed" || !event.context.canContinue || !selected?.completed ||
+		// Pi evaluates continuation again after this handler queues the next workflow.
+		if (event.outcome !== "completed" || !selected?.completed ||
 			selected.queuedPrompt || selected.sessionGeneration !== sessionGeneration) return;
 		const invocation = [...activeInvocations].find(([, phase]) => phase === "workflow" || phase === "create-workflow")?.[0];
 		if (invocation === undefined) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-pr",
-  "version": "6.2.6",
+  "version": "6.2.9",
   "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",