pi2dsh 0.18.0 → 0.20.0

package/dist/{runtime-C-cmLDY0.mjs → runtime-CBZcd1uU.mjs}

@@ -1,15 +1,16 @@
 
-import { En as PiCapabilityError, F as generateBranchSummary, Tn as CapabilityLedger, b as Theme, d as ExtensionRunner, w as __runWithSubagentSessionFactory } from "./pi-coding-agent-DXJ_Jzo0.mjs";
+import { Dn as PiCapabilityError, En as CapabilityLedger, F as generateBranchSummary, b as Theme, d as ExtensionRunner, w as __runWithSubagentSessionFactory } from "./pi-coding-agent-CPXFo0UO.mjs";
 import { t as getAgentDir } from "./pi-config-shim-CZ1wFzqM.mjs";
 import { $ as AssistantMessageEventStream, S as getSupportedThinkingLevels, c as builtinProviders, et as isContextOverflow, o as __runWithPiAiRuntime, r as __createPiAiRuntimeRegistry } from "./pi-ai-DQPHUR9S.mjs";
 import { W as getKeybindings, _t as stripTerminalSequences } from "./pi-tui-DruSeKmd.mjs";
+import { r as piMcpConfigPaths, t as collectPiMcpServers } from "./mcp-config-C1K-IzzB.mjs";
 import { c as resolvePiProviderAuth, i as oauthCredentialRef, l as storedOAuthCredential, n as joinSignals, o as providerSupportsOAuth, r as loginPiProvider, t as FileCredentialStore } from "./oauth-bridge-C_MAPMGA.mjs";
 import { createRequire } from "node:module";
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { EventEmitter } from "node:events";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createJiti } from "jiti";
@@ -912,7 +913,21 @@ var PiBridgedAgentSession = class {
 			this.#restrictionDispose = toolsService.restrict({ allow: this.#activeToolNames.map(nativeToolNameOf).filter((name) => known.has(name)) });
 		} catch {}
 	}
