@oh-my-pi/pi-coding-agent 17.0.1 → 17.0.3

package/src/extensibility/utils.ts

@@ -44,7 +44,7 @@ export function createNoOpUIContext(): HookUIContext {
 }
 
 /**
- * Raised by {@link withExitGuard} when a guarded callback synchronously
+ * Raised by {@link withHostGuard} when a guarded callback synchronously
  * attempts to terminate the host process. Callers catch this like any other
  * load-time failure so the extension/hook is skipped with a logged error
  * instead of taking the CLI down with it.
@@ -66,22 +66,46 @@ export class ExtensionExitError extends Error {
 
 type ExitAliasName = "process.exit" | "process.reallyExit";
 
-let exitGuardDepth = 0;
-let exitGuardOriginalProcessExit: typeof process.exit | null = null;
-let exitGuardOriginalReallyExit: typeof process.reallyExit | null = null;
+/**
+ * stdin events a loaded module must not be allowed to leave hijacked. A
+ * top-level `new StdioServerTransport()` (or a bare `process.stdin.resume()`)
+ * inside a `~/.claude/tools` MCP server attaches a `data` consumer and puts the
+ * shared stdin into flowing mode; Bun delivers one `data` event to that
+ * consumer and the TUI's own listener (attached later in `terminal.start()`)
+ * then never re-arms — every keypress after the first is swallowed (#5618).
+ */
+const HOST_GUARD_STDIN_EVENTS = ["data", "readable", "end", "close", "error"] as const;
+type StdinGuardEvent = (typeof HOST_GUARD_STDIN_EVENTS)[number];
+type StdinGuardListener = (...args: unknown[]) => void;
+
+let hostGuardDepth = 0;
+let hostGuardOriginalProcessExit: typeof process.exit | null = null;
+let hostGuardOriginalReallyExit: typeof process.reallyExit | null = null;
+let hostGuardStdinListeners: Record<StdinGuardEvent, StdinGuardListener[]> | null = null;
+let hostGuardStdinWasPaused = false;
+let hostGuardStdinWasRaw = false;
 
 /**
- * Run `fn` with hard-exit APIs patched so any synchronous attempt to terminate
- * the host raises {@link ExtensionExitError} instead. Restored in `finally`.
+ * Run `fn` with host-owned process state fenced off from third-party module
+ * evaluation, restored in `finally`. Guards the dynamic-import and
+ * factory-invocation sites that load extension / hook / tool / plugin modules
+ * from user directories (including Claude Code's `~/.claude/tools`, which OMP
+ * slurps wholesale). Two hazards are neutralized:
  *
- * Guards the dynamic-import and factory-invocation sites that load third-party
- * extension / hook modules — a `process.exit(0)` or `process.reallyExit(0)` in
- * a stranger's script (e.g. a Codex hook script that happens to live next to
- * OMP-shaped modules) would otherwise kill OMP during startup with no error
- * surface, since `try/catch` cannot intercept a synchronous exit.
+ * - **Hard exit.** `process.exit(0)` / `process.reallyExit(0)` in a stranger's
+ *   script (e.g. a CLI-shaped module with `main()` at the bottom) would kill
+ *   OMP during startup with no error surface, since `try/catch` cannot
+ *   intercept a synchronous exit. Both are patched to throw
+ *   {@link ExtensionExitError} instead.
+ * - **stdin hijack.** A module that attaches a stdin consumer at evaluation
+ *   time (an MCP `StdioServerTransport`, or a bare `resume()`) steals Bun's
+ *   single stdin reader, so the TUI goes permanently deaf after one keypress
+ *   (#5618). Any `data`/`readable`/`end`/`close`/`error` listener the module
+ *   adds is removed, and the stream's paused and raw-mode state is restored to
+ *   the pre-load snapshot.
  *
  * Nested and concurrent guard windows are safe: only the outermost guard
- * restores the real hard-exit APIs.
+ * snapshots and restores host state.
  */
 function guardedExit(alias: ExitAliasName): (code?: number | string) => never {
 	return (code?: number | string): never => {
@@ -89,29 +113,71 @@ function guardedExit(alias: ExitAliasName): (code?: number | string) => never {
 	};
 }
 
-export async function withExitGuard<T>(fn: () => Promise<T>): Promise<T> {
-	if (exitGuardDepth === 0) {
-		exitGuardOriginalProcessExit = process.exit;
+export async function withHostGuard<T>(fn: () => Promise<T>): Promise<T> {
+	if (hostGuardDepth === 0) {
+		hostGuardOriginalProcessExit = process.exit;
 		process.exit = guardedExit("process.exit") as typeof process.exit;
 
 		if (typeof process.reallyExit === "function") {
-			exitGuardOriginalReallyExit = process.reallyExit;
+			hostGuardOriginalReallyExit = process.reallyExit;
 			process.reallyExit = guardedExit("process.reallyExit") as typeof process.reallyExit;
 		}
+
+		const stdin = process.stdin;
+		hostGuardStdinWasPaused = stdin.isPaused();
+		hostGuardStdinWasRaw = stdin.isRaw ?? false;
+		const snapshot = {} as Record<StdinGuardEvent, StdinGuardListener[]>;
+		for (const event of HOST_GUARD_STDIN_EVENTS) {
+			snapshot[event] = stdin.rawListeners(event) as StdinGuardListener[];
+		}
+		hostGuardStdinListeners = snapshot;
 	}
-	exitGuardDepth++;
+	hostGuardDepth++;
 	try {
 		return await fn();
 	} finally {
-		exitGuardDepth--;
-		if (exitGuardDepth === 0) {
-			if (exitGuardOriginalProcessExit) {
-				process.exit = exitGuardOriginalProcessExit;
-				exitGuardOriginalProcessExit = null;
+		hostGuardDepth--;
+		if (hostGuardDepth === 0) {
+			if (hostGuardOriginalProcessExit) {
+				process.exit = hostGuardOriginalProcessExit;
+				hostGuardOriginalProcessExit = null;
+			}
+			if (hostGuardOriginalReallyExit) {
+				process.reallyExit = hostGuardOriginalReallyExit;
+				hostGuardOriginalReallyExit = null;
 			}
-			if (exitGuardOriginalReallyExit) {
-				process.reallyExit = exitGuardOriginalReallyExit;
-				exitGuardOriginalReallyExit = null;
+			if (hostGuardStdinListeners) {
+				const stdin = process.stdin;
+				for (const event of HOST_GUARD_STDIN_EVENTS) {
+					const before = hostGuardStdinListeners[event];
+					// Reconcile the stream back to the pre-load snapshot: drop any
+					// listener the module added, and reinstate any snapshot listener
+					// it removed (e.g. a factory calling `removeAllListeners("data")`
+					// would otherwise permanently strip ProcessTerminal's input
+					// handler, leaving the parent TUI deaf). removeAllListeners then
+					// re-adding in snapshot order restores both membership and order.
+					const current = stdin.rawListeners(event) as StdinGuardListener[];
+					const differs =
+						current.length !== before.length || current.some((listener, index) => listener !== before[index]);
+					if (!differs) continue;
+					stdin.removeAllListeners(event);
+					for (const listener of before) {
+						stdin.on(event, listener);
+					}
+				}
+				if (
+					stdin.isTTY &&
+					typeof stdin.setRawMode === "function" &&
+					(stdin.isRaw ?? false) !== hostGuardStdinWasRaw
+				) {
+					stdin.setRawMode(hostGuardStdinWasRaw);
+				}
+				if (hostGuardStdinWasPaused && !stdin.isPaused()) {
+					stdin.pause();
+				} else if (!hostGuardStdinWasPaused && stdin.isPaused()) {
+					stdin.resume();
+				}
+				hostGuardStdinListeners = null;
 			}
 		}
 	}

package/src/irc/bus.ts

@@ -127,12 +127,31 @@ export class IrcBus {
 			};
 		}
 
+		// A `parked` recipient always needs the lifecycle to revive it — this is
+		// read from *this* bus's registry, so it holds for any registry. The
+		// mid-park / adopted checks below query the lifecycle's own state, which
+		// only describes the registry it manages: consult them only when the
+		// lifecycle owns this bus's registry, otherwise a custom-registry bus
+		// (fallen back to the global manager) would gate a live recipient on
+		// unrelated global park state. Main/non-adopted live peers skip the gate,
+		// and pending waiters still win without a session.
+		const lifecycle = this.#lifecycle();
+		const lifecycleOwnsRegistry = lifecycle.manages(this.#registry);
+		const needsLifecycleGate =
+			ref.status === "parked" ||
+			(lifecycleOwnsRegistry && (lifecycle.isParking(message.to) || lifecycle.has(message.to)));
+
+		const priorSession = ref.session;
 		let revived = false;
-		if (ref.status === "parked") {
+		if (needsLifecycleGate) {
 			try {
-				await this.#lifecycle().ensureLive(message.to);
-				revived = true;
+				const liveSession = await lifecycle.ensureLive(message.to);
+				// Revival = we did not keep the same live instance (parked start, or
+				// park completed and a fresh session was rebuilt).
+				revived = !priorSession || liveSession !== priorSession;
 			} catch (error) {
+				// Not revivable / released / revive failed. Do not buffer: a permanent
+				// failure must not inflate unread counts or pretend delivery is pending.
 				return {
 					to: message.to,
 					outcome: "failed",

package/src/launch/broker.ts

@@ -3,7 +3,7 @@ import * as net from "node:net";
 import * as os from "node:os";
 import * as path from "node:path";
 import { Process, type PtyRunResult, PtySession } from "@oh-my-pi/pi-natives";
-import { isEexist, isEnoent, logger, postmortem, sanitizeText } from "@oh-my-pi/pi-utils";
+import { isEexist, isEnoent, logger, postmortem, procmgr, sanitizeText } from "@oh-my-pi/pi-utils";
 import { truncateHead, truncateHeadBytes, truncateTail, truncateTailBytes } from "../session/streaming-output";
 import { workerEnvFromParent } from "../subprocess/worker-client";
 import { daemonBrokerEndpoint } from "./paths";
@@ -555,7 +555,8 @@ class DaemonBroker {
 				`printf '%s' "$$" > ${quoteShellArg(pidPath)}`,
 				`exec ${argv.map(quoteShellArg).join(" ")}`,
 			].join("; ");
-			run = session.start({ command, shell: process.env.SHELL, ...options }, onChunk);
+			const shell = procmgr.getShellConfig().shell;
+			run = session.start({ command, shell, ...options }, onChunk);
 		}
 		void run
 			.then(result => this.#onPtyExit(record, generation, result))

package/src/launch/client.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as net from "node:net";
 import * as os from "node:os";
 import * as path from "node:path";
-import { isEexist, isEnoent, postmortem } from "@oh-my-pi/pi-utils";
+import { isEexist, isEisdir, isEnoent, postmortem } from "@oh-my-pi/pi-utils";
 import { resolveWorkerSpawnCmd, workerEnvFromParent } from "../subprocess/worker-client";
 import { daemonBrokerEndpoint, daemonRuntimeDir } from "./paths";
 import {
@@ -49,7 +49,7 @@ async function canonicalProjectDir(projectDir: string): Promise<string> {
 	try {
 		return await fs.realpath(resolved);
 	} catch (error) {
-		if (isEnoent(error)) return resolved;
+		if (isEnoent(error) || isEisdir(error)) return resolved;
 		throw error;
 	}
 }

package/src/launch/presence.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { isEnoent, postmortem } from "@oh-my-pi/pi-utils";
+import { isEisdir, isEnoent, postmortem } from "@oh-my-pi/pi-utils";
 import { daemonRuntimeDir } from "./paths";
 
 const CLIENTS_DIR = "clients";
@@ -15,7 +15,7 @@ async function canonicalProjectDir(projectDir: string): Promise<string> {
 	try {
 		return await fs.realpath(resolved);
 	} catch (error) {
-		if (isEnoent(error)) return resolved;
+		if (isEnoent(error) || isEisdir(error)) return resolved;
 		throw error;
 	}
 }

package/src/lsp/client.ts

@@ -142,6 +142,9 @@ const CLIENT_CAPABILITIES = {
 			codeDescriptionSupport: true,
 			dataSupport: true,
 		},
+		diagnostic: {
+			dynamicRegistration: true,
+		},
 	},
 	window: {
 		workDoneProgress: true,
@@ -428,7 +431,7 @@ async function handleConfigurationRequest(client: LspClient, message: LspJsonRpc
 	const items = params?.items ?? [];
 	const result = items.map(item => {
 		const section = item.section ?? "";
-		return client.config.settings?.[section] ?? {};
+		return client.config.settings?.[section] ?? null;
 	});
 	await sendResponse(client, message.id, result, "workspace/configuration");
 }
@@ -456,6 +459,58 @@ async function handleApplyEditRequest(client: LspClient, message: LspJsonRpcRequ
 	}
 }
 
+interface DynamicCapabilityRegistration {
+	id?: unknown;
+	method?: unknown;
+}
+
+interface DynamicCapabilityParams {
+	registrations?: DynamicCapabilityRegistration[];
+	unregisterations?: DynamicCapabilityRegistration[];
+	unregistrations?: DynamicCapabilityRegistration[];
+}
+
+function updateDynamicCapabilities(client: LspClient, message: LspJsonRpcRequest): void {
+	const params = message.params as DynamicCapabilityParams;
+	if (message.method === "client/registerCapability") {
+		if (!Array.isArray(params.registrations)) return;
+		let registrations = client.dynamicCapabilityRegistrations;
+		if (!registrations) {
+			registrations = new Map();
+			client.dynamicCapabilityRegistrations = registrations;
+		}
+		for (const registration of params.registrations) {
+			if (typeof registration.id === "string" && typeof registration.method === "string") {
+				registrations.set(registration.id, registration.method);
+			}
+		}
+		return;
+	}
+
+	const registrations = client.dynamicCapabilityRegistrations;
+	if (!registrations) return;
+	const unregistrations = params.unregisterations ?? params.unregistrations;
+	if (!Array.isArray(unregistrations)) return;
+	for (const registration of unregistrations) {
+		if (typeof registration.id === "string") {
+			registrations.delete(registration.id);
+		}
+	}
+}
+
+/** Whether the server advertised LSP 3.17 document diagnostic pulls statically or through registration. */
+export function supportsDocumentDiagnostics(client: LspClient): boolean {
+	const staticProvider = client.serverCapabilities?.diagnosticProvider;
+	if (staticProvider) return true;
+
+	const registrations = client.dynamicCapabilityRegistrations;
+	if (!registrations) return false;
+	for (const method of registrations.values()) {
+		if (method === "textDocument/diagnostic") return true;
+	}
+	return false;
+}
+
 /**
  * Respond to a server-initiated request.
  */
@@ -478,6 +533,7 @@ async function handleServerRequest(client: LspClient, message: LspJsonRpcRequest
 		return;
 	}
 	if (message.method === "client/registerCapability" || message.method === "client/unregisterCapability") {
+		updateDynamicCapabilities(client, message);
 		// Some servers block semantic requests until dynamic registration succeeds.
 		await sendResponse(client, message.id, null, message.method);
 		return;
@@ -685,6 +741,7 @@ export async function getOrCreateClient(
 			requestId: 0,
 			diagnostics: new Map(),
 			diagnosticsVersion: 0,
+			dynamicCapabilityRegistrations: new Map(),
 			openFiles: new Map(),
 			pendingRequests: new Map(),
 			messageBuffer: new Uint8Array(0),

package/src/lsp/index.ts

@@ -28,6 +28,7 @@ import {
 	sendNotification,
 	sendRequest,
 	setIdleTimeout,
+	supportsDocumentDiagnostics,
 	syncContent,
 	WARMUP_TIMEOUT_MS,
 	waitForProjectLoaded,
@@ -530,17 +531,49 @@ interface WaitForDiagnosticsOptions {
 	settleMs?: number;
 }
 
+function requestDocumentDiagnostics(
+	client: LspClient,
+	uri: string,
+	signal: AbortSignal | undefined,
+	timeoutMs: number,
+): Promise<Diagnostic[] | undefined> {
+	return sendRequest(client, "textDocument/diagnostic", { textDocument: { uri } }, signal, timeoutMs)
+		.then(report => {
+			if (!report || typeof report !== "object" || !("kind" in report) || report.kind !== "full") {
+				return undefined;
+			}
+			if (!("items" in report) || !Array.isArray(report.items)) return undefined;
+			return report.items;
+		})
+		.catch(err => {
+			if (!signal?.aborted) {
+				logger.debug("LSP document diagnostic pull failed", { server: client.name, uri, error: String(err) });
+			}
+			return undefined;
+		});
+}
+
 async function waitForDiagnostics(
 	client: LspClient,
 	uri: string,
 	options: WaitForDiagnosticsOptions = {},
 ): Promise<Diagnostic[]> {
 	const { timeoutMs = 3000, signal, minVersion, expectedDocumentVersion, settleMs = DIAGNOSTICS_SETTLE_MS } = options;
-	const start = Date.now();
+	const deadline = Date.now() + timeoutMs;
+	let pullAttempted = false;
+	let pullResultPromise: Promise<{ diagnostics: Diagnostic[] | undefined }> | undefined;
+	let pulled: Diagnostic[] | undefined;
 	let settledRef: PublishedDiagnostics | undefined;
 	let settledAt = 0;
-	while (Date.now() - start < timeoutMs) {
+	while (Date.now() < deadline) {
 		throwIfAborted(signal);
+		if (!pullAttempted && supportsDocumentDiagnostics(client)) {
+			pullAttempted = true;
+			pullResultPromise = requestDocumentDiagnostics(client, uri, signal, Math.max(1, deadline - Date.now())).then(
+				diagnostics => ({ diagnostics }),
+			);
+		}
+
 		const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
 		const published = client.diagnostics.get(uri);
 		if (published && versionOk) {
@@ -557,13 +590,36 @@ async function waitForDiagnostics(
 				return published.diagnostics;
 			}
 		}
-		await Bun.sleep(DIAGNOSTICS_POLL_MS);
+
+		const pollMs = Math.min(DIAGNOSTICS_POLL_MS, Math.max(0, deadline - Date.now()));
+		if (!pullResultPromise) {
+			await Bun.sleep(pollMs);
+			continue;
+		}
+		const pullResult = await Promise.race([pullResultPromise, Bun.sleep(pollMs).then(() => undefined)]);
+		if (pullResult) {
+			pullResultPromise = undefined;
+			pulled = pullResult.diagnostics;
+			if (pulled !== undefined) break;
+		}
 	}
+
 	const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
-	if (!versionOk) {
-		return [];
+	const published = client.diagnostics.get(uri);
+	if (published && versionOk) {
+		return published.diagnostics;
+	}
+	if (pullResultPromise) {
+		pulled = (await pullResultPromise).diagnostics;
 	}
-	return client.diagnostics.get(uri)?.diagnostics ?? [];
+	throwIfAborted(signal);
+	if (pulled === undefined) return [];
+	client.diagnostics.set(uri, {
+		diagnostics: pulled,
+		version: expectedDocumentVersion ?? client.openFiles.get(uri)?.version ?? null,
+	});
+	client.diagnosticsVersion += 1;
+	return pulled;
 }
 
 /** Project type detection result */

package/src/lsp/types.ts

@@ -387,6 +387,7 @@ export interface LspServerCapabilities {
 	referencesProvider?: boolean;
 	documentSymbolProvider?: boolean;
 	workspaceSymbolProvider?: boolean;
+	diagnosticProvider?: boolean | Record<string, unknown>;
 	[key: string]: unknown;
 }
 
@@ -398,6 +399,8 @@ export interface LspClient {
 	requestId: number;
 	diagnostics: Map<string, PublishedDiagnostics>;
 	diagnosticsVersion: number;
+	/** Dynamic capability registrations keyed by the server-provided registration ID. */
+	dynamicCapabilityRegistrations?: Map<string, string>;
 	openFiles: Map<string, OpenFile>;
 	pendingRequests: Map<number | string, PendingRequest>;
 	messageBuffer: Uint8Array;

package/src/main.ts

@@ -59,6 +59,7 @@ import type { PrintModeOptions } from "./modes/print-mode";
 import { CURRENT_SETUP_VERSION } from "./modes/setup-version";
 import { initTheme, stopThemeWatcher } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
+import { createWarpEventBridgeExtension } from "./modes/warp-events";
 import { AgentLifecycleManager } from "./registry/agent-lifecycle";
 import {
 	type CreateAgentSessionOptions,
@@ -76,7 +77,7 @@ import { executeBuiltinSlashCommand } from "./slash-commands/builtin-registry";
 import { shouldShowStartupSplash } from "./startup-splash";
 import { discoverTitleSystemPromptFile, resolvePromptInput } from "./system-prompt";
 import { createPersistedSubagentReviverFactory } from "./task/persisted-revive";
-import { initTelemetryExport, isTelemetryExportEnabled } from "./telemetry-export";
+import { createTelemetryExportConfig, initTelemetryExport, isTelemetryExportEnabled } from "./telemetry-export";
 import { concreteThinkingLevel, parseConfiguredThinkingLevel } from "./thinking";
 import type { LspStartupServerInfo } from "./tools";
 import {
@@ -1350,15 +1351,13 @@ export async function runRootCommand(
 	sessionOptions.hasUI = isInteractive || mode === "rpc-ui";
 	sessionOptions.settings = settingsInstance;
 
-	// OTEL: register the global OTLP trace exporter when an OTLP endpoint is
-	// configured via env, then switch on the agent loop's telemetry so its
-	// GenAI spans (invoke_agent / chat / execute_tool) are actually emitted.
-	// Both are no-ops when OTEL_EXPORTER_OTLP_ENDPOINT is unset. An empty config
-	// is enough to enable telemetry — content capture is governed by the
-	// standard OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT env var.
+	// OTEL: register global OTLP exporters when an endpoint is configured via
+	// env, then switch on the agent loop's telemetry hooks so traces, run-level
+	// metrics, and structured logs have source events to export. Content capture
+	// remains governed by OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT.
 	await logger.time("initTelemetryExport", initTelemetryExport);
 	if (isTelemetryExportEnabled()) {
-		sessionOptions.telemetry = {};
+		sessionOptions.telemetry = createTelemetryExportConfig(sessionOptions.telemetry);
 	}
 
 	// Handle CLI --api-key as runtime override (not persisted)
@@ -1407,6 +1406,10 @@ export async function runRootCommand(
 		// string-flag value such as `--target @notes.md` is the flag's value, not a
 		// file — and the same result is handed to createAgentSession via
 		// `preloadedExtensions` so the discovery work is not repeated.
+		if (isInteractive) {
+			sessionOptions.extensions = [...(sessionOptions.extensions ?? []), createWarpEventBridgeExtension()];
+		}
+
 		const eventBus = new EventBus();
 		const extensionsResult = await loadSessionExtensions(sessionOptions, cwd, settingsInstance, eventBus);
 		const extensionFlagSink: ExtensionFlagSink = {

package/src/mcp/manager.ts

@@ -572,8 +572,14 @@ export class MCPManager {
 		};
 	}
 
+	/**
+	 * Ownership is matched via `mcpServerName`, never a `mcp__${name}_` name
+	 * prefix: tool names are lossy-sanitized, so one server's sanitized name
+	 * can prefix another's (`atlassian` vs `atlassian:atlassian`) and a name
+	 * with sanitized characters never prefix-matches its own tools at all.
+	 */
 	#replaceServerTools(name: string, tools: CustomTool<TSchema, MCPToolDetails>[]): void {
-		this.#tools = this.#tools.filter(t => !t.name.startsWith(`mcp__${name}_`));
+		this.#tools = this.#tools.filter(t => t.mcpServerName !== name);
 		this.#tools.push(...tools);
 		// Stable sort by name so reconnect order does not perturb the array.
 		// See `sortMCPToolsByName` for the cache-stability rationale.
@@ -762,8 +768,8 @@ export class MCPManager {
 		}
 
 		// Remove tools from this server and notify consumers
-		const hadTools = this.#tools.some(t => t.name.startsWith(`mcp__${name}_`));
-		this.#tools = this.#tools.filter(t => !t.name.startsWith(`mcp__${name}_`));
+		const hadTools = this.#tools.some(t => t.mcpServerName === name);
+		this.#tools = this.#tools.filter(t => t.mcpServerName !== name);
 		if (hadTools) this.#onToolsChanged?.(this.#tools);
 
 		// Notify prompt consumers so stale commands are cleared

package/src/mcp/oauth-flow.ts

@@ -385,6 +385,13 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 	async generateAuthUrl(state: string, redirectUri: string): Promise<{ url: string; instructions?: string }> {
 		if (!this.#resolvedClientId) {
 			await this.#tryRegisterClient(redirectUri);
+			// `unapproved_client` explicitly establishes that registration cannot
+			// produce the required client id. Other DCR failures stay on the
+			// clientless probe path because they may be transient or caused by
+			// unrelated registration metadata.
+			if (!this.#resolvedClientId && this.#isDefinitiveRegistrationRejection()) {
+				throw this.#missingClientIdError();
+			}
 		}
 
 		const authUrl = new URL(this.config.authorizationUrl);
@@ -691,6 +698,19 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 		}
 	}
 
+	/**
+	 * Whether the provider explicitly rejected this client as unapproved.
+	 *
+	 * HTTP status alone is insufficient: payload errors such as
+	 * `invalid_client_metadata` and `invalid_redirect_uri` do not establish that
+	 * the authorization endpoint requires a client id. Keep those on the
+	 * clientless probe path.
+	 */
+	#isDefinitiveRegistrationRejection(): boolean {
+		const failure = this.#registrationFailure;
+		return failure?.status === 403 && /\bunapproved_client\b/i.test(failure.detail ?? "");
+	}
+
 	/**
 	 * Build the error thrown when the authorize probe confirms the provider
 	 * demands a `client_id`. When dynamic client registration was attempted and