@oh-my-pi/pi-coding-agent 16.3.4 → 16.3.5

package/src/modes/controllers/mcp-command-controller.ts

@@ -8,7 +8,13 @@ import { type Component, replaceTabs, Spacer, Text } from "@oh-my-pi/pi-tui";
 import { getMCPConfigPath, getProjectDir } from "@oh-my-pi/pi-utils";
 import type { SourceMeta } from "../../capability/types";
 import { expandEnvVarsDeep } from "../../discovery/helpers";
-import { analyzeAuthError, discoverOAuthEndpoints, loadAllMCPConfigs, MCPManager } from "../../mcp";
+import {
+	analyzeAuthError,
+	discoverOAuthEndpoints,
+	fetchResourceMetadataScopes,
+	loadAllMCPConfigs,
+	MCPManager,
+} from "../../mcp";
 import { connectToServer, disconnectServer, listTools } from "../../mcp/client";
 import {
 	addMCPServer,
@@ -43,6 +49,7 @@ import {
 import type { MCPAuthConfig, MCPServerConfig, MCPServerConnection } from "../../mcp/types";
 import { shortenPath } from "../../tools/render-utils";
 import { urlHyperlinkAlways } from "../../tui";
+import { copyToClipboard } from "../../utils/clipboard";
 import { openPath } from "../../utils/open";
 import { ChatBlock } from "../components/chat-block";
 import { MCPAddWizard } from "../components/mcp-add-wizard";
@@ -73,23 +80,77 @@ function raceAbortSignal<T>(promise: Promise<T>, signal: AbortSignal, createErro
 	});
 }
 
