pi2dsh 0.19.0 → 0.21.0

package/dist/{runtime-CW52OWvW.mjs → runtime-CGDq6LKi.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();
@@ -948,6 +963,7 @@ async function createBridgedAgentSession(host, options) {
 	const providedManager = options.sessionManager;
 	const archiveFile = typeof providedManager?.getSessionFile === "function" ? providedManager.getSessionFile() : void 0;
 	const resumeSessionId = host.resumeSessionIdFor?.(archiveFile);
+	const sideline = providedManager !== void 0 && archiveFile === void 0;
 	subagentSerial += 1;
 	const sessionId = `pi2dsh-sub-${Date.now().toString(36)}-${subagentSerial}`;
 	let handle;
@@ -1061,15 +1077,30 @@ async function createBridgedAgentSession(host, options) {
 			version: 2,
 			mode: "continuable",
 			provider: "pi2dsh",
-			label: childLabel(options.label, host.packageName)
+			label: `${sideline ? "Side: " : ""}${childLabel(options.label, host.packageName)}`
 		});
 	} catch (error) {
 		host.cordis.logger?.warn?.(`[pi2dsh] child session could not record its subagent identity: ${error instanceof Error ? error.message : String(error)}`);
 	}
 	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
@@ -1109,6 +1140,7 @@ function messageText(message) {
 */
 var BrowserSurfaces = class {
 	#byParent = /* @__PURE__ */ new Map();
+	#commandRunners = /* @__PURE__ */ new Map();
 	#surfaces = /* @__PURE__ */ new Map();
 	#entrySources = /* @__PURE__ */ new Map();
 	#draftRequests = /* @__PURE__ */ new Map();
@@ -1150,6 +1182,7 @@ var BrowserSurfaces = class {
 				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;
 				}
@@ -1159,6 +1192,7 @@ var BrowserSurfaces = class {
 				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);
 			});
 		});