-	async bindExtensions(_bindings = {}) {}
+	/** Per-extension mount failures recorded at creation, for bindExtensions' onError. */
+	#extensionFailures = [];
+	adoptExtensionFailures(failures) {
+		this.#extensionFailures = failures;
+	}
+	async bindExtensions(bindings = {}) {
+		const onError = bindings.onError;
+		if (typeof onError !== "function") return;
+		for (const failure of this.#extensionFailures) try {
+			onError({
+				extensionPath: failure.name,
+				error: failure.error
+			});
+		} catch {}
+	}
 	async dispose() {
 		for (const dispose of this.#disposers.splice(0)) try {
 			dispose();
@@ -1068,8 +1083,23 @@ async function createBridgedAgentSession(host, options) {
 	}
 	const thinkingLevel = typeof options.thinkingLevel === "string" ? options.thinkingLevel : void 0;
 	host.adoptChildAgent?.(handle.agent, thinkingLevel);
+	let extensionFailures = [];
+	try {
+		extensionFailures = await host.mountChildExtensions?.(handle.agent, options.resourceLoader) ?? [];
+	} catch (error) {
+		extensionFailures = [{
+			name: "pi2dsh:child-extensions",
+			error: error instanceof Error ? error.message : String(error)
+		}];
+	}
+	for (const failure of extensionFailures) {
+		const message = `[pi2dsh] child extension ${JSON.stringify(failure.name)} did not mount: ${failure.error}`;
+		host.cordis.logger?.warn?.(message);
+		console.warn(message);
+	}
 	const session = new PiBridgedAgentSession(host, handle, tools, thinkingLevel);
 	session.adoptRestriction(initialRestrictionDispose);
+	session.adoptExtensionFailures(extensionFailures);
 	return { session };
 }
 //#endregion
@@ -1123,6 +1153,102 @@ var BrowserSurfaces = class {
 	imageToolNames() {
 		return [...this.#imageToolNames];
 	}
+	#scene;
+	#sceneRevision = 0;
+	#sceneWidth = 100;
+	openScene(packageName, factory, theme, keybindings, options) {
+		this.#finishScene(void 0);
+		return new Promise((resolve, reject) => {
+			const run = {
+				package: packageName,
+				component: void 0,
+				options,
+				resolve,
+				reject
+			};
+			this.#scene = run;
+			const driver = { requestRender: () => this.#invalidateScene() };
+			const done = (value) => {
+				if (this.#scene !== run) return;
+				this.#finishScene(value);
+			};
+			Promise.resolve().then(() => factory(driver, theme, keybindings, done)).then((component) => {
+				if (this.#scene !== run) {
+					component.dispose?.();
+					return;
+				}
+				if (typeof component?.render !== "function") {
+					this.#scene = void 0;
+					this.#invalidateScene();
+					console.warn(`[pi2dsh] web scene for ${packageName}: component lacks render(width)`);
+					reject(/* @__PURE__ */ new TypeError("Pi custom component must implement render(width)"));
+					return;
+				}
+				run.component = component;
+				this.#invalidateScene();
+			}, (error) => {
+				if (this.#scene !== run) return;
+				this.#scene = void 0;
+				this.#invalidateScene();
+				console.warn(`[pi2dsh] web scene for ${packageName}: component factory failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+				reject(error);
+			});
+		});
+	}
+	/** What the browser paints: the live component's frame, or a closed marker. */
+	sceneSnapshot() {
+		const scene = this.#scene;
+		if (scene?.component === void 0) return {
+			open: false,
+			revision: this.#sceneRevision
+		};
+		const requested = (typeof scene.options?.overlayOptions === "function" ? scene.options.overlayOptions() : scene.options?.overlayOptions)?.width;
+		const width = typeof requested === "number" && Number.isFinite(requested) && requested > 0 ? Math.min(this.#sceneWidth, Math.floor(requested)) : this.#sceneWidth;
+		let lines;
+		try {
+			lines = scene.component.render(width);
+		} catch (error) {
+			const failed = this.#scene;
+			this.#scene = void 0;
+			this.#invalidateScene();
+			console.warn(`[pi2dsh] web scene for ${scene.package}: render(width) failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+			failed?.reject(error);
+			return {
+				open: false,
+				revision: this.#sceneRevision
+			};
+		}
+		return {
+			open: true,
+			package: scene.package,
+			revision: this.#sceneRevision,
+			lines
+		};
+	}
+	/** Raw terminal input from the browser keyboard, verbatim into the component. */
+	sceneInput(sequence, width) {
+		if (typeof width === "number" && Number.isFinite(width)) this.#sceneWidth = Math.max(20, Math.min(400, Math.floor(width)));
+		const component = this.#scene?.component;
+		if (component === void 0 || sequence.length === 0) return;
+		component.handleInput?.(sequence);
+		component.invalidate?.();
+		this.#invalidateScene();
+	}
+	/** The browser dismissed the overlay: resolve the Pi caller with undefined. */
+	closeScene() {
+		this.#finishScene(void 0);
+	}
+	#finishScene(value) {
+		const scene = this.#scene;
+		if (scene === void 0) return;
+		this.#scene = void 0;
+		scene.component?.dispose?.();
+		this.#invalidateScene();
+		scene.resolve(value);
+	}
+	#invalidateScene() {
+		this.#sceneRevision += 1;
+	}
 	/**
 	* Track one child session under its parent.
 	* @param parentSessionId - the session the panel floats over.
@@ -1442,7 +1568,7 @@ function publishAuthorization(url) {
 function revokeAuthorization(path) {
 	pendingAuthorizations.delete(path.slice(18));
 }
-function registerBrowserSurfaceRoute(ctx, registry) {
+function registerBrowserSurfaceRoute(ctx, registry, hooks) {
 	const web = ctx.get("webServer");
 	if (web === void 0 || typeof web.register !== "function") return false;
 	ctx.effect(() => web.register({
@@ -1467,6 +1593,63 @@ function registerBrowserSurfaceRoute(ctx, registry) {
 				response.end();
 				return;
 			}
+			if (url.pathname === "/pi2dsh/mcp-state" && (method === "GET" || method === "HEAD")) {
+				if (hooks?.mcpState === void 0) {
+					response.writeHead(404);
+					response.end();
+					return;
+				}
+				const body = JSON.stringify(await hooks.mcpState(url.searchParams.get("session") ?? ""));
+				response.writeHead(200, {
+					"content-type": "application/json; charset=utf-8",
+					"cache-control": "no-store"
+				});
+				response.end(method === "HEAD" ? void 0 : body);
+				return;
+			}
+			if (url.pathname === "/pi2dsh/mcp-action" && method === "POST") {
+				if (hooks?.mcpAction === void 0) {
+					response.writeHead(404);
+					response.end();
+					return;
+				}
+				const chunks = [];
+				const raw = await new Promise((settle) => {
+					const stream = req;
+					stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+					stream.on("end", () => settle(Buffer.concat(chunks).toString("utf8")));
+				});
+				let outcome;
+				try {
+					const payload = JSON.parse(raw || "{}");
+					if (typeof payload.session !== "string" || typeof payload.server !== "string" || typeof payload.disabled !== "boolean") throw new TypeError("mcp-action needs { session, server, disabled }");
+					const scope = payload.scope === "global" ? "global" : "project";
+					outcome = await hooks.mcpAction(payload.session, payload.server, payload.disabled, scope);
+				} catch (error) {
+					response.writeHead(400, { "content-type": "application/json; charset=utf-8" });
+					response.end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+					return;
+				}
+				response.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+				response.end(JSON.stringify(outcome ?? { ok: true }));
+				return;
+			}
+			if (method === "POST" && (url.pathname === "/pi2dsh/scene-input" || url.pathname === "/pi2dsh/scene-close")) {
+				const chunks = [];
+				const body = await new Promise((settle) => {
+					const stream = req;
+					stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+					stream.on("end", () => settle(Buffer.concat(chunks).toString("utf8")));
+				});
+				if (url.pathname === "/pi2dsh/scene-close") registry.closeScene();
+				else try {
+					const payload = JSON.parse(body || "{}");
+					if (typeof payload.sequence === "string") registry.sceneInput(payload.sequence, typeof payload.width === "number" ? payload.width : void 0);
+				} catch {}
+				response.writeHead(204);
+				response.end();
+				return;
+			}
 			if (method !== "GET" && method !== "HEAD") {
 				response.writeHead(405);
 				response.end();
@@ -1512,11 +1695,13 @@ function registerBrowserSurfaceRoute(ctx, registry) {
 			const body = JSON.stringify(session === "" ? {
 				threads: [],
 				surfaces: [],
-				entries: []
+				entries: [],
+				scene: registry.sceneSnapshot()
 			} : {
 				threads: registry.snapshot(session),
 				surfaces: registry.surfaces(session),
 				entries: registry.entries(session),
+				scene: registry.sceneSnapshot(),
 				...registry.draftRequest(session) === void 0 ? {} : { draft: registry.draftRequest(session) }
 			});
 			response.writeHead(200, {
@@ -3001,7 +3186,7 @@ function registerPiProviderRoute(options) {
 }
 //#endregion
 //#region src/tui-surfaces.ts
-function service(ctx, name) {
+function service$1(ctx, name) {
 	try {
 		return ctx.get(name, false);
 	} catch {
@@ -3048,6 +3233,8 @@ function preferredWidth(options) {
 var TuiSurfaceAdapter = class {
 	packageName;
 	instanceKey;
+	kind = "tuiScenes";
+	nativeCommands = dshTuiLocalCommands();
 	sceneId;
 	scenes;
 	status;
@@ -3060,10 +3247,10 @@ var TuiSurfaceAdapter = class {
 	constructor(ctx, packageName, instanceKey) {
 		this.packageName = packageName;
 		this.instanceKey = instanceKey;
-		const scenes = service(ctx, "tuiScenes");
+		const scenes = service$1(ctx, "tuiScenes");
 		if (scenes === void 0) throw new Error("pi2dsh: dsh-TUI scene service is unavailable");
 		this.scenes = scenes;
-		this.status = service(ctx, "tuiStatus");
+		this.status = service$1(ctx, "tuiStatus");
 		this.sceneId = sceneIdFor(instanceKey === void 0 ? packageName : `${packageName}-${instanceKey}`);
 		this.unregisterScene = scenes.register({
 			id: this.sceneId,
@@ -3196,7 +3383,7 @@ function mountTuiSurfaceAdapter(ctx, packageName, publish, instanceKey) {
 			publish(void 0);
 		});
 	};
-	if (service(ctx, "tuiScenes") !== void 0) {
+	if (service$1(ctx, "tuiScenes") !== void 0) {
 		attach(ctx);
 		return;
 	}
@@ -3289,8 +3476,252 @@ function dshTuiLocalCommands() {
 	cachedTuiLocalCommands = tuiLocalCommandsForVersion(version);
 	return cachedTuiLocalCommands;
 }
-function commandNameForDshTui(name, tuiAvailable) {
-	return tuiAvailable && dshTuiLocalCommands().has(name) ? `pi-${name}` : name;
+/** Host-native command ownership, independent of the concrete TUI package. */
+function commandNameForTerminal(name, nativeCommands) {
+	return nativeCommands?.has(name) === true ? `pi-${name}` : name;
+}
+/** Bridge fallback commands disappear when the active Host already owns one. */
+function shouldRegisterCompatibilityCommand(name, nativeCommands) {
+	return nativeCommands?.has(name) !== true;
+}
+//#endregion
+//#region src/pi-component-relay.ts
+let relaySerial = 0;
+function relayId() {
+	relaySerial += 1;
+	return `pi2dsh-custom-${relaySerial}`;
+}
+/**
+* One Host-owned Pi component session expressed as data messages.
+*
+* The result value never crosses the presentation boundary: Pi's own `done`
+* callback completes it on the Host. Frames and input are deliberately plain
+* data so the presentation transport can change independently.
+*/
+var PiComponentRelay = class {
+	sessionId = relayId();
+	options;
+	ready;
+	result;
+	component;
+	invalidations = /* @__PURE__ */ new Set();
+	resolveResult;
+	rejectResult;
+	revision = 0;
+	closed = false;
+	constructor(factory, theme, keybindings, options) {
+		this.options = options;
+		this.result = new Promise((resolve, reject) => {
+			this.resolveResult = resolve;
+			this.rejectResult = reject;
+		});
+		const driver = { requestRender: () => this.invalidate() };
+		const done = (value) => this.close(value);
+		this.ready = Promise.resolve().then(() => factory(driver, theme, keybindings, done)).then((component) => {
+			if (this.closed) {
+				component.dispose?.();
+				return false;
+			}
+			if (typeof component?.render !== "function") throw new TypeError("Pi custom component must implement render(width)");
+			this.component = component;
+			this.invalidate();
+			return true;
+		}).catch((error) => {
+			this.fail(error);
+			return false;
+		});
+	}
+	get active() {
+		return !this.closed;
+	}
+	onInvalidate(listener) {
+		this.invalidations.add(listener);
+		return () => this.invalidations.delete(listener);
+	}
+	frame(request) {
+		if (request.sessionId !== this.sessionId) throw new Error("stale Pi component render session");
+		const width = Math.max(1, Math.floor(request.width));
+		return {
+			sessionId: this.sessionId,
+			revision: this.revision,
+			width,
+			lines: this.component?.render(width) ?? []
+		};
+	}
+	input(message) {
+		if (message.sessionId !== this.sessionId || this.closed) return;
+		this.component?.handleInput?.(message.data);
+	}
+	invalidate() {
+		if (this.closed) return;
+		this.revision += 1;
+		for (const listener of this.invalidations) listener(this.revision);
+	}
+	close(value) {
+		if (this.closed) return;
+		this.closed = true;
+		const component = this.component;
+		this.component = void 0;
+		component?.dispose?.();
+		this.invalidations.clear();
+		this.resolveResult(value);
+	}
+	fail(error) {
+		if (this.closed) return;
+		this.closed = true;
+		const component = this.component;
+		this.component = void 0;
+		component?.dispose?.();
+		this.invalidations.clear();
+		this.rejectResult(error);
+	}
+};
+//#endregion
+//#region src/pi-tui-extension-surface.ts
+function service(ctx) {
+	try {
+		return ctx.get("piTuiExtensions", false);
+	} catch {
+		return;
+	}
+}
+function statusId(packageName, instanceKey, key) {
+	return `pi2dsh-status-${`${packageName}${instanceKey === void 0 ? "" : `-${instanceKey}`}-${key}`.toLowerCase().replace(/[^a-z0-9_-]+/gu, "-").replace(/^-+|-+$/gu, "") || "entry"}`;
+}
+function overlayOptions(options) {
+	const raw = typeof options?.overlayOptions === "function" ? options.overlayOptions() : options?.overlayOptions;
+	return raw === void 0 ? void 0 : { ...raw };
+}
+/** dsh-pi-tui backend over the public `piTuiExtensions` service. */
+var PiTuiExtensionSurfaceAdapter = class {
+	extensionService;
+	unstableFacade;
+	packageName;
+	instanceKey;
+	kind = "piTuiExtensions";
+	nativeCommands;
+	statusHandles = /* @__PURE__ */ new Map();
+	mounts = /* @__PURE__ */ new Set();
+	disposed = false;
+	constructor(extensionService, unstableFacade, nativeCommands, packageName, instanceKey) {
+		this.extensionService = extensionService;
+		this.unstableFacade = unstableFacade;
+		this.packageName = packageName;
+		this.instanceKey = instanceKey;
+		this.nativeCommands = new Set(nativeCommands);
+	}
+	get available() {
+		if (this.disposed) return false;
+		try {
+			return this.extensionService.api().capabilities.has("unstable.surface.handle");
+		} catch {
+			return false;
+		}
+	}
+	setStatus(key, text) {
+		if (this.disposed) return;
+		const id = statusId(this.packageName, this.instanceKey, key);
+		const previous = this.statusHandles.get(id);
+		if (text === void 0) {
+			previous?.dispose();
+			this.statusHandles.delete(id);
+			return;
+		}
+		const value = {
+			spans: [{
+				text: String(text),
+				tone: "textDim"
+			}],
+			minWidth: 4,
+			importance: 50
+		};
+		if (previous !== void 0) {
+			previous.replace(value);
+			return;
+		}
+		if (!this.extensionService.api().capabilities.has("slot.chrome.footer.status")) return;
+		this.statusHandles.set(id, this.extensionService.register("chrome.footer.status", {
+			id,
+			order: 500,
+			description: `Pi status ${key} from ${this.packageName}`
+		}, value));
+	}
+	async custom(factory, theme, keybindings, options) {
+		if (!this.available) return void 0;
+		for (const active of [...this.mounts]) active.relay.close(void 0);
+		const relay = new PiComponentRelay(factory, theme, keybindings, options);
+		const record = { relay };
+		this.mounts.add(record);
+		try {
+			if (!await relay.ready || !relay.active) return await relay.result;
+			if (this.disposed) {
+				relay.close(void 0);
+				return await relay.result;
+			}
+			const lease = this.unstableFacade.surface.handle.mountComponent({
+				render: (width) => relay.frame({
+					sessionId: relay.sessionId,
+					width
+				}).lines,
+				handleInput: (data) => relay.input({
+					sessionId: relay.sessionId,
+					data
+				}),
+				dispose: () => relay.close(void 0)
+			}, overlayOptions(options));
+			record.lease = lease;
+			const offInvalidate = relay.onInvalidate(() => lease.invalidate());
+			const release = () => {
+				offInvalidate();
+				lease.close();
+			};
+			relay.result.then(release, release);
+			if (!lease.active) relay.close(void 0);
+			lease.focus();
+			return await relay.result;
+		} catch (error) {
+			relay.fail(error);
+			throw error;
+		} finally {
+			this.mounts.delete(record);
+		}
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const handle of this.statusHandles.values()) handle.dispose();
+		this.statusHandles.clear();
+		for (const active of this.mounts) {
+			active.relay.close(void 0);
+			active.lease?.close();
+		}
+		this.mounts.clear();
+	}
+};
+/**
+* Build the optional backend from published public entry points.
+* Returns undefined when the service is absent or cannot provide the exact
+* raw-component capability; callers then keep the existing dsh-TUI/Web path.
+*/
+async function createPiTuiExtensionSurfaceAdapter(ctx, packageName, instanceKey) {
+	const extensionService = service(ctx);
+	if (extensionService === void 0) return void 0;
+	const api = extensionService.api();
+	if (api.apiVersion !== 1 || !api.capabilities.has("unstable.surface.handle")) {
+		ctx.logger?.warn(`pi2dsh: piTuiExtensions cannot host Pi components (api=${api.apiVersion}, raw surface=${api.capabilities.has("unstable.surface.handle")})`);
+		return;
+	}
+	try {
+		const [hostModule, unstableModule] = await Promise.all([import("@xmoon76/dsh-pi-tui"), import("@xmoon76/dsh-pi-tui/extensions/unstable")]);
+		if (unstableModule.UNSTABLE_API_LEVEL !== 1) {
+			ctx.logger?.warn(`pi2dsh: unsupported dsh-pi-tui unstable API level ${unstableModule.UNSTABLE_API_LEVEL}`);
+			return;
+		}
+		return new PiTuiExtensionSurfaceAdapter(extensionService, unstableModule.unstable(extensionService), hostModule.LOCAL_COMMANDS, packageName, instanceKey);
+	} catch (error) {
+		ctx.logger?.warn(`pi2dsh: could not attach the public piTuiExtensions backend: ${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
 }
 //#endregion
 //#region src/runtime.ts
@@ -3808,9 +4239,11 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 		setHeader: (factory) => putSurface(ctx, state, agent, "header", factory),
 		setTitle: (title) => putSurface(ctx, state, agent, "title", title),
 		custom: async (factory, options) => {
+			if (typeof factory !== "function") return void 0;
 			const surfaces = state.tuiSurfaces;
-			if (surfaces === void 0 || typeof factory !== "function") return void 0;
-			return surfaces.custom(factory, state.theme, getKeybindings(), options);
+			if (surfaces !== void 0) return surfaces.custom(factory, state.theme, getKeybindings(), options);
+			const browser = state.shared.browserSurfaces;
+			if (browser !== void 0 && state.shared.browserSurfacesRouted === true) return browser.openScene(state.packageName, factory, state.theme, getKeybindings(), options);
 		},
 		pasteToEditor(text) {
 			const surfaces = state.shared.browserSurfaces;
@@ -4007,7 +4440,8 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 		},
 		ui,
 		get mode() {
-			return state.tuiSurfaces?.available === true ? "tui" : "rpc";
+			if (state.tuiSurfaces?.available === true) return "tui";
+			return state.shared.browserSurfaces !== void 0 && state.shared.browserSurfacesRouted === true ? "tui" : "rpc";
 		},
 		get hasUI() {
 			return state.tuiSurfaces?.available === true || humanAnswererAvailable(userQuestions, agent);
@@ -5121,6 +5555,59 @@ function oauthStoreOf(state) {
 }
 const COMPANION_ROUTE_PREFIX = "pi2dsh-companion/";
 const SHARED_HOST_STATE = /* @__PURE__ */ new WeakMap();
+function registerChildExtensionCatalog(ctx, catalog) {
+	sharedHostStateOf(ctx).childExtensions = catalog;
+}
+/** Read the installed-package catalog registered on shared host state, or undefined. */
+function getSharedChildExtensionCatalog(ctx) {
+	return sharedHostStateOf(ctx).childExtensions;
+}
+/**
+* Which installed packages a creator's resource loader selects for its child
+* — the creator's OWN filter code decides (the loader's getExtensions applies
+* noExtensions and extensionsOverride), this only maps the surviving entry
+* paths back to package names. No loader at all means Pi's default: the full
+* discovered set (sdk.ts builds a default loader and loads everything).
+*/
+function resolveChildExtensionPackages(loader, catalog) {
+	if (loader === void 0 || loader === null) return {
+		names: [...new Set(catalog.packageByEntryPath.values())],
+		failures: []
+	};
+	const getExtensions = loader.getExtensions;
+	if (typeof getExtensions !== "function") return {
+		names: [],
+		failures: []
+	};
+	const names = /* @__PURE__ */ new Set();
+	const failures = [];
+	let entries;
+	try {
+		entries = getExtensions.call(loader)?.extensions ?? [];
+	} catch (error) {
+		return {
+			names: [],
+			failures: [{
+				name: "resourceLoader.getExtensions",
+				error: error instanceof Error ? error.message : String(error)
+			}]
+		};
+	}
+	for (const entry of entries) {
+		const path = entry?.path;
+		if (typeof path !== "string" || path.length === 0) continue;
+		const name = catalog.packageByEntryPath.get(resolve(path));
+		if (name !== void 0) names.add(name);
+		else failures.push({
+			name: path,
+			error: "not an installed DSH plugin — path-loaded extensions are not supported on this host; install it with `dsh plugin add <pkg>`"
+		});
+	}
+	return {
+		names: [...names],
+		failures
+	};
+}
 /**
 * Pi's provider ledger is layered, not flat (model-runtime.ts:742-786 at the
 * pinned upstream): a builtin base map, an extension overlay where defined
@@ -5381,6 +5868,10 @@ async function materializeAttachmentImage(ctx, attachment) {
 	}
 }
 function ensureLoginCommand(ctx, state) {
+	if (!shouldRegisterCompatibilityCommand("login", state.tuiSurfaces?.nativeCommands) && optionalService(ctx, "authorization") !== void 0) {
+		logger(ctx).debug("[pi2dsh] native terminal owns /login and the authorization service is composed; Pi OAuth flows are available through it");
+		return;
+	}
 	const scoped = scopeOf(ctx);
 	const owner = typeof scoped === "object" && scoped !== null ? scoped : ctx;
 	const registered = state.shared.loginRegistered ??= /* @__PURE__ */ new WeakSet();
@@ -6166,9 +6657,9 @@ function normalizedPiCommandName(piName) {
 }
 function dshCommandName(ctx, state, piName) {
 	const validName = normalizedPiCommandName(piName);
-	const name = commandNameForDshTui(validName, state.tuiSurfaces?.available === true || optionalService(ctx, "tuiScenes") !== void 0);
+	const name = commandNameForTerminal(validName, state.tuiSurfaces?.nativeCommands);
 	if (name !== piName) {
-		const reason = name === `pi-${validName}` ? `because dsh-TUI reserves /${validName} for its own local command (locals win on name collisions)` : "to satisfy DSH command naming";
+		const reason = name === `pi-${validName}` ? `because the active terminal reserves /${validName} for its native command (host commands win on collisions)` : "to satisfy DSH command naming";
 		logger(ctx).warn(`[pi2dsh] Pi command /${piName} registered as /${name} ${reason}`);
 	}
 	return name;
@@ -6654,6 +7145,12 @@ async function applyPiPackage(ctx, options) {
 	const shared = sharedHostStateOf(ctx);
 	const scopedOwner = options.ownerAgent ?? scopeOf(ctx);
 	const ownerAgent = typeof scopedOwner === "object" && scopedOwner !== null ? scopedOwner : void 0;
+	if (ownerAgent !== void 0 && options.hostAnchor !== true) {
+		shared.childPackageTools ??= /* @__PURE__ */ new WeakMap();
+		const byPackage = shared.childPackageTools.get(ownerAgent) ?? /* @__PURE__ */ new Map();
+		byPackage.set(options.manifest.package.name, runtimeTools);
+		shared.childPackageTools.set(ownerAgent, byPackage);
+	}
 	const state = {
 		shared,
 		packageName: options.manifest.package.name,
@@ -6716,9 +7213,17 @@ async function applyPiPackage(ctx, options) {
 		publishedOAuthKeys: shared.publishedOAuthKeys,
 		tuiSurfaces: void 0
 	};
-	mountTuiSurfaceAdapter(ctx, state.packageName, (adapter) => {
+	const surfaceInstanceKey = typeof ownerAgent?.id === "string" ? ownerAgent.id : void 0;
+	const piTuiSurface = await createPiTuiExtensionSurfaceAdapter(ctx, state.packageName, surfaceInstanceKey);
+	if (piTuiSurface !== void 0) {
+		state.tuiSurfaces = piTuiSurface;
+		ctx.effect(() => () => {
+			piTuiSurface.dispose();
+			if (state.tuiSurfaces === piTuiSurface) state.tuiSurfaces = void 0;
+		});
+	} else mountTuiSurfaceAdapter(ctx, state.packageName, (adapter) => {
 		state.tuiSurfaces = adapter;
-	}, typeof ownerAgent?.id === "string" ? ownerAgent.id : void 0);
+	}, surfaceInstanceKey);
 	subscribeLifecycle(ctx, state);
 	subscribeInterceptors(ctx, state);
 	shared.providerBuiltins ??= /* @__PURE__ */ new Map();
@@ -6772,7 +7277,57 @@ async function applyPiPackage(ctx, options) {
 		});
 	}
 	const browserSurfaces = state.shared.browserSurfaces ??= new BrowserSurfaces();
-	if (state.shared.browserSurfacesRouted !== true) state.shared.browserSurfacesRouted = registerBrowserSurfaceRoute(ctx, browserSurfaces);
+	if (state.shared.browserSurfacesRouted !== true) {
+		const sessionCwd = (session) => {
+			const cwd = ctx.get("sessions")?.get?.(session)?.header?.cwd;
+			if (typeof cwd === "string" && cwd.length > 0) return cwd;
+			return session === "" ? homedir() : process.cwd();
+		};
+		const globalLayerPaths = (cwd) => new Set(piMcpConfigPaths(cwd).slice(0, 4));
+		state.shared.browserSurfacesRouted = registerBrowserSurfaceRoute(ctx, browserSurfaces, {
+			async mcpState(session) {
+				const cwd = sessionCwd(session);
+				const globals = globalLayerPaths(cwd);
+				const { servers, sources } = collectPiMcpServers(cwd);
+				return {
+					cwd,
+					sources,
+					servers: [...servers.values()].map((server) => ({
+						name: server.name,
+						transport: server.transport,
+						target: server.transport === "stdio" ? [server.command, ...server.args ?? []].filter(Boolean).join(" ") : server.url ?? "",
+						disabled: server.disabled,
+						sourcePath: server.sourcePath,
+						layer: globals.has(server.sourcePath) ? "global" : "project",
+						envKeys: Object.keys(server.env ?? {}),
+						headerKeys: Object.keys(server.headers ?? {})
+					}))
+				};
+			},
+			async mcpAction(session, server, disabled, scope) {
+				const cwd = sessionCwd(session);
+				const { servers } = collectPiMcpServers(cwd);
+				if (!servers.has(server)) throw new TypeError(`unknown MCP server ${JSON.stringify(server)}`);
+				const overridePath = scope === "global" ? [...globalLayerPaths(cwd)][3] : join(cwd, ".pi", "mcp.json");
+				let current = {};
+				try {
+					current = JSON.parse(await readFile(overridePath, "utf8"));
+				} catch {}
+				const mcpServers = typeof current.mcpServers === "object" && current.mcpServers !== null ? current.mcpServers : {};
+				mcpServers[server] = {
+					...typeof mcpServers[server] === "object" && mcpServers[server] !== null ? mcpServers[server] : {},
+					disabled
+				};
+				current.mcpServers = mcpServers;
+				await mkdir(dirname(overridePath), { recursive: true });
+				await writeFile(overridePath, `${JSON.stringify(current, null, 2)}\n`);
+				return {
+					ok: true,
+					note: "run /reload (or restart the session) to apply"
+				};
+			}
+		});
+	}
 	ctx.effect(() => browserSurfaces.trackCompletions(state.packageName ?? "pi", async (trigger, query) => {
 		if (state.autocompleteProviders.length === 0) return [];
 		let provider = { getSuggestions: async () => null };
@@ -6882,6 +7437,21 @@ async function applyPiPackage(ctx, options) {
 			return state.bridge.readonlySessionManager(session, cwd);
 		},
 		resumeSessionIdFor: (file) => state.bridge.sessionIdOfArchiveFile(file),
+		mountChildExtensions: async (childAgent, loader) => {
+			const shared = sharedHostStateOf(ctx);
+			const catalog = shared.childExtensions;
+			if (catalog === void 0) return [];
+			const { names, failures } = resolveChildExtensionPackages(loader, catalog);
+			if (names.length === 0) return failures;
+			const mountFailures = await catalog.mount(childAgent, names);
+			const attachable = loader;
+			if (typeof attachable?.attachChildToolResolver === "function") attachable.attachChildToolResolver((path) => {
+				const packageName = catalog.packageByEntryPath.get(resolve(path));
+				if (packageName === void 0) return void 0;
+				return shared.childPackageTools?.get(childAgent)?.get(packageName);
+			});
+			return [...failures, ...mountFailures];
+		},
 		sessionGoneFromPersistence: async (sessionId) => {
 			const persistence = optionalService(ctx, "sessionPersistence");
 			if (typeof persistence?.list !== "function") return void 0;
@@ -6950,6 +7520,7 @@ const runtimeInternals = {
 	currentPiModel,
 	lastRequestRouteOf,
 	resolveCallerRoute,
+	resolveChildExtensionPackages,
 	dshToPiContent,
 	expandPrompt,
 	isKnownImageTool,
@@ -6960,6 +7531,6 @@ const runtimeInternals = {
 	textBlocks
 };
 //#endregion
-export { registerVisionCompanions as a, overlayProviderConfig as i, mergeProviderRegistration as n, runtimeInternals as o, normalizeToolSchema as r, applyPiPackage as t };
+export { overlayProviderConfig as a, runtimeInternals as c, normalizeToolSchema as i, getSharedChildExtensionCatalog as n, registerChildExtensionCatalog as o, mergeProviderRegistration as r, registerVisionCompanions as s, applyPiPackage as t };
 
-//# sourceMappingURL=runtime-C-cmLDY0.mjs.map
+//# sourceMappingURL=runtime-CBZcd1uU.mjs.map