-/** Renders the MCP OAuth fallback URL without hard-wrapping the copy target. */
+/**
+ * Minimum column budget for URL wrapping. Below this the terminal is
+ * effectively unusable, but we still emit chunks so no character is silently
+ * dropped and the user can widen and reflow.
+ */
+const MCP_AUTH_MIN_WRAP_WIDTH = 16;
+
+/**
+ * Wrap `url` into rows that each fit inside `width`, prefixed by a shared
+ * single-column indent so nested composition doesn't touch column 0. When the
+ * label + URL fit on one line, returns a single row; otherwise puts the label
+ * on its own row and slices the URL into fixed-width chunks. URL chunks are
+ * plain code points — browsers strip whitespace when pasted into the address
+ * bar, so a multi-row selection copies back to the intact URL.
+ */
+function wrapUrlRows(label: string, url: string, width: number): string[] {
+	const indent = " ";
+	const sanitized = replaceTabs(url);
+	const effective = Math.max(MCP_AUTH_MIN_WRAP_WIDTH, Math.trunc(width));
+	const inlineWidth = indent.length + label.length + 1 + sanitized.length;
+	if (inlineWidth <= effective) {
+		return [`${indent}${theme.fg("muted", `${label} ${sanitized}`)}`];
+	}
+	const chunkWidth = Math.max(1, effective - indent.length);
+	const rows: string[] = [`${indent}${theme.fg("muted", label)}`];
+	for (let i = 0; i < sanitized.length; i += chunkWidth) {
+		rows.push(`${indent}${theme.fg("muted", sanitized.slice(i, i + chunkWidth))}`);
+	}
+	return rows;
+}
+
+/**
+ * Renders the MCP OAuth fallback URL. Always shows the full authorization URL
+ * as the primary `Copy URL:` target — that works from any machine, including
+ * SSH/WSL/headless sessions where the OMP-hosted `/launch` loopback URL would
+ * resolve against the user's local browser and fail.
+ *
+ * The render is `width`-aware: on any viewport narrower than the composed row
+ * ({@link TUI#prepareLine} truncates anything wider with `Ellipsis.Omit`, no
+ * marker), the URL is hard-wrapped into width-fitted rows so the primary copy
+ * target can never silently lose trailing OAuth parameters — the failure mode
+ * that motivated #4418 in the first place. Browsers strip whitespace when a
+ * multi-row selection is pasted into the address bar, so the reassembled URL
+ * is byte-identical to what we rendered.
+ *
+ * When the flow's callback server hosts a short `launchUrl`, it is offered
+ * as an additional local shortcut for wide-terminal local users. The OSC 8
+ * hyperlink continues to carry the full URL for terminals that support it.
+ */
 export class MCPAuthorizationLinkPrompt implements Component {
-	readonly #url: string;
+	readonly #fullUrl: string;
+	readonly #launchUrl: string | undefined;
 
-	constructor(url: string) {
-		this.#url = url;
+	constructor(url: string, launchUrl?: string) {
+		this.#fullUrl = url;
+		this.#launchUrl = launchUrl && launchUrl !== url ? launchUrl : undefined;
 	}
 
 	invalidate(): void {}
 
-	render(_width: number): readonly string[] {
-		const link = urlHyperlinkAlways(this.#url, "Click here to authorize");
-		return [
+	render(width: number): readonly string[] {
+		const link = urlHyperlinkAlways(this.#fullUrl, "Click here to authorize");
+		const lines: string[] = [
 			` ${theme.fg("success", "Open authorization URL:")}`,
 			` ${theme.fg("accent", link)}`,
-			` ${theme.fg("muted", `Copy URL: ${replaceTabs(this.#url)}`)}`,
+			...wrapUrlRows("Copy URL:", this.#fullUrl, width),
 		];
+		if (this.#launchUrl) {
+			lines.push(...wrapUrlRows("Local shortcut (this machine only):", this.#launchUrl, width));
+		}
+		return lines;
 	}
 }
 
@@ -506,11 +567,18 @@ export class MCPCommandController {
 									finalConfig.url,
 									authResult.authServerUrl,
 									authResult.resourceMetadataUrl,
+									{ protectedScopes: authResult.scopes },
 								);
 							} catch {
 								// Ignore discovery error and handle below.
 							}
 						}
+						if (oauth && !oauth.scopes && authResult.resourceMetadataUrl) {
+							// JSON-error-body path skips `discoverOAuthEndpoints`; fetch the
+							// advertised protected-resource metadata for the required scopes.
+							const scopes = await fetchResourceMetadataScopes(authResult.resourceMetadataUrl);
+							if (scopes) oauth = { ...oauth, scopes };
+						}
 
 						if (!oauth) {
 							this.ctx.showError(
@@ -689,7 +757,7 @@ export class MCPCommandController {
 					stripSameOriginResource: opts?.stripSameOriginResource,
 				},
 				{
-					onAuth: (info: { url: string; instructions?: string }) => {
+					onAuth: (info: { url: string; launchUrl?: string; instructions?: string }) => {
 						// Show auth URL prominently in chat as one block
 						const block = new TranscriptBlock();
 						this.ctx.present(block);
@@ -707,24 +775,25 @@ export class MCPCommandController {
 						block.addChild(new Text(theme.fg("muted", MCP_MANUAL_LOGIN_TIP), 1, 0));
 						block.addChild(new Spacer(1));
 						block.addChild(new Text(theme.fg("accent", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"), 1, 0));
-						// Try to open browser automatically
-						try {
-							openPath(info.url);
-
-							// Show confirmation that browser should open
-							block.addChild(new Spacer(1));
-							block.addChild(new Text(theme.fg("success", "→ Opening browser automatically..."), 1, 0));
-							block.addChild(new Spacer(1));
-							block.addChild(new Text(theme.fg("muted", "Alternative if browser did not open:"), 1, 0));
-							block.addChild(new MCPAuthorizationLinkPrompt(info.url));
-							this.ctx.ui.requestRender();
-						} catch (_error) {
-							// Show error if browser doesn't open
-							block.addChild(new Spacer(1));
-							block.addChild(new Text(theme.fg("warning", "→ Could not open browser automatically"), 1, 0));
-							block.addChild(new MCPAuthorizationLinkPrompt(info.url));
-							this.ctx.ui.requestRender();
-						}
+						// `openPath` is best-effort — it logs spawn failures but never
+						// throws, so we always render the copy-URL fallback beneath the
+						// "attempting to open browser" line and no earlier try/catch is
+						// worth keeping.
+						openPath(info.url);
+						// Stage the FULL authorization URL on the clipboard via OSC 52.
+						// The full URL works from any machine (unlike `launchUrl`, which
+						// only resolves against the OMP host), and OSC 52 is a
+						// wire-level protocol — the terminal writes it to the user's
+						// LOCAL clipboard even when OMP is on a remote SSH box.
+						// Best-effort: falls back to the visible copy-URL rows below
+						// whether or not the terminal honors OSC 52.
+						void copyToClipboard(info.url).catch(() => {});
+						block.addChild(new Spacer(1));
+						block.addChild(new Text(theme.fg("success", "→ Attempting to open browser..."), 1, 0));
+						block.addChild(new Spacer(1));
+						block.addChild(new Text(theme.fg("muted", "Alternative if browser did not open:"), 1, 0));
+						block.addChild(new MCPAuthorizationLinkPrompt(info.url, info.launchUrl));
+						this.ctx.ui.requestRender();
 					},
 					onProgress: (message: string) => {
 						this.ctx.present([new Spacer(1), new Text(theme.fg("muted", message), 1, 0)]);
@@ -1010,7 +1079,15 @@ export class MCPCommandController {
 		let oauth = authResult.authType === "oauth" ? (authResult.oauth ?? null) : null;
 
 		if (!oauth && (config.type === "http" || config.type === "sse") && config.url) {
-			oauth = await discoverOAuthEndpoints(config.url, authResult.authServerUrl, authResult.resourceMetadataUrl);
+			oauth = await discoverOAuthEndpoints(config.url, authResult.authServerUrl, authResult.resourceMetadataUrl, {
+				protectedScopes: authResult.scopes,
+			});
+		}
+		if (oauth && !oauth.scopes && authResult.resourceMetadataUrl) {
+			// JSON-error-body path skips `discoverOAuthEndpoints`; fetch the
+			// advertised protected-resource metadata for the required scopes.
+			const scopes = await fetchResourceMetadataScopes(authResult.resourceMetadataUrl);
+			if (scopes) oauth = { ...oauth, scopes };
 		}
 
 		if (!oauth) {

package/src/modes/controllers/selector-controller.ts

@@ -1117,11 +1117,19 @@ export class SelectorController {
 		const useManualInput = PASTE_CODE_LOGIN_PROVIDERS.has(providerId);
 		try {
 			await this.ctx.session.modelRegistry.authStorage.login(providerId as OAuthProvider, {
-				onAuth: (info: { url: string; instructions?: string }) => {
+				onAuth: (info: { url: string; launchUrl?: string; instructions?: string }) => {
 					const block = new TranscriptBlock();
+					// Full URL first: works from any machine, including SSH boxes
+					// where the OMP-hosted `launchUrl` would resolve against the
+					// user's local browser and fail.
 					block.addChild(new Text(theme.fg("dim", info.url), 1, 0));
 					const hyperlink = `\x1b]8;;${info.url}\x07Click here to login\x1b]8;;\x07`;
 					block.addChild(new Text(theme.fg("accent", hyperlink), 1, 0));
+					if (info.launchUrl && info.launchUrl !== info.url) {
+						block.addChild(
+							new Text(theme.fg("dim", `Local shortcut (this machine only): ${info.launchUrl}`), 1, 0),
+						);
+					}
 					if (info.instructions) {
 						block.addChild(new Spacer(1));
 						block.addChild(new Text(theme.fg("warning", info.instructions), 1, 0));

package/src/modes/rpc/rpc-client.ts

@@ -724,17 +724,21 @@ export class RpcClient {
 	 * The server will emit an `open_url` extension_ui_request for the auth URL.
 	 * Resolves when login completes or rejects on failure.
 	 *
-	 * @param onOpenUrl Called when the server emits the auth URL. The host must open
-	 *   it in a browser for the callback-server OAuth flow to complete.
+	 * @param onOpenUrl Called when the server emits the auth URL. The host must
+	 *   open `url` in a browser for the callback-server OAuth flow to complete.
+	 *   When the flow's callback server hosts a `/launch` redirect, `launchUrl`
+	 *   is a short loopback URL that 302s to `url` — hosts SHOULD surface it as
+	 *   the truncation-safe copy target so terminal viewport clipping cannot
+	 *   corrupt trailing OAuth query parameters (e.g. `code_challenge_method=S256`).
 	 */
 	async login(
 		providerId: string,
-		options?: { onOpenUrl?: (url: string, instructions?: string) => void },
+		options?: { onOpenUrl?: (url: string, instructions?: string, launchUrl?: string) => void },
 	): Promise<{ providerId: string }> {
 		const { onOpenUrl } = options ?? {};
 		const listener = onOpenUrl
 			? (req: RpcExtensionUIRequest) => {
-					if (req.method === "open_url") onOpenUrl(req.url, req.instructions);
+					if (req.method === "open_url") onOpenUrl(req.url, req.instructions, req.launchUrl);
 				}
 			: undefined;
 		if (listener) this.#extensionUiListeners.add(listener);

package/src/modes/rpc/rpc-mode.ts

@@ -1213,6 +1213,7 @@ export async function runRpcMode(
 								id: Snowflake.next() as string,
 								method: "open_url",
 								url: info.url,
+								launchUrl: info.launchUrl,
 								instructions: info.instructions,
 							} as RpcExtensionUIRequest);
 						},

package/src/modes/rpc/rpc-types.ts

@@ -370,7 +370,19 @@ export type RpcExtensionUIRequest =
 	  }
 	| { type: "extension_ui_request"; id: string; method: "setTitle"; title: string }
 	| { type: "extension_ui_request"; id: string; method: "set_editor_text"; text: string }
-	| { type: "extension_ui_request"; id: string; method: "open_url"; url: string; instructions?: string };
+	| {
+			type: "extension_ui_request";
+			id: string;
+			method: "open_url";
+			url: string;
+			/**
+			 * Short loopback URL that 302-redirects to {@link url}. When present,
+			 * hosts SHOULD surface it as the copy target so terminal viewport
+			 * truncation cannot corrupt OAuth query parameters on the full URL.
+			 */
+			launchUrl?: string;
+			instructions?: string;
+	  };
 
 // ============================================================================
 // Host Tool Frames (bidirectional)

package/src/modes/setup-wizard/scenes/sign-in.ts

@@ -80,6 +80,7 @@ export class SignInTab implements SetupTab {
 	#selector: OAuthSelectorComponent;
 	#statusLines: string[] = [];
 	#authUrl: string | undefined;
+	#authLaunchUrl: string | undefined;
 	#prompt: PromptState | undefined;
 	#promptResolve: ((value: string) => void) | undefined;
 	#loginAbort: AbortController | undefined;
@@ -146,6 +147,9 @@ export class SignInTab implements SetupTab {
 				theme.fg("accent", `Browser login: ${loginUrlLink(this.#authUrl)} ${loginCopyHint()}`),
 				...urlLines.slice(0, 2),
 			);
+			if (this.#authLaunchUrl) {
+				lines.push(theme.fg("dim", `Local shortcut (this machine only): ${this.#authLaunchUrl}`));
+			}
 		}
 		if (this.#prompt) {
 			lines.push(theme.fg("warning", this.#prompt.message));
@@ -182,6 +186,7 @@ export class SignInTab implements SetupTab {
 		this.#loggingInProvider = providerId;
 		this.#statusLines = [theme.fg("dim", "Starting OAuth flow…")];
 		this.#authUrl = undefined;
+		this.#authLaunchUrl = undefined;
 		this.#loginAbort = new AbortController();
 		this.host.restoreFocus();
 		this.host.requestRender();
@@ -189,7 +194,17 @@ export class SignInTab implements SetupTab {
 			await this.#authStorage.login(providerId as OAuthProvider, {
 				signal: this.#loginAbort.signal,
 				onAuth: info => {
+					// Store the full authorization URL as the primary copy/display
+					// target: it works from any machine, including SSH boxes where
+					// the OMP-hosted `launchUrl` would resolve against the user's
+					// local browser and fail. The wizard render uses
+					// `wrapTextWithAnsi`, so long URLs wrap across lines rather
+					// than getting truncated — the RFC 7636 §4.3 PKCE-downgrade
+					// bug that motivated `launchUrl` is unreachable through this
+					// surface. `launchUrl` is still surfaced as an optional local
+					// shortcut for wide-terminal local users.
 					this.#authUrl = info.url;
+					this.#authLaunchUrl = info.launchUrl && info.launchUrl !== info.url ? info.launchUrl : undefined;
 					this.#statusLines = [];
 					if (info.instructions) {
 						this.#statusLines.push(theme.fg("warning", info.instructions));
@@ -216,6 +231,7 @@ export class SignInTab implements SetupTab {
 				theme.fg("dim", `Credentials saved to ${getAgentDbPath()}`),
 			];
 			this.#authUrl = undefined;
+			this.#authLaunchUrl = undefined;
 			this.#loggingInProvider = undefined;
 			this.#loginAbort = undefined;
 			this.#selector.stopValidation();
@@ -227,6 +243,7 @@ export class SignInTab implements SetupTab {
 			if (this.#loginAbort?.signal.aborted) {
 				this.#statusLines = [theme.fg("dim", "Login cancelled.")];
 				this.#authUrl = undefined;
+				this.#authLaunchUrl = undefined;
 			} else {
 				const message = error instanceof Error ? error.message : String(error);
 				this.#statusLines = [
@@ -234,6 +251,7 @@ export class SignInTab implements SetupTab {
 					theme.fg("dim", "Choose another provider or press Esc to continue."),
 				];
 				this.#authUrl = undefined;
+				this.#authLaunchUrl = undefined;
 			}
 			this.#loggingInProvider = undefined;
 			this.#loginAbort = undefined;

package/src/prompts/tools/read.md

@@ -67,7 +67,7 @@ For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
 
 # Internal URIs
 
-All URI schemes take the same line selectors. `artifact://<id>` recovers full output a bash/eval/tool result spilled or truncated.
+All URI schemes take the same line selectors. `artifact://<id>` recovers spilled output; large artifacts block unbounded `:raw`, so page with `artifact://<id>:N-M` / `artifact://<id>:raw:N-M` and use the reported artifact file path for search/copy workflows.
 
 `ssh://host/<absolute-path>` reads a remote text file (UTF-8, ≤1 MiB) or lists a directory one level deep, on a pre-configured SSH host or `~/.ssh/config` alias; `ssh://host/` lists the remote root and bare `ssh://` lists the configured hosts. Files are also writable via `write` and searchable via `search`; a directory only lists (`search` refuses a directory, `write` refuses to overwrite one). A literal `:`, `?`, or `#` in the remote path must be percent-encoded (`%3A`/`%3F`/`%23`) — a trailing `:sel` is read as a line selector, and `?`/`#` start a URL query/fragment. Requires a POSIX login shell (`sh`/`bash`/`zsh`); a Windows host or a non-POSIX shell (fish, csh/tcsh) is rejected — use the `ssh` tool there.
 

package/src/subprocess/worker-runtime.ts

@@ -1,3 +1,4 @@
+import * as fsp from "node:fs/promises";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 import type { ProgressInfo } from "@huggingface/transformers";
@@ -27,6 +28,15 @@ import packageJson from "../../package.json" with { type: "json" };
 
 export const TRANSFORMERS_PACKAGE = "@huggingface/transformers";
 const COMPILED_TRANSFORMERS_VERSION = process.env.PI_TINY_TRANSFORMERS_VERSION;
+const ONNX_RUNTIME_NODE_PACKAGE = "onnxruntime-node";
+const ONNX_RUNTIME_CUDA_INSTALL = "cuda12";
+const ONNX_RUNTIME_CUDA_PROVIDER_FILES = [
+	"libonnxruntime_providers_cuda.so",
+	"libonnxruntime_providers_shared.so",
+	"libonnxruntime_providers_tensorrt.so",
+] as const;
+const LINUX_X64_ONNX_RUNTIME_CUDA_PROVIDER_DIR = path.join("bin", "napi-v6", "linux", "x64");
+
 const sourceRequire = createRequire(import.meta.url);
 
 // ── Error serialization ─────────────────────────────────────────────
@@ -162,6 +172,87 @@ export async function installSharpStubResolver(runtimeDir: string): Promise<stri
 	return nodeModules;
 }
 
+function shouldInstallOnnxRuntimeCudaProviders(device: string | undefined): boolean {
+	const normalized = device?.trim().toLowerCase();
+	return (
+		process.platform === "linux" &&
+		process.arch === "x64" &&
+		(normalized === "cuda" || normalized === "gpu" || normalized === "auto")
+	);
+}
+
+async function missingOnnxRuntimeCudaProviderFiles(binDir: string): Promise<string[]> {
+	const missing: string[] = [];
+	for (const file of ONNX_RUNTIME_CUDA_PROVIDER_FILES) {
+		try {
+			await fsp.access(path.join(binDir, file));
+		} catch {
+			missing.push(file);
+		}
+	}
+	return missing;
+}
+
+async function readPipe(stream: ReadableStream<Uint8Array> | null): Promise<string> {
+	if (!stream) return "";
+	return new Response(stream).text();
+}
+
+async function installOnnxRuntimeCudaProviders(packageDir: string, runtimeDir: string, binDir: string): Promise<void> {
+	const script = path.join(packageDir, "script", "install.js");
+	try {
+		await fsp.access(script);
+	} catch {
+		throw new Error(
+			`ONNX Runtime CUDA provider binaries are missing from ${binDir}, and ${script} is unavailable. Remove the tiny-model side runtime cache at ${runtimeDir} and retry.`,
+		);
+	}
+
+	const proc = Bun.spawn([process.execPath, script], {
+		cwd: runtimeDir,
+		env: { ...Bun.env, BUN_BE_BUN: "1", ONNXRUNTIME_NODE_INSTALL: ONNX_RUNTIME_CUDA_INSTALL },
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const [stdout, stderr, exitCode] = await Promise.all([
+		readPipe(proc.stdout as ReadableStream<Uint8Array> | null),
+		readPipe(proc.stderr as ReadableStream<Uint8Array> | null),
+		proc.exited,
+	]);
+	if (exitCode !== 0) {
+		const output = `${stdout}\n${stderr}`.trim();
+		throw new Error(
+			`Failed to install ONNX Runtime CUDA provider binaries into ${binDir} with ${process.execPath} ${script} (exit ${exitCode}). Remove the tiny-model side runtime cache at ${runtimeDir} and retry with network access. ${output}`,
+		);
+	}
+}
+
+/**
+ * Repairs the compiled Transformers side runtime when CUDA was requested and
+ * Bun skipped `onnxruntime-node`'s NuGet sidecar install.
+ */
+export async function ensureOnnxRuntimeCudaProviders(
+	runtimeDir: string,
+	device = process.env.PI_TINY_DEVICE,
+): Promise<void> {
+	if (!shouldInstallOnnxRuntimeCudaProviders(device)) return;
+	const nodeModules = path.join(runtimeDir, "node_modules");
+	const manifest = resolveRuntimeModule(nodeModules, `${ONNX_RUNTIME_NODE_PACKAGE}/package.json`);
+	if (!manifest)
+		throw new Error(`Unable to resolve ${ONNX_RUNTIME_NODE_PACKAGE} in compiled runtime at ${nodeModules}`);
+	const packageDir = path.dirname(manifest);
+	const binDir = path.join(packageDir, LINUX_X64_ONNX_RUNTIME_CUDA_PROVIDER_DIR);
+	const missing = await missingOnnxRuntimeCudaProviderFiles(binDir);
+	if (missing.length === 0) return;
+
+	await installOnnxRuntimeCudaProviders(packageDir, runtimeDir, binDir);
+	const stillMissing = await missingOnnxRuntimeCudaProviderFiles(binDir);
+	if (stillMissing.length === 0) return;
+	throw new Error(
+		`ONNX Runtime CUDA provider install completed but ${stillMissing.join(", ")} are still missing from ${binDir}. Remove the tiny-model side runtime cache at ${runtimeDir} and retry.`,
+	);
+}
+
 /**
  * Prepare a freshly-installed compiled runtime for loading and return the
  * absolute entrypoint of `packageName` to `require`.
@@ -211,6 +302,114 @@ interface ConfigurableTransformers {
 	LogLevel: { ERROR: unknown };
 }
 
+export interface TransformersRuntimeMetadata {
+	__ompRuntimeNodeModules?: string;
+	__ompTransformersEntry?: string;
+	__ompCudaRepairError?: string;
+}
+
+function attachTransformersRuntimeMetadata<T extends ConfigurableTransformers>(
+	transformers: T,
+	metadata: TransformersRuntimeMetadata,
+): T {
+	const runtime = transformers as T & TransformersRuntimeMetadata;
+	runtime.__ompRuntimeNodeModules = metadata.__ompRuntimeNodeModules;
+	runtime.__ompTransformersEntry = metadata.__ompTransformersEntry;
+	runtime.__ompCudaRepairError = metadata.__ompCudaRepairError;
+	return runtime;
+}
+
+const TRANSITIVE_CUDA_LIBRARY_RE =
+	/\b(lib(?:cu|nv)[A-Za-z0-9_.+-]*\.so(?:\.[0-9]+)*)\b[^:\n]*:\s*cannot open shared object file/iu;
+const CUDA_DEVICE_UNAVAILABLE_RE = /\bCUDA failure 100\b|no CUDA-capable device is detected|cudaSetDevice|GPU=-1/iu;
+
+function cudaDeviceUnavailable(error: unknown): boolean {
+	return CUDA_DEVICE_UNAVAILABLE_RE.test(errorText(error));
+}
+
+function missingCudaLibrary(error: unknown): string | undefined {
+	return TRANSITIVE_CUDA_LIBRARY_RE.exec(errorText(error))?.[1];
+}
+
+function cudaFailureCause(
+	metadata: TransformersRuntimeMetadata,
+	error: unknown,
+	missingFiles: readonly string[],
+): string {
+	if (metadata.__ompCudaRepairError) {
+		return `ONNX Runtime CUDA provider install failed: ${metadata.__ompCudaRepairError}`;
+	}
+	if (missingFiles.length > 0) return `missing ONNX Runtime CUDA provider file(s): ${missingFiles.join(", ")}`;
+	const missingLibrary = missingCudaLibrary(error);
+	if (missingLibrary) return `${missingLibrary}: cannot open shared object file`;
+	if (cudaDeviceUnavailable(error)) {
+		return "CUDA provider files are present; CUDA runtime reports no CUDA-capable device";
+	}
+	return "CUDA provider files are present; inspect the original ONNX Runtime CUDA error";
+}
+
+function cudaFailureHint(
+	metadata: TransformersRuntimeMetadata,
+	error: unknown,
+	missingFiles: readonly string[],
+): string {
+	if (metadata.__ompCudaRepairError) {
+		return "restore network access to nuget.org (or pre-populate the tiny side runtime) and rerun; CPU inference remained available";
+	}
+	if (missingFiles.length > 0) return "reinstall the tiny side runtime with ONNX Runtime postinstall enabled";
+	if (missingCudaLibrary(error)) {
+		return "install the matching CUDA/cuDNN shared libraries and expose them on the dynamic loader path";
+	}
+	if (cudaDeviceUnavailable(error)) {
+		return "make the NVIDIA GPU visible to this process/session, or use providers.tinyModelDevice=default/cpu";
+	}
+	return "check the host CUDA driver, device visibility, and ONNX Runtime CUDA compatibility";
+}
+
+function resolveOnnxRuntimePackageDir(metadata: TransformersRuntimeMetadata): string | null {
+	const entry = metadata.__ompTransformersEntry;
+	if (entry) {
+		try {
+			return path.dirname(createRequire(entry).resolve(`${ONNX_RUNTIME_NODE_PACKAGE}/package.json`));
+		} catch {
+			// Fall through to the side-runtime resolver below.
+		}
+	}
+	const nodeModules = metadata.__ompRuntimeNodeModules;
+	if (!nodeModules) return null;
+	const manifest = resolveRuntimeModule(nodeModules, `${ONNX_RUNTIME_NODE_PACKAGE}/package.json`);
+	return manifest ? path.dirname(manifest) : null;
+}
+
+export async function formatOnnxRuntimeCudaDiagnostics(
+	metadata: TransformersRuntimeMetadata,
+	requestedDevice: string,
+	error: unknown,
+): Promise<string | null> {
+	const device = requestedDevice.trim().toLowerCase();
+	if (device !== "cuda" && device !== "gpu" && device !== "auto") return null;
+	if (process.platform !== "linux" || process.arch !== "x64") return null;
+	const packageDir = resolveOnnxRuntimePackageDir(metadata);
+	if (!packageDir) {
+		return [
+			"ONNX Runtime CUDA diagnostics:",
+			`  PI_TINY_DEVICE=${requestedDevice} requested CUDAExecutionProvider`,
+			"  cause: unable to resolve onnxruntime-node in the tiny-model runtime",
+		].join("\n");
+	}
+	const binDir = path.join(packageDir, LINUX_X64_ONNX_RUNTIME_CUDA_PROVIDER_DIR);
+	const missingFiles = await missingOnnxRuntimeCudaProviderFiles(binDir);
+	const sideRuntime = metadata.__ompRuntimeNodeModules;
+	const lines = [
+		"ONNX Runtime CUDA diagnostics:",
+		`  PI_TINY_DEVICE=${requestedDevice} requested CUDAExecutionProvider`,
+		sideRuntime ? `  side runtime: ${sideRuntime}` : `  onnxruntime-node: ${packageDir}`,
+		`  cause: ${cudaFailureCause(metadata, error, missingFiles)}`,
+	];
+	lines.push(`  hint: ${cudaFailureHint(metadata, error, missingFiles)}`);
+	return lines.join("\n");
+}
+
 function configureTransformers<T extends ConfigurableTransformers>(transformers: T): T {
 	transformers.env.cacheDir = getTinyModelsCacheDir();
 	transformers.env.allowLocalModels = false;
@@ -251,7 +450,12 @@ export function loadTransformersRuntime<T extends ConfigurableTransformers, K>(
 	runtimeDir: () => string,
 ): Promise<T> {
 	return holder.load(async () => {
-		if (!isCompiledBinary()) return configureTransformers(sourceRequire(TRANSFORMERS_PACKAGE) as T);
+		if (!isCompiledBinary()) {
+			const entry = sourceRequire.resolve(TRANSFORMERS_PACKAGE);
+			return attachTransformersRuntimeMetadata(configureTransformers(sourceRequire(entry) as T), {
+				__ompTransformersEntry: entry,
+			});
+		}
 		const installedDir = await ensureRuntimeInstalled({
 			runtimeDir: runtimeDir(),
 			install: {
@@ -270,8 +474,21 @@ export function loadTransformersRuntime<T extends ConfigurableTransformers, K>(
 					},
 				}),
 		});
+		let cudaRepairError: string | undefined;
+		try {
+			await ensureOnnxRuntimeCudaProviders(installedDir);
+		} catch (repairError) {
+			// Deferred failure: keep loading Transformers so `loadPipelineWithDeviceFallback`
+			// still gets its CUDA→CPU retry. The error is surfaced through the CUDA
+			// diagnostics attached to the runtime metadata.
+			cudaRepairError = errorMessage(repairError);
+		}
 		const entry = await prepareCompiledRuntime(installedDir, TRANSFORMERS_PACKAGE);
 		const require_ = createRequire(entry);
-		return configureTransformers(require_(entry) as T);
+		return attachTransformersRuntimeMetadata(configureTransformers(require_(entry) as T), {
+			__ompRuntimeNodeModules: path.join(installedDir, "node_modules"),
+			__ompTransformersEntry: entry,
+			__ompCudaRepairError: cudaRepairError,
+		});
 	});
 }

package/src/task/worktree.ts

@@ -855,18 +855,40 @@ export async function mergeTaskBranches(
 				try {
 					const target = baseSha ? `${baseSha}..${branchName}` : branchName;
 					await git.cherryPick(repoRoot, target);
-				} catch (err) {
+				} catch (initialErr) {
+					// Empty cherry-picks are not conflicts: a commit whose net
+					// effect is already on HEAD (redundant change, or 3-way
+					// merge auto-resolved to HEAD) leaves the sequencer stopped
+					// with a "The previous cherry-pick is now empty" message.
+					// Advance past every consecutive empty with `--skip` so the
+					// remaining non-redundant commits in the range still land.
+					// A genuine conflict (unmerged files, no "now empty"
+					// message) falls through to the abort path below.
+					let cursor: unknown = initialErr;
+					while (git.cherryPick.isEmptyError(cursor)) {
+						try {
+							await git.cherryPick.skip(repoRoot);
+							cursor = undefined;
+							break;
+						} catch (skipErr) {
+							cursor = skipErr;
+						}
+					}
+					if (cursor === undefined) {
+						merged.push(branchName);
+						continue;
+					}
 					try {
 						await git.cherryPick.abort(repoRoot);
 					} catch {
 						/* no state to abort */
 					}
 					const stderr =
-						err instanceof git.GitCommandError
-							? err.result.stderr.trim()
-							: err instanceof Error
-								? err.message
-								: String(err);
+						cursor instanceof git.GitCommandError
+							? cursor.result.stderr.trim()
+							: cursor instanceof Error
+								? cursor.message
+								: String(cursor);
 					failed.push(branchName);
 					conflictResult = {
 						merged,