@@ -1179,6 +1213,7 @@ var BrowserSurfaces = class {
 			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,
@@ -1234,6 +1269,32 @@ var BrowserSurfaces = class {
 		};
 	}
 	/**
+	* Register the executor for one package's Pi commands on one session, so
+	* product UI (a side-chat window's input, its action buttons) can run the
+	* package's OWN command handlers — the same code path the composer takes.
+	* Generic by construction: the runner closure carries the package runtime;
+	* this registry only routes (session, package) to it.
+	* @param sessionId - the root session the package is mounted for.
+	* @param packageName - the Pi package owning the commands.
+	* @param runner - executes one registered Pi command by its Pi name.
+	* @returns a disposer that unregisters the runner.
+	*/
+	registerCommandRunner(sessionId, packageName, runner) {
+		const runners = this.#commandRunners.get(sessionId) ?? /* @__PURE__ */ new Map();
+		runners.set(packageName, runner);
+		this.#commandRunners.set(sessionId, runners);
+		return () => {
+			const live = this.#commandRunners.get(sessionId);
+			if (live === void 0) return;
+			if (live.get(packageName) === runner) live.delete(packageName);
+			if (live.size === 0) this.#commandRunners.delete(sessionId);
+		};
+	}
+	/** The registered runner for (session, package), when one is mounted. */
+	commandRunner(sessionId, packageName) {
+		return this.#commandRunners.get(sessionId)?.get(packageName);
+	}
+	/**
 	* The panel's view of one parent session.
 	* @param parentSessionId - session the browser is currently showing.
 	* @returns every side thread opened under it, oldest first.
@@ -1535,7 +1596,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({
@@ -1560,6 +1621,75 @@ 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 (url.pathname === "/pi2dsh/pi-command" && method === "POST") {
+				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")));
+				});
+				try {
+					const payload = JSON.parse(raw || "{}");
+					if (typeof payload.session !== "string" || typeof payload.package !== "string" || typeof payload.command !== "string") throw new TypeError("pi-command needs { session, package, command }");
+					const runner = registry.commandRunner(payload.session, payload.package);
+					if (runner === void 0) {
+						response.writeHead(404, { "content-type": "application/json; charset=utf-8" });
+						response.end(JSON.stringify({ error: `no ${payload.package} command runner mounted for this session` }));
+						return;
+					}
+					const notice = await runner(payload.command, typeof payload.args === "string" ? payload.args : "");
+					response.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+					response.end(JSON.stringify({
+						ok: true,
+						...notice === void 0 ? {} : { notice }
+					}));
+				} 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;
+			}
 			if (method === "POST" && (url.pathname === "/pi2dsh/scene-input" || url.pathname === "/pi2dsh/scene-close")) {
 				const chunks = [];
 				const body = await new Promise((settle) => {
@@ -3112,7 +3242,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 {
@@ -3159,6 +3289,8 @@ function preferredWidth(options) {
 var TuiSurfaceAdapter = class {
 	packageName;
 	instanceKey;
+	kind = "tuiScenes";
+	nativeCommands = dshTuiLocalCommands();
 	sceneId;
 	scenes;
 	status;
@@ -3171,10 +3303,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,
@@ -3307,7 +3439,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;
 	}
@@ -3400,8 +3532,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
@@ -3854,7 +4230,7 @@ function projectDialogPrompt(title, supplementalDetail, linkMode) {
 		...detail.length === 0 ? {} : { detail }
 	};
 }
-function contextFor(ctx, state, agent, signal, command = false, sessionOverride) {
+function contextFor(ctx, state, agent, signal, command = false, sessionOverride, headlessUi = false) {
 	const notices = [];
 	const userQuestions = optionalService(ctx, "userQuestions");
 	const dialogLinkMode = optionalService(ctx, "tuiScenes") === void 0 ? "markdown" : "terminal";
@@ -3920,6 +4296,7 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 		setTitle: (title) => putSurface(ctx, state, agent, "title", title),
 		custom: async (factory, options) => {
 			if (typeof factory !== "function") return void 0;
+			if (headlessUi) return void 0;
 			const surfaces = state.tuiSurfaces;
 			if (surfaces !== void 0) return surfaces.custom(factory, state.theme, getKeybindings(), options);
 			const browser = state.shared.browserSurfaces;
@@ -4120,7 +4497,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);
@@ -5234,6 +5612,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
@@ -5494,16 +5925,20 @@ async function materializeAttachmentImage(ctx, attachment) {
 	}
 }
 function ensureLoginCommand(ctx, state) {
-	const scoped = scopeOf(ctx);
-	const owner = typeof scoped === "object" && scoped !== null ? scoped : ctx;
-	const registered = state.shared.loginRegistered ??= /* @__PURE__ */ new WeakSet();
-	if (registered.has(owner)) return;
-	registered.add(owner);
+	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;
+	}
+	if (state.shared.loginCommandRegistered === true) return;
+	state.shared.loginCommandRegistered = true;
 	try {
 		registerLoginCommand(ctx, state);
+		ctx.effect(() => () => {
+			state.shared.loginCommandRegistered = false;
+		});
 	} catch (error) {
-		registered.delete(owner);
-		logger(ctx).warn(`[pi2dsh] /login is already registered by an earlier package in this host; this package's providers use that command (${error instanceof Error ? error.message : String(error)})`);
+		state.shared.loginCommandRegistered = false;
+		logger(ctx).warn(`[pi2dsh] /login could not be registered; provider logins remain available on the host's own sign-in surface (${error instanceof Error ? error.message : String(error)})`);
 	}
 }
 /**
@@ -6279,9 +6714,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;
@@ -6767,6 +7202,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,
@@ -6829,9 +7270,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();
@@ -6885,7 +7334,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 };
@@ -6941,6 +7440,21 @@ async function applyPiPackage(ctx, options) {
 		}
 		return rendered;
 	}));
+	const runnerSessionId = ownerAgent === void 0 ? "" : String(agentSession(ownerAgent)?.id ?? "");
+	if (runnerSessionId.length > 0) {
+		const disposeRunner = browserSurfaces.registerCommandRunner(runnerSessionId, state.packageName, async (name, args) => {
+			const live = state.commands.get(name);
+			if (live === void 0) throw new Error(`${state.packageName} has no command ${JSON.stringify(name)}`);
+			const commandContext = contextFor(ctx, state, ownerAgent, void 0, true, void 0, true);
+			await runInPiRuntime(state, ownerAgent, async () => {
+				await ensurePiSessionStarted(ctx, state, ownerAgent, void 0);
+				await live.handler(args, commandContext);
+			});
+			const notices = commandContext.__notices;
+			return notices.length > 0 ? notices.join("\n") : void 0;
+		});
+		ctx.effect(() => disposeRunner);
+	}
 	state.subagentSessionFactory = async (subagentOptions) => {
 		const created = await createBridgedAgentSession(subagentHost(), subagentOptions);
 		const parent = agentSession(currentAgent(state));
@@ -6995,6 +7509,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;
@@ -7063,6 +7592,7 @@ const runtimeInternals = {
 	currentPiModel,
 	lastRequestRouteOf,
 	resolveCallerRoute,
+	resolveChildExtensionPackages,
 	dshToPiContent,
 	expandPrompt,
 	isKnownImageTool,
@@ -7073,6 +7603,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-CW52OWvW.mjs.map
+//# sourceMappingURL=runtime-CGDq6LKi.mjs.map