pi2dsh 0.13.2 → 0.14.0

package/dist/{runtime-DEjs_Qlf.mjs → runtime-Bb9Bfk4M.mjs}

@@ -1,8 +1,9 @@
 
-import { X as isContextOverflow, Y as AssistantMessageEventStream, c as builtinProviders, i as __setPiAiLlmBridge, x as getSupportedThinkingLevels } from "./pi-ai-D7PqVeWs.mjs";
-import { P as generateBranchSummary, Tn as PiCapabilityError, b as Theme, d as ExtensionRunner, w as __setSubagentSessionFactory, wn as CapabilityLedger } from "./pi-coding-agent-BVZu0dHG.mjs";
+import { En as PiCapabilityError, F as generateBranchSummary, Tn as CapabilityLedger, b as Theme, d as ExtensionRunner, w as __runWithSubagentSessionFactory } from "./pi-coding-agent-DK8hbJP5.mjs";
 import { t as getAgentDir } from "./pi-config-shim-CZ1wFzqM.mjs";
-import { a as FileCredentialStore, c as providerSupportsOAuth, i as oauthCredentialRef, l as resolvePiProviderAuth, o as joinSignals, s as loginPiProvider, u as storedOAuthCredential } from "./credentials-oauth-Txs6oew8.mjs";
+import { $ as isContextOverflow, Q as AssistantMessageEventStream, S as getSupportedThinkingLevels, c as builtinProviders, o as __runWithPiAiRuntime, r as __createPiAiRuntimeRegistry } from "./pi-ai-DpqiLdPA.mjs";
+import { W as getKeybindings } from "./pi-tui-DruSeKmd.mjs";
+import { a as FileCredentialStore, c as providerSupportsOAuth, i as oauthCredentialRef, l as resolvePiProviderAuth, o as joinSignals, s as loginPiProvider, u as storedOAuthCredential } from "./credentials-oauth-Didpkkjx.mjs";
 import { createRequire } from "node:module";
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
@@ -13,6 +14,7 @@ import { EventEmitter } from "node:events";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createJiti } from "jiti";
 import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmError, QUOTA_EXCEEDED_CODE, createUserMessage, isContextWindowExceededError, isQuotaExceededError } from "@deepseek-ai/dsh-llm";
+import { scopeOf } from "@deepseek-ai/dsh-scope";
 import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
 import { randomUUID } from "node:crypto";
 import { foldSurface } from "@deepseek-ai/dsh-session";
@@ -356,6 +358,18 @@ var PiSessionBridge = class {
 //#endregion
 //#region src/subagent-bridge.ts
 let subagentSerial = 0;
+/**
+* Cross-scope subscription base. Session events dispatch under the OWNING
+* session's scope; a package instance mounted per Agent registers listeners
+* inside its own Agent's scope and would never see a child session's events.
+* The bridge's callbacks filter by exact session/agent identity, so they
+* subscribe unscoped at the root context — the same posture the old
+* host-level mount had.
+*/
+function unscopedEventContext(cordis) {
+	const host = cordis;
+	return host.root ?? host;
+}
 /** Flatten a Pi message's content to text for transcript seeding. */
 function piMessageText(message) {
 	const content = message.content;
@@ -395,7 +409,7 @@ var PiBridgedAgentSession = class {
 		this.#session = handle.agent.session ?? {};
 		this.#tools = tools;
 		this.#activeToolNames = tools.map((tool) => tool?.name).filter((name) => typeof name === "string");
-		const cordis = host.cordis;
+		const cordis = unscopedEventContext(host.cordis);
 		const offEvents = cordis.on("session/event", (session, event) => {
 			if (session !== this.#session) return;
 			this.#project(event);
@@ -594,7 +608,7 @@ var PiBridgedAgentSession = class {
 			type: "text",
 			text: String(text)
 		}]);
-		const cordis = this.#host.cordis;
+		const cordis = unscopedEventContext(this.#host.cordis);
 		const completed = new Promise((resolve) => {
 			const off = cordis.on("session/event", (session, event) => {
 				if (session !== this.#session) return;
@@ -2274,7 +2288,12 @@ function piProviderDshAdapter(providerId, provider, host) {
 		async *stream(options) {
 			const auth = (await host.resolveAuth())?.auth;
 			const modelId = String(options.model ?? "");
-			const model = providerModels(provider).find((entry) => entry.id === modelId) ?? {
+			let model = providerModels(provider).find((entry) => entry.id === modelId);
+			if (model === void 0 && host.ensureModel !== void 0) {
+				await host.ensureModel(modelId);
+				model = providerModels(provider).find((entry) => entry.id === modelId);
+			}
+			model ??= {
 				id: modelId,
 				provider: providerId
 			};
@@ -2297,6 +2316,7 @@ function piProviderDshAdapter(providerId, provider, host) {
 				...host.beforeProviderRequest === void 0 ? {} : { onPayload: (payload) => host.beforeProviderRequest(payload, {
 					provider: providerId,
 					model,
+					...typeof options.sessionId === "string" ? { sessionId: options.sessionId } : {},
 					...options.signal instanceof AbortSignal ? { signal: options.signal } : {}
 				}) },
 				...effort === void 0 || effort === "off" ? {} : { reasoning: effort }
@@ -2654,6 +2674,220 @@ function registerPiProviderRoute(options) {
 	}
 }
 //#endregion
+//#region src/tui-surfaces.ts
+function service(ctx, name) {
+	try {
+		return ctx.get(name, false);
+	} catch {
+		return;
+	}
+}
+function surfaceToken(value) {
+	const normalized = value.toLowerCase().replace(/[^a-z0-9_-]+/gu, "-").replace(/^-+|-+$/gu, "");
+	if (normalized.length === 0) return "entry";
+	return /^[a-z]/u.test(normalized) ? normalized : `k-${normalized}`;
+}
+function sceneIdFor(packageName) {
+	return `pi2dsh-${surfaceToken(packageName)}-custom`;
+}
+function statusKeyFor(packageName, key) {
+	return `pi2dsh:${surfaceToken(packageName)}:${surfaceToken(key)}`;
+}
+function rawTerminalInput(input, key, event) {
+	const keypress = event?.keypress;
+	if (typeof keypress?.sequence === "string" && keypress.sequence.length > 0) return keypress.sequence;
+	if (key.return === true) return "\r";
+	if (key.escape === true) return "\x1B";
+	if (key.tab === true) return "	";
+	if (key.backspace === true) return "";
+	if (key.upArrow === true) return "\x1B[A";
+	if (key.downArrow === true) return "\x1B[B";
+	if (key.rightArrow === true) return "\x1B[C";
+	if (key.leftArrow === true) return "\x1B[D";
+	if (key.ctrl === true && input.length === 1) {
+		const code = input.toLowerCase().charCodeAt(0);
+		if (code >= 97 && code <= 122) return String.fromCharCode(code - 96);
+	}
+	return input;
+}
+function preferredWidth(options) {
+	const width = (typeof options?.overlayOptions === "function" ? options.overlayOptions() : options?.overlayOptions)?.width;
+	return typeof width === "number" && Number.isFinite(width) && width > 0 ? Math.floor(width) : void 0;
+}
+/**
+* One package-scoped Pi custom-surface host backed by one dsh-TUI scene.
+* The MCP adapter is a consumer, not a special case: every component using
+* the public Pi component protocol follows the same path.
+*/
+var TuiSurfaceAdapter = class {
+	packageName;
+	instanceKey;
+	sceneId;
+	scenes;
+	status;
+	statusDisposers = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Set();
+	unregisterScene;
+	revision = 0;
+	active;
+	disposed = false;
+	constructor(ctx, packageName, instanceKey) {
+		this.packageName = packageName;
+		this.instanceKey = instanceKey;
+		const scenes = service(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.sceneId = sceneIdFor(instanceKey === void 0 ? packageName : `${packageName}-${instanceKey}`);
+		this.unregisterScene = scenes.register({
+			id: this.sceneId,
+			title: `${packageName} custom panel`,
+			component: (props) => this.scene(props)
+		});
+	}
+	get available() {
+		return !this.disposed;
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	snapshot() {
+		return this.revision;
+	}
+	setStatus(key, text) {
+		if (this.disposed || this.status === void 0) return;
+		const dshKey = statusKeyFor(this.instanceKey === void 0 ? this.packageName : `${this.packageName}-${this.instanceKey}`, key);
+		this.statusDisposers.get(dshKey)?.();
+		this.statusDisposers.delete(dshKey);
+		if (text === void 0) return;
+		const dispose = this.status.set(dshKey, String(text));
+		if (typeof dispose === "function") this.statusDisposers.set(dshKey, dispose);
+	}
+	custom(factory, theme, keybindings, options) {
+		if (this.disposed) return Promise.resolve(void 0);
+		this.finish(void 0);
+		return new Promise((resolve, reject) => {
+			const run = {
+				options,
+				resolve,
+				reject
+			};
+			this.active = run;
+			const driver = { requestRender: () => this.invalidate() };
+			const done = (value) => this.finishFor(run, value);
+			Promise.resolve().then(() => factory(driver, theme, keybindings, done)).then((component) => {
+				if (this.active !== run) {
+					component.dispose?.();
+					return;
+				}
+				if (typeof component?.render !== "function") {
+					this.failFor(run, /* @__PURE__ */ new TypeError("Pi custom component must implement render(width)"));
+					return;
+				}
+				run.component = component;
+				this.invalidate();
+				if (!this.scenes.open(this.sceneId)) this.finishFor(run, void 0);
+			}, (error) => this.failFor(run, error));
+		});
+	}
+	render(width) {
+		const active = this.active;
+		if (active?.component === void 0) return [];
+		const available = Math.max(12, Math.floor(width) - 2);
+		const requested = preferredWidth(active.options);
+		return active.component.render(requested === void 0 ? available : Math.min(available, requested));
+	}
+	handleInput(data) {
+		const component = this.active?.component;
+		if (component === void 0) return;
+		component.handleInput?.(data);
+		component.invalidate?.();
+		this.invalidate();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.finish(void 0);
+		for (const dispose of this.statusDisposers.values()) dispose();
+		this.statusDisposers.clear();
+		this.unregisterScene();
+		this.listeners.clear();
+	}
+	invalidate() {
+		this.revision += 1;
+		for (const listener of this.listeners) listener();
+	}
+	finish(value) {
+		const active = this.active;
+		if (active !== void 0) this.finishFor(active, value);
+	}
+	finishFor(run, value, closeScene = true) {
+		if (this.active !== run) return;
+		this.active = void 0;
+		run.component?.dispose?.();
+		if (closeScene) this.scenes.close();
+		this.invalidate();
+		run.resolve(value);
+	}
+	failFor(run, error) {
+		if (this.active !== run) return;
+		this.active = void 0;
+		run.component?.dispose?.();
+		this.scenes.close();
+		this.invalidate();
+		run.reject(error);
+	}
+	scene(props) {
+		const { React, ui } = props;
+		React.useSyncExternalStore((listener) => this.subscribe(listener), () => this.snapshot(), () => this.snapshot());
+		React.useEffect(() => () => {
+			const active = this.active;
+			if (active !== void 0) this.finishFor(active, void 0, false);
+		}, []);
+		ui.useInput((input, key, event) => this.handleInput(rawTerminalInput(input, key, event)));
+		const { columns } = ui.useTerminalSize();
+		const lines = this.render(columns);
+		const Line = ui.Ansi ?? ui.Text;
+		return React.createElement(ui.Box, {
+			flexDirection: "column",
+			width: "100%",
+			paddingX: 1
+		}, ...lines.map((line, index) => React.createElement(Line, { key: index }, line)));
+	}
+};
+/**
+* Attach lazily to dsh-TUI. Cordis reloads this child fiber whenever the
+* service implementation changes, so a TUI update cannot leave a stale scene
+* proxy in the bridge.
+*/
+function mountTuiSurfaceAdapter(ctx, packageName, publish, instanceKey) {
+	const attach = (surfaceCtx) => {
+		const adapter = new TuiSurfaceAdapter(surfaceCtx, packageName, instanceKey);
+		publish(adapter);
+		surfaceCtx.effect?.(() => () => {
+			adapter.dispose();
+			publish(void 0);
+		});
+	};
+	if (service(ctx, "tuiScenes") !== void 0) {
+		attach(ctx);
+		return;
+	}
+	if (typeof ctx.inject === "function") {
+		ctx.inject(["tuiScenes"], attach);
+		return;
+	}
+}
+/**
+* dsh-TUI handles `/mcp` locally before it asks DSH's command registry. Until
+* it exposes a reserved-command seam, keep its native status command and make
+* an installed Pi MCP manager reachable as `/pi-mcp`.
+*/
+function commandNameForDshTui(name, tuiAvailable) {
+	return tuiAvailable && name === "mcp" ? "pi-mcp" : name;
+}
+//#endregion
 //#region src/runtime.ts
 /** Fallback thread ids when a child session reports none. */
 let sidePanelSerial = 0;
@@ -3042,9 +3276,8 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 			...prefill === void 0 ? {} : { detail: `Current text:\n${String(prefill)}` }
 		}),
 		setStatus: (key, text) => {
-			const surfaces = state.shared.browserSurfaces;
-			if (surfaces === void 0) return;
-			surfaces.setStatus(sessionIdOf(state, agent), state.packageName, String(key), text);
+			state.shared.browserSurfaces?.setStatus(sessionIdOf(state, agent), state.packageName, String(key), text);
+			state.tuiSurfaces?.setStatus(String(key), text);
 		},
 		setWidget: (key, content) => {
 			const surfaces = state.shared.browserSurfaces;
@@ -3063,7 +3296,11 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 		setFooter: (factory) => putSurface(ctx, state, agent, "footer", factory),
 		setHeader: (factory) => putSurface(ctx, state, agent, "header", factory),
 		setTitle: (title) => putSurface(ctx, state, agent, "title", title),
-		custom: async () => void 0,
+		custom: async (factory, options) => {
+			const surfaces = state.tuiSurfaces;
+			if (surfaces === void 0 || typeof factory !== "function") return void 0;
+			return surfaces.custom(factory, state.theme, getKeybindings(), options);
+		},
 		pasteToEditor(text) {
 			const surfaces = state.shared.browserSurfaces;
 			const sessionId = sessionIdOf(state, agent);
@@ -3258,9 +3495,11 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 			}
 		},
 		ui,
-		mode: "rpc",
+		get mode() {
+			return state.tuiSurfaces?.available === true ? "tui" : "rpc";
+		},
 		get hasUI() {
-			return humanAnswererAvailable(userQuestions, agent);
+			return state.tuiSurfaces?.available === true || humanAnswererAvailable(userQuestions, agent);
 		},
 		cwd: contextCwd,
 		sessionManager: session === void 0 ? state.bridge.readonlySessionManager({
@@ -3461,8 +3700,8 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 			return { cancelled: false };
 		},
 		reload: async () => {
-			const remounts = state.shared.packageRemounts;
-			if (remounts === void 0 || remounts.size === 0) return;
+			const remounts = packageRemountsOf(ctx, state.shared);
+			if (remounts.size === 0) return;
 			for (const [name, remount] of remounts) try {
 				await remount();
 			} catch (error) {
@@ -3481,10 +3720,19 @@ function contextFor(ctx, state, agent, signal, command = false, sessionOverride)
 async function dispatch(state, eventName, event, eventContext) {
 	const results = [];
 	const agent = eventContext.__agent;
-	for (const handler of state.handlers.get(eventName) ?? []) results.push(await state.agentScope.run(agent, () => handler(event, eventContext)));
+	for (const handler of state.handlers.get(eventName) ?? []) results.push(await runInPiRuntime(state, agent, () => handler(event, eventContext)));
 	return results;
 }
 /**
+* Bind every compatibility singleton to this exact Agent runtime for the
+* duration of extension-owned work. AsyncLocalStorage follows promises and
+* detached work spawned inside the callback, so two live Agents cannot
+* overwrite each other's model bridge or child-session factory.
+*/
+function runInPiRuntime(state, agent, callback) {
+	return state.agentScope.run(agent, () => __runWithSubagentSessionFactory(state.subagentSessionFactory, () => __runWithPiAiRuntime(state.llmBridge, state.piAiRegistry, callback)));
+}
+/**
 * Pi's request-body event is a waterfall over the body the provider transport
 * will actually send. Only package-registered Pi transports expose that body
 * through SimpleStreamOptions.onPayload; native DSH adapters build it behind
@@ -3499,7 +3747,7 @@ async function dispatchBeforeProviderRequest(ctx, state, payload, request) {
 		provider: request.provider
 	};
 	for (const handler of state.handlers.get("before_provider_request") ?? []) try {
-		const result = await state.agentScope.run(agent, () => handler({
+		const result = await runInPiRuntime(state, agent, () => handler({
 			type: "before_provider_request",
 			payload: current
 		}, eventContext));
@@ -3509,6 +3757,14 @@ async function dispatchBeforeProviderRequest(ctx, state, payload, request) {
 	}
 	return current;
 }
+/** Run Pi's provider-body waterfall through every package runtime of one Agent. */
+async function dispatchHostProviderRequest(ctx, shared, fallback, payload, request) {
+	const scoped = request.sessionId === void 0 ? void 0 : shared.runtimeStatesBySession.get(request.sessionId);
+	const states = scoped === void 0 || scoped.size === 0 ? [fallback] : [...scoped];
+	let current = payload;
+	for (const state of states) current = await dispatchBeforeProviderRequest(ctx, state, current, request);
+	return current;
+}
 /**
 * What triggered a compaction, in Pi's vocabulary.
 *
@@ -3611,41 +3867,167 @@ async function messageFromSessionEvent(ctx, event) {
 function sourceReason(value) {
 	return value === "resume" ? "resume" : value === "fork" ? "fork" : "startup";
 }
+/**
+* Claim Pi's once-per-session `session_start` event.
+*
+* dsh-TUI can execute a slash command before DSH starts the first model turn,
+* so `agent/session-start` has not necessarily been announced yet. Pi, by
+* contrast, announces `session_start` before the user can execute a command.
+* The command bridge uses this same claim before invoking a Pi command; when
+* DSH later announces the real agent lifecycle, the durable session id keeps
+* the second path from restarting the extension.
+*/
+function claimPiSessionStart(state, agent) {
+	const id = agentSession(agent)?.id;
+	if (typeof id === "string") {
+		if (state.startedSessions.has(id)) return false;
+		state.startedSessions.add(id);
+		return true;
+	}
+	if (typeof agent === "object" && agent !== null) {
+		if (state.startedSessionlessAgents.has(agent)) return false;
+		state.startedSessionlessAgents.add(agent);
+		return true;
+	}
+	return false;
+}
+async function ensurePiSessionStarted(ctx, state, agent, signal) {
+	await startPiSession(ctx, state, agent, "startup", signal);
+}
+function inFlightPiSessionStart(state, agent) {
+	const id = agentSession(agent)?.id;
+	if (typeof id === "string") return state.sessionStartTasks.get(id);
+	if (typeof agent === "object" && agent !== null) return state.sessionlessStartTasks.get(agent);
+}
+function rememberPiSessionStart(state, agent, task) {
+	const id = agentSession(agent)?.id;
+	if (typeof id === "string") state.sessionStartTasks.set(id, task);
+	else if (typeof agent === "object" && agent !== null) state.sessionlessStartTasks.set(agent, task);
+}
+function forgetPiSessionStart(state, agent, task) {
+	const id = agentSession(agent)?.id;
+	if (typeof id === "string") {
+		if (state.sessionStartTasks.get(id) === task) state.sessionStartTasks.delete(id);
+	} else if (typeof agent === "object" && agent !== null && state.sessionlessStartTasks.get(agent) === task) state.sessionlessStartTasks.delete(agent);
+}
+function releasePiSessionClaim(state, agent) {
+	const id = agentSession(agent)?.id;
+	if (typeof id === "string") {
+		state.startedSessions.delete(id);
+		state.sessionStartTasks.delete(id);
+	} else if (typeof agent === "object" && agent !== null) {
+		state.startedSessionlessAgents.delete(agent);
+		state.sessionlessStartTasks.delete(agent);
+	}
+}
+function replacementReason(reason) {
+	if (reason === "resume") return "resume";
+	if (reason === "fork") return "fork";
+	return "new";
+}
+function trackRuntimeSession(state, agent) {
+	const id = agentSession(agent)?.id;
+	if (typeof id !== "string") return;
+	let states = state.shared.runtimeStatesBySession.get(id);
+	if (states === void 0) {
+		states = /* @__PURE__ */ new Set();
+		state.shared.runtimeStatesBySession.set(id, states);
+	}
+	states.add(state);
+}
+function untrackRuntimeSession(state, agent) {
+	const id = agentSession(agent)?.id;
+	if (typeof id !== "string") return;
+	const states = state.shared.runtimeStatesBySession.get(id);
+	states?.delete(state);
+	if (states?.size === 0) state.shared.runtimeStatesBySession.delete(id);
+}
+/** Dispatch or join the one in-flight Pi session_start for this session. */
+async function startPiSession(ctx, state, agent, reason, signal) {
+	if (!acceptsAgent(state, agent)) return;
+	const existing = inFlightPiSessionStart(state, agent);
+	if (existing !== void 0) {
+		await existing;
+		return;
+	}
+	const task = runInPiRuntime(state, agent, async () => {
+		const previous = state.hostAgent;
+		const replacing = typeof previous === "object" && previous !== null && previous !== agent;
+		const transitionReason = replacing ? replacementReason(reason) : reason;
+		if (replacing && !state.piShutdownAgents.has(previous)) {
+			state.piShutdownAgents.add(previous);
+			releasePiSessionClaim(state, previous);
+			await runInPiRuntime(state, previous, () => dispatch(state, "session_shutdown", {
+				type: "session_shutdown",
+				reason: replacementReason(reason)
+			}, contextFor(ctx, state, previous, signal)));
+		}
+		if (typeof agent === "object" && agent !== null) {
+			state.hostAgent = agent;
+			state.piShutdownAgents.delete(agent);
+		}
+		if (!claimPiSessionStart(state, agent)) return;
+		try {
+			await dispatch(state, "session_start", {
+				type: "session_start",
+				reason: transitionReason
+			}, contextFor(ctx, state, agent, signal));
+		} catch (error) {
+			releasePiSessionClaim(state, agent);
+			throw error;
+		}
+	});
+	rememberPiSessionStart(state, agent, task);
+	try {
+		await task;
+	} finally {
+		forgetPiSessionStart(state, agent, task);
+	}
+}
 function subscribeLifecycle(ctx, state) {
 	const cordis = ctx;
 	const warn = (event, error) => logger(ctx).warn(`[pi2dsh] ${event} handler failed: ${String(error)}`);
 	cordis.on("agent/session-start", (payload) => {
 		const agent = payload.agent;
-		if (isSubagentOrigin(agent)) {
-			state.activeAgents.add(agent);
-			return;
-		}
+		if (!acceptsAgent(state, agent)) return;
 		state.activeAgents.add(agent);
+		trackRuntimeSession(state, agent);
 		const session = agentSession(agent);
 		if (session !== void 0) state.bridge.load(session.id);
-		if (state.pendingActiveTools !== void 0) state.agentScope.run(agent, () => setActiveTools(ctx, state, state.pendingActiveTools));
-		dispatch(state, "session_start", {
-			type: "session_start",
-			reason: sourceReason(payload.source)
-		}, contextFor(ctx, state, agent, void 0)).catch((error) => warn("session_start", error));
+		if (state.pendingActiveTools !== void 0) runInPiRuntime(state, agent, () => setActiveTools(ctx, state, state.pendingActiveTools));
+		if (!state.extensionsReady) {
+			state.pendingSessionStarts.set(agent, sourceReason(payload.source));
+			return;
+		}
+		startPiSession(ctx, state, agent, sourceReason(payload.source), void 0).catch((error) => warn("session_start", error));
 	});
 	cordis.on("agent/disposed", (payload) => {
 		const agent = payload.agent;
+		if (!acceptsAgent(state, agent)) return;
+		const ownsHostSession = state.hostAgent === agent;
 		state.activeAgents.delete(agent);
+		untrackRuntimeSession(state, agent);
+		state.pendingSessionStarts.delete(agent);
 		if (typeof agent === "object" && agent !== null) {
 			state.toolRestrictions.get(agent)?.();
 			state.toolRestrictions.delete(agent);
 		}
 		if (typeof agent === "object" && agent !== null && !state.disposedAgents.has(agent)) {
 			state.disposedAgents.add(agent);
-			if (!isSubagentOrigin(agent)) dispatch(state, "session_shutdown", {
-				type: "session_shutdown",
-				reason: "quit"
-			}, contextFor(ctx, state, agent, void 0)).catch((error) => warn("session_shutdown", error));
+			releasePiSessionClaim(state, agent);
+			if (ownsHostSession && !state.piShutdownAgents.has(agent)) {
+				state.piShutdownAgents.add(agent);
+				state.hostAgent = void 0;
+				dispatch(state, "session_shutdown", {
+					type: "session_shutdown",
+					reason: "quit"
+				}, contextFor(ctx, state, agent, void 0)).catch((error) => warn("session_shutdown", error));
+			}
 		}
 	});
 	cordis.on("session/event", (session, event) => {
-		if (isSubagentOrigin(session)) return;
+		const ownedSession = agentSession(state.ownerAgent);
+		if (ownedSession !== void 0 ? session !== ownedSession : isSubagentOrigin(session)) return;
 		const agent = [...state.activeAgents].find((candidate) => candidate.session === session);
 		const eventContext = contextFor(ctx, state, agent, void 0);
 		const type = event.type;
@@ -3796,7 +4178,7 @@ function subscribeLifecycle(ctx, state) {
 	cordis.on("agent/request", async (payload, next) => {
 		const config = await next();
 		const agent = payload.agent;
-		if (agent === void 0) return config;
+		if (agent === void 0 || !acceptsAgent(state, agent)) return config;
 		const override = state.modelOverrides.get(agent);
 		const thinking = state.thinkingLevels.get(agent);
 		if (override === void 0 && thinking === void 0) return config;
@@ -3808,23 +4190,81 @@ function subscribeLifecycle(ctx, state) {
 		};
 	});
 	cordis.effect(() => async () => {
-		for (const agent of state.activeAgents) if (typeof agent === "object" && agent !== null && !state.disposedAgents.has(agent)) {
+		const agent = state.hostAgent;
+		if (typeof agent === "object" && agent !== null && !state.piShutdownAgents.has(agent)) {
+			state.piShutdownAgents.add(agent);
 			state.disposedAgents.add(agent);
 			await dispatch(state, "session_shutdown", {
 				type: "session_shutdown",
 				reason: "quit"
 			}, contextFor(ctx, state, agent, void 0));
 		}
+		state.hostAgent = void 0;
+		for (const active of state.activeAgents) untrackRuntimeSession(state, active);
 		state.activeAgents.clear();
+		state.startedSessions.clear();
+		state.sessionStartTasks.clear();
+		state.pendingSessionStarts.clear();
 		for (const dispose of state.toolDisposers.values()) dispose();
 		state.toolDisposers.clear();
+		for (const provider of [...state.ownedProviderRoutes]) releaseSharedProviderRoute(state, provider);
 		state.eventBus.removeAllListeners();
 	}, "pi2dsh session shutdown");
 }
+async function flushPendingSessionStarts(ctx, state) {
+	state.extensionsReady = true;
+	if (state.ownerAgent !== void 0 && !state.pendingSessionStarts.has(state.ownerAgent)) {
+		const owned = state.ownerAgent;
+		if (!state.activeAgents.has(owned)) {
+			state.activeAgents.add(owned);
+			trackRuntimeSession(state, owned);
+			const session = agentSession(owned);
+			if (session !== void 0) state.bridge.load(session.id);
+		}
+		state.pendingSessionStarts.set(owned, "startup");
+	}
+	const pending = [...state.pendingSessionStarts];
+	state.pendingSessionStarts.clear();
+	for (const [agent, reason] of pending) await startPiSession(ctx, state, agent, reason, void 0);
+}
+/**
+* Start freshly reloaded extension handlers in every live Pi host session.
+*
+* `ctx.reload()` creates a new extension instance. The durable session has
+* already been claimed by the previous instance, so the ordinary once-per-
+* session guard must deliberately NOT suppress this replay: from the new
+* instance's point of view this is its first `session_start`. The command's
+* AsyncLocalStorage agent is included because a lean composition can execute
+* a Pi command without publishing DSH's optional agent/session-start event.
+*/
+async function restartReloadedPiSessions(ctx, state) {
+	state.extensionsReady = true;
+	const pending = new Map(state.pendingSessionStarts);
+	state.pendingSessionStarts.clear();
+	const commandAgent = currentAgent(state);
+	const candidates = [...state.activeAgents, ...commandAgent === void 0 ? [] : [commandAgent]];
+	const seenSessions = /* @__PURE__ */ new Set();
+	const seenSessionless = /* @__PURE__ */ new Set();
+	for (const agent of candidates) {
+		if (!acceptsAgent(state, agent)) continue;
+		const sessionId = agentSession(agent)?.id;
+		if (typeof sessionId === "string") {
+			if (seenSessions.has(sessionId)) continue;
+			seenSessions.add(sessionId);
+		} else {
+			if (seenSessionless.has(agent)) continue;
+			seenSessionless.add(agent);
+		}
+		await runInPiRuntime(state, agent, () => dispatch(state, "session_start", {
+			type: "session_start",
+			reason: pending.get(agent) ?? "resume"
+		}, contextFor(ctx, state, agent, void 0)));
+	}
+}
 function subscribeInterceptors(ctx, state) {
 	const cordis = ctx;
 	cordis.on("tools/pre-execute", async (exec, next) => {
-		if (isSubagentOrigin(exec.agent)) return next();
+		if (!acceptsAgent(state, exec.agent)) return next();
 		const input = cloneJson(exec.arguments);
 		const event = {
 			type: "tool_call",
@@ -3862,7 +4302,7 @@ function subscribeInterceptors(ctx, state) {
 		return next();
 	});
 	cordis.on("tools/post-execute", async (exec, result, next) => {
-		if (isSubagentOrigin(exec.agent)) return next();
+		if (!acceptsAgent(state, exec.agent)) return next();
 		const downstream = await next();
 		await dispatch(state, "tool_execution_end", {
 			type: "tool_execution_end",
@@ -3904,7 +4344,7 @@ function subscribeInterceptors(ctx, state) {
 	});
 	cordis.on("agent/inbox/claimed", (payload) => {
 		const agent = payload.agent;
-		if (agent === void 0 || isSubagentOrigin(agent)) return;
+		if (agent === void 0 || !acceptsAgent(state, agent)) return;
 		const claimed = state.claimedForStep.get(agent) ?? [];
 		claimed.push({
 			message: payload.message,
@@ -3914,7 +4354,7 @@ function subscribeInterceptors(ctx, state) {
 	});
 	cordis.on("agent/pre-step", async (payload, next) => {
 		const agent = payload.agent;
-		if (isSubagentOrigin(agent)) return next();
+		if (!acceptsAgent(state, agent)) return next();
 		const tally = state.terminateBatch.get(agent);
 		state.terminateBatch.delete(agent);
 		if (tally !== void 0 && tally.calls > 0 && tally.calls === tally.terminating) {
@@ -3936,7 +4376,7 @@ function subscribeInterceptors(ctx, state) {
 		};
 	});
 	const systemPrompt = optionalService(ctx, "systemPrompt");
-	if (systemPrompt !== void 0) ctx.effect(() => systemPrompt.section({
+	if (systemPrompt !== void 0 && !state.hostAnchor) ctx.effect(() => systemPrompt.section({
 		name: `pi2dsh:tool-guidance:${state.packageName ?? "pi"}`,
 		order: 150,
 		text: () => piToolPromptContribution(ctx, state)
@@ -3946,7 +4386,8 @@ function subscribeInterceptors(ctx, state) {
 		const original = renderPrompt(downstream);
 		state.currentSystemPrompt = original;
 		const agent = assembleContext.agent ?? assembleContext.scope;
-		if (agent !== void 0 && !isSubagentOrigin(agent)) {
+		if (agent !== void 0 && !acceptsAgent(state, agent)) return downstream;
+		if (agent !== void 0 && acceptsAgent(state, agent)) {
 			await runBeforeAgentStart(ctx, state, agent, assembleContext.signal, original);
 			const override = state.turnSystemPromptOverrides.get(agent);
 			if (override === void 0) return downstream;
@@ -4147,6 +4588,16 @@ function oauthStoreOf(state) {
 }
 const COMPANION_ROUTE_PREFIX = "pi2dsh-companion/";
 const SHARED_HOST_STATE = /* @__PURE__ */ new WeakMap();
+/**
+* The engine's own built-in OAuth directory entries, by object identity.
+* They are login placeholders (no models, no transport), preloaded so
+* `/login <provider>` works before any package is installed — and a package
+* registering the SAME provider id owns the richer definition (transport,
+* catalog, its own flow) and must supersede the placeholder in the shared
+* ledger. Two PACKAGES colliding on one id still keep first-wins, matching
+* the route-ownership rule.
+*/
+const BUILTIN_PROVIDER_SEEDS = /* @__PURE__ */ new WeakSet();
 function sharedHostStateOf(ctx) {
 	const key = ctx.root ?? ctx;
 	let shared = SHARED_HOST_STATE.get(key);
@@ -4154,6 +4605,9 @@ function sharedHostStateOf(ctx) {
 		shared = {
 			companionRoutes: /* @__PURE__ */ new Map(),
 			providerRouteDisposers: /* @__PURE__ */ new Map(),
+			providerModelDiscoveries: /* @__PURE__ */ new Map(),
+			providerRouteOwners: /* @__PURE__ */ new Map(),
+			runtimeStatesBySession: /* @__PURE__ */ new Map(),
 			publishedOAuthKeys: /* @__PURE__ */ new Map(),
 			providers: /* @__PURE__ */ new Map()
 		};
@@ -4161,6 +4615,17 @@ function sharedHostStateOf(ctx) {
 	}
 	return shared;
 }
+function packageRemountsOf(ctx, shared) {
+	const scoped = scopeOf(ctx);
+	const owner = typeof scoped === "object" && scoped !== null ? scoped : ctx;
+	const byOwner = shared.packageRemounts ??= /* @__PURE__ */ new WeakMap();
+	let remounts = byOwner.get(owner);
+	if (remounts === void 0) {
+		remounts = /* @__PURE__ */ new Map();
+		byOwner.set(owner, remounts);
+	}
+	return remounts;
+}
 /**
 * Image-admission companion routes: for every text-only route in the DSH
 * llm directory, a `<route>-vision` route that admits images at the host's
@@ -4285,11 +4750,15 @@ async function materializeAttachmentImage(ctx, attachment) {
 	}
 }
 function ensureLoginCommand(ctx, state) {
-	if (state.shared.loginRegistered === true) return;
-	state.shared.loginRegistered = true;
+	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);
 	try {
 		registerLoginCommand(ctx, state);
 	} 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)})`);
 	}
 }
@@ -4432,7 +4901,7 @@ function keepOAuthCredentialFresh(ctx, state) {
 	state.shared.oauthRefreshHooked = true;
 	ctx.on("llm/stream", ((options, next) => {
 		const provider = typeof options.provider === "string" ? options.provider : void 0;
-		const config = provider === void 0 ? void 0 : state.providers.get(provider);
+		const config = provider === void 0 ? void 0 : state.shared.providers.get(provider);
 		if (provider === void 0 || config === void 0 || !providerSupportsOAuth(config)) return next();
 		const publish = () => publishOAuthCredential(ctx, state, provider, config).catch((error) => logger(ctx).warn(`[pi2dsh] could not refresh the stored credential for ${JSON.stringify(provider)}: ${error instanceof Error ? error.message : String(error)}`));
 		return (async function* () {
@@ -4461,37 +4930,47 @@ function keepOAuthCredentialFresh(ctx, state) {
 async function discoverProviderModels(ctx, state, name, value) {
 	const refreshModels = value.refreshModels;
 	if (typeof refreshModels !== "function") return void 0;
+	const existing = state.shared.providerModelDiscoveries.get(name);
+	if (existing !== void 0) return await existing;
+	const task = (async () => {
+		try {
+			const apiKey = ((await resolvePiProviderAuth({
+				providerId: name,
+				providerConfig: value,
+				store: oauthStoreOf(state)
+			}).catch(() => void 0))?.auth)?.apiKey;
+			await Promise.resolve(refreshModels.call(value, {
+				stored: void 0,
+				...apiKey === void 0 ? {} : { credential: {
+					type: "api_key",
+					key: apiKey
+				} },
+				store: {
+					read: async () => void 0,
+					write: async () => {},
+					delete: async () => {}
+				},
+				allowNetwork: true,
+				signal: new AbortController().signal,
+				publish: async (publication) => {
+					publication.update?.();
+					return true;
+				}
+			}));
+		} catch (error) {
+			logger(ctx).warn(`[pi2dsh] model catalog refresh for Pi provider ${JSON.stringify(name)} failed (its registry entries stay static): ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		state.modelCatalog?.refresh();
+		state.providerRouteDisposers.get(name)?.reannounce?.();
+		return await llmOf(ctx)?.listModels(name).then((models) => models.length).catch(() => void 0);
+	})();
+	state.shared.providerModelDiscoveries.set(name, task);
 	try {
-		const apiKey = ((await resolvePiProviderAuth({
-			providerId: name,
-			providerConfig: value,
-			store: oauthStoreOf(state)
-		}).catch(() => void 0))?.auth)?.apiKey;
-		await Promise.resolve(refreshModels.call(value, {
-			stored: void 0,
-			...apiKey === void 0 ? {} : { credential: {
-				type: "api_key",
-				key: apiKey
-			} },
-			store: {
-				read: async () => void 0,
-				write: async () => {},
-				delete: async () => {}
-			},
-			allowNetwork: true,
-			signal: new AbortController().signal,
-			publish: async (publication) => {
-				publication.update?.();
-				return true;
-			}
-		}));
-	} catch (error) {
-		logger(ctx).warn(`[pi2dsh] model catalog refresh for Pi provider ${JSON.stringify(name)} failed (its registry entries stay static): ${error instanceof Error ? error.message : String(error)}`);
-		return;
+		return await task;
+	} finally {
+		if (state.shared.providerModelDiscoveries.get(name) === task) state.shared.providerModelDiscoveries.delete(name);
 	}
-	state.modelCatalog?.refresh();
-	state.providerRouteDisposers.get(name)?.reannounce?.();
-	return await llmOf(ctx)?.listModels(name).then((models) => models.length).catch(() => void 0);
 }
 function registerLoginCommand(ctx, state) {
 	registerCommand(ctx, state, {
@@ -4564,6 +5043,10 @@ function registerTool(ctx, state, tool) {
 	const normalized = normalizeToolSchema(tool.parameters);
 	for (const warning of normalized.warnings) logger(ctx).warn(`[pi2dsh] tool ${tool.name}: ${warning}`);
 	state.tools.set(tool.name, tool);
+	if (state.hostAnchor) {
+		state.toolDisposers.set(tool.name, () => {});
+		return;
+	}
 	const definition = {
 		name: tool.name,
 		description: tool.description,
@@ -4576,6 +5059,8 @@ function registerTool(ctx, state, tool) {
 		isConcurrencySafe: () => tool.executionMode === "parallel",
 		async execute(args, exec) {
 			const live = state.tools.get(tool.name) ?? tool;
+			const agent = exec.agent;
+			await ensurePiSessionStarted(ctx, state, agent, exec.signal);
 			const mutated = state.argMutations.get(exec);
 			if (mutated !== void 0) state.argMutations.delete(exec);
 			const effective = mutated ?? args;
@@ -4586,8 +5071,7 @@ function registerTool(ctx, state, tool) {
 				name: live.name,
 				arguments: live.prepareArguments?.(cloneJson(effective)) ?? effective
 			});
-			const agent = exec.agent;
-			const result = await normalizeToolResultForDsh(ctx, await state.agentScope.run(agent, () => live.execute(String(exec.callId), prepared, exec.signal, (update) => {
+			const result = await normalizeToolResultForDsh(ctx, await runInPiRuntime(state, agent, () => live.execute(String(exec.callId), prepared, exec.signal, (update) => {
 				dispatch(state, "tool_execution_update", {
 					type: "tool_execution_update",
 					toolCallId: String(exec.callId),
@@ -4621,6 +5105,12 @@ function currentAgent(state) {
 	if (scoped !== void 0) return scoped;
 	if (state.activeAgents.size === 1) return state.activeAgents.values().next().value;
 }
+/** Exact-Agent ownership for scoped mounts; legacy root mounts retain their old host-session rule. */
+function acceptsAgent(state, agent) {
+	if (state.hostAnchor) return false;
+	if (state.ownerAgent !== void 0) return agent === state.ownerAgent;
+	return !isSubagentOrigin(agent);
+}
 function toolRuntime(ctx, agent) {
 	return (agent?.ctx)?.tools ?? ctx.tools;
 }
@@ -4845,10 +5335,16 @@ async function executePiCommand(service, cwd, command, args, options) {
 		operation.cleanup();
 	}
 }
-function dshCommandName(ctx, piName) {
+function normalizedPiCommandName(piName) {
 	const normalized = piName.toLowerCase().replace(/[^a-z0-9_-]+/gu, "-").replace(/^[^a-z]+/u, "");
-	const name = normalized.length > 0 ? normalized : "pi-command";
-	if (name !== piName) logger(ctx).warn(`[pi2dsh] Pi command /${piName} registered as /${name} to satisfy DSH command naming`);
+	return normalized.length > 0 ? normalized : "pi-command";
+}
+function dshCommandName(ctx, state, piName) {
+	const name = commandNameForDshTui(normalizedPiCommandName(piName), state.tuiSurfaces?.available === true || optionalService(ctx, "tuiScenes") !== void 0);
+	if (name !== piName) {
+		const reason = name === "pi-mcp" ? "because dsh-TUI reserves /mcp for its native MCP status view" : "to satisfy DSH command naming";
+		logger(ctx).warn(`[pi2dsh] Pi command /${piName} registered as /${name} ${reason}`);
+	}
 	return name;
 }
 function registerCommand(ctx, state, command) {
@@ -4857,12 +5353,19 @@ function registerCommand(ctx, state, command) {
 		return;
 	}
 	state.commands.set(command.name, command);
+	if (state.hostAnchor) return;
 	const commands = ctx.get("commands");
 	if (commands === void 0) {
 		logger(ctx).warn(`[pi2dsh] command /${command.name} was not registered because this DSH composition has no ctx.commands`);
 		return;
 	}
-	const baseName = dshCommandName(ctx, command.name);
+	const baseName = dshCommandName(ctx, state, command.name);
+	const existingOwner = state.dshCommandOwners.get(baseName);
+	if (existingOwner !== void 0 && existingOwner !== command.name && normalizedPiCommandName(command.name) === baseName && normalizedPiCommandName(existingOwner) !== baseName) {
+		state.commandDisposers.get(existingOwner)?.();
+		state.commandDisposers.delete(existingOwner);
+		state.dshCommandOwners.delete(baseName);
+	}
 	const definitionFor = (dshName) => ({
 		name: dshName,
 		description: command.description || `Migrated Pi command /${command.name}`,
@@ -4871,7 +5374,10 @@ function registerCommand(ctx, state, command) {
 			const agent = invocation.agent;
 			const commandContext = contextFor(ctx, state, agent, invocation.signal, true);
 			const live = state.commands.get(command.name) ?? command;
-			await state.agentScope.run(agent, () => live.handler(String(invocation.rawInput ?? "").trimStart(), commandContext));
+			await runInPiRuntime(state, agent, async () => {
+				await ensurePiSessionStarted(ctx, state, agent, invocation.signal);
+				await live.handler(String(invocation.rawInput ?? "").trimStart(), commandContext);
+			});
 			const notices = commandContext.__notices;
 			return {
 				kind: "success",
@@ -4884,6 +5390,7 @@ function registerCommand(ctx, state, command) {
 		const dshName = ordinal === 1 ? baseName : `${baseName}-${ordinal}`;
 		try {
 			state.commandDisposers.set(command.name, commands.register(definitionFor(dshName)));
+			state.dshCommandOwners.set(dshName, command.name);
 			if (ordinal > 1) logger(ctx).warn(`[pi2dsh] command /${command.name} collides with an earlier registration in this host; mounted as /${dshName} (Pi numbers colliding commands the same way)`);
 			return;
 		} catch (error) {
@@ -4942,6 +5449,56 @@ function requireSession(state, operation) {
 	if (session === void 0) throw new Error(`pi2dsh: ${operation} requires one active DSH agent with a durable session`);
 	return session;
 }
+function releaseSharedProviderRoute(state, name) {
+	if (!state.ownedProviderRoutes.delete(name)) return;
+	const owners = state.shared.providerRouteOwners.get(name);
+	owners?.delete(state);
+	if (owners !== void 0 && owners.size > 0) return;
+	state.shared.providerRouteOwners.delete(name);
+	const route = state.shared.providerRouteDisposers.get(name);
+	state.shared.providerRouteDisposers.delete(name);
+	route?.();
+}
+function registerSharedProviderRoute(ctx, state, name, value) {
+	const shared = state.shared;
+	const existing = shared.providerRouteDisposers.get(name);
+	if (existing !== void 0) {
+		let owners = shared.providerRouteOwners.get(name);
+		if (owners === void 0) {
+			owners = /* @__PURE__ */ new Set();
+			shared.providerRouteOwners.set(name, owners);
+		}
+		owners.add(state);
+		state.ownedProviderRoutes.add(name);
+		return existing;
+	}
+	const canonical = shared.providers.get(name) ?? value;
+	shared.providers.set(name, canonical);
+	const route = registerPiProviderRoute({
+		llm: llmOf(ctx),
+		ctx,
+		providerId: name,
+		provider: canonical,
+		host: {
+			resolveAuth: async () => resolvePiProviderAuth({
+				providerId: name,
+				providerConfig: canonical,
+				store: oauthStoreOf(state)
+			}),
+			ensureModel: async () => {
+				await discoverProviderModels(ctx, state, name, canonical);
+			},
+			warn: (message) => logger(ctx).warn(message),
+			beforeProviderRequest: (payload, request) => dispatchHostProviderRequest(ctx, shared, state, payload, request),
+			resolveAttachments: () => optionalService(ctx, "attachments")
+		}
+	});
+	if (route === void 0) return void 0;
+	shared.providerRouteDisposers.set(name, route);
+	shared.providerRouteOwners.set(name, /* @__PURE__ */ new Set([state]));
+	state.ownedProviderRoutes.add(name);
+	return route;
+}
 function createPiApi(ctx, state) {
 	return {
 		on(event, handler) {
@@ -4971,28 +5528,23 @@ function createPiApi(ctx, state) {
 			const name = typeof providerOrName === "string" ? providerOrName : String(providerOrName?.id ?? providerOrName?.name ?? "unnamed");
 			const value = typeof providerOrName === "string" ? config ?? {} : providerOrName;
 			state.providers.set(name, value);
+			const sharedExisting = state.shared.providers.get(name);
+			if (sharedExisting === void 0 || BUILTIN_PROVIDER_SEEDS.has(sharedExisting)) {
+				state.shared.providers.set(name, value);
+				if (sharedExisting !== void 0) {
+					const stale = state.shared.providerRouteDisposers.get(name);
+					if (stale !== void 0) {
+						state.shared.providerRouteDisposers.delete(name);
+						state.shared.providerRouteOwners.delete(name);
+						stale();
+					}
+				}
+			}
 			if (providerSupportsOAuth(value)) {
 				ensureLoginCommand(ctx, state);
 				logger(ctx).info(`[pi2dsh] Pi provider ${JSON.stringify(name)} supports OAuth — log in with /login ${name}`);
 			}
-			const routeDisposer = registerPiProviderRoute({
-				llm: llmOf(ctx),
-				ctx,
-				providerId: name,
-				provider: value,
-				host: {
-					resolveAuth: async () => resolvePiProviderAuth({
-						providerId: name,
-						providerConfig: value,
-						store: oauthStoreOf(state)
-					}),
-					warn: (message) => logger(ctx).warn(message),
-					beforeProviderRequest: (payload, request) => dispatchBeforeProviderRequest(ctx, state, payload, request),
-					resolveAttachments: () => optionalService(ctx, "attachments")
-				}
-			});
-			if (routeDisposer !== void 0) {
-				state.providerRouteDisposers.set(name, routeDisposer);
+			if (registerSharedProviderRoute(ctx, state, name, value) !== void 0) {
 				state.modelCatalog?.refresh();
 				if (providerCarriesTransport(value)) logger(ctx).info(`[pi2dsh] Pi provider ${JSON.stringify(name)} registered as a native DSH llm route`);
 			} else if (!providerSupportsOAuth(value)) logger(ctx).info(`[pi2dsh] recorded Pi provider ${JSON.stringify(name)}; model calls stay on DSH llm adapters`);
@@ -5000,11 +5552,7 @@ function createPiApi(ctx, state) {
 		},
 		unregisterProvider(name) {
 			state.providers.delete(name);
-			const routeDisposer = state.providerRouteDisposers.get(name);
-			if (routeDisposer !== void 0) {
-				state.providerRouteDisposers.delete(name);
-				routeDisposer();
-			}
+			releaseSharedProviderRoute(state, name);
 		},
 		registerMessageRenderer(customType, renderer) {
 			state.messageRenderers.set(customType, renderer);
@@ -5200,15 +5748,10 @@ async function loadExtensions(rootDir, manifest, api, onExtensionError, onCapabi
 		resolveShim("pi-ai")
 	]);
 	const aliases = {};
+	const require = createRequire(import.meta.url);
 	for (const family of ["@earendil-works", "@mariozechner"]) {
 		aliases[`${family}/pi-coding-agent`] = codingAgentShim;
 		aliases[`${family}/pi-tui`] = tuiShim;
-		aliases[`${family}/pi-ai`] = aiShim;
-		aliases[`${family}/pi-ai/compat`] = aiShim;
-		aliases[`${family}/pi-ai/oauth`] = aiShim;
-		aliases[`${family}/pi-ai/providers/all`] = aiShim;
-		aliases[`${family}/pi-ai/bedrock-provider`] = aiShim;
-		aliases[`${family}/pi-ai/bun-oauth`] = aiShim;
 		for (const api of [
 			"anthropic-messages",
 			"openai-completions",
@@ -5220,9 +5763,19 @@ async function loadExtensions(rootDir, manifest, api, onExtensionError, onCapabi
 			"mistral-conversations",
 			"bedrock-converse-stream",
 			"pi-messages"
-		]) aliases[`${family}/pi-ai/api/${api}`] = aiShim;
+		]) {
+			try {
+				aliases[`${family}/pi-ai/api/${api}.lazy`] = fileURLToPath(import.meta.resolve(`@earendil-works/pi-ai/api/${api}.lazy`));
+			} catch {}
+			aliases[`${family}/pi-ai/api/${api}`] = aiShim;
+		}
+		aliases[`${family}/pi-ai/compat`] = aiShim;
+		aliases[`${family}/pi-ai/oauth`] = aiShim;
+		aliases[`${family}/pi-ai/providers/all`] = aiShim;
+		aliases[`${family}/pi-ai/bedrock-provider`] = aiShim;
+		aliases[`${family}/pi-ai/bun-oauth`] = aiShim;
+		aliases[`${family}/pi-ai`] = aiShim;
 	}
-	const require = createRequire(import.meta.url);
 	for (const entry of [
 		"typebox",
 		"typebox/value",
@@ -5272,9 +5825,13 @@ 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;
 	const state = {
 		shared,
 		packageName: options.manifest.package.name,
+		ownerAgent,
+		hostAnchor: options.hostAnchor === true,
 		handlers: /* @__PURE__ */ new Map(),
 		tools: runtimeTools,
 		runner: new ExtensionRunner(piToolRecords),
@@ -5282,21 +5839,33 @@ async function applyPiPackage(ctx, options) {
 		toolRestrictions: /* @__PURE__ */ new WeakMap(),
 		commands: /* @__PURE__ */ new Map(),
 		commandDisposers: /* @__PURE__ */ new Map(),
+		dshCommandOwners: /* @__PURE__ */ new Map(),
 		companionRoutes: shared.companionRoutes,
 		flags: /* @__PURE__ */ new Map(),
 		notifications: [],
 		activeAgents: /* @__PURE__ */ new Set(),
+		hostAgent: void 0,
+		piShutdownAgents: /* @__PURE__ */ new WeakSet(),
 		disposedAgents: /* @__PURE__ */ new WeakSet(),
+		startedSessions: /* @__PURE__ */ new Set(),
+		sessionStartTasks: /* @__PURE__ */ new Map(),
+		startedSessionlessAgents: /* @__PURE__ */ new WeakSet(),
+		sessionlessStartTasks: /* @__PURE__ */ new WeakMap(),
+		extensionsReady: false,
+		pendingSessionStarts: /* @__PURE__ */ new Map(),
 		currentSystemPrompt: "",
 		messageSource: `pi2dsh:${options.manifest.package.name}`,
 		eventBus: new EventEmitter(),
 		agentScope: new AsyncLocalStorage(),
+		llmBridge: void 0,
+		piAiRegistry: __createPiAiRuntimeRegistry(),
+		subagentSessionFactory: void 0,
 		bridge: new PiSessionBridge(),
 		theme: new Theme(),
 		shortcuts: /* @__PURE__ */ new Map(),
 		messageRenderers: /* @__PURE__ */ new Map(),
 		entryRenderers: /* @__PURE__ */ new Map(),
-		providers: shared.providers,
+		providers: /* @__PURE__ */ new Map(),
 		autocompleteProviders: [],
 		editorBuffers: /* @__PURE__ */ new WeakMap(),
 		toolsExpanded: false,
@@ -5314,31 +5883,42 @@ async function applyPiPackage(ctx, options) {
 		streamingTexts: /* @__PURE__ */ new Map(),
 		lastLoggedModels: /* @__PURE__ */ new WeakMap(),
 		providerRouteDisposers: shared.providerRouteDisposers,
-		publishedOAuthKeys: shared.publishedOAuthKeys
+		ownedProviderRoutes: /* @__PURE__ */ new Set(),
+		publishedOAuthKeys: shared.publishedOAuthKeys,
+		tuiSurfaces: void 0
 	};
+	mountTuiSurfaceAdapter(ctx, state.packageName, (adapter) => {
+		state.tuiSurfaces = adapter;
+	}, typeof ownerAgent?.id === "string" ? ownerAgent.id : void 0);
 	subscribeLifecycle(ctx, state);
 	subscribeInterceptors(ctx, state);
-	for (const provider of builtinProviders()) state.providers.set(provider.id, {
-		name: provider.name,
-		baseUrl: provider.baseUrl,
-		oauth: provider.auth.oauth
-	});
+	for (const provider of builtinProviders()) {
+		const config = {
+			name: provider.name,
+			baseUrl: provider.baseUrl,
+			oauth: provider.auth.oauth
+		};
+		BUILTIN_PROVIDER_SEEDS.add(config);
+		state.providers.set(provider.id, config);
+		if (!shared.providers.has(provider.id)) shared.providers.set(provider.id, config);
+	}
 	ensureLoginCommand(ctx, state);
 	for (const [name, config] of [...state.providers]) try {
 		await ensureLoggedInProviderRoute(ctx, state, name, config);
 	} catch (error) {
 		logger(ctx).warn(`[pi2dsh] could not restore the route for logged-in provider ${JSON.stringify(name)}: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	if (options.manifest.skillDirs.length > 0) {
+	if (options.manifest.skillDirs.length > 0 && state.ownerAgent === void 0) {
 		if (ctx.get("skills") === void 0) logger(ctx).warn("[pi2dsh] migrated skills were not mounted because this DSH composition has no ctx.skills");
 		else {
 			const { apply: applyFilesystemSkills } = await import("@deepseek-ai/dsh-skill-filesystem");
-			applyFilesystemSkills(ctx, {
+			const config = {
 				providerName: `pi2dsh-${options.manifest.package.name.replace(/[^a-zA-Z0-9_-]+/gu, "-").replace(/^-+|-+$/gu, "")}`,
 				includeDefaultRoots: false,
 				customSkillDirs: options.manifest.skillDirs.map((path) => join(rootDir, path)),
 				watch: false
-			});
+			};
+			await ctx.plugin(Object.assign((skillCtx) => applyFilesystemSkills(skillCtx, config), { inject: ["skills"] }));
 		}
 	}
 	const llm = llmOf(ctx);
@@ -5352,12 +5932,11 @@ async function applyPiPackage(ctx, options) {
 			});
 		}
 		await state.modelCatalog.refresh();
-		__setPiAiLlmBridge((model, context, callOptions) => streamViaDshLlm(llm, {
+		state.llmBridge = (model, context, callOptions) => streamViaDshLlm(llm, {
 			model,
 			context,
 			options: callOptions
-		}));
-		ctx.effect(() => () => __setPiAiLlmBridge(void 0));
+		});
 	}
 	const browserSurfaces = state.shared.browserSurfaces ??= new BrowserSurfaces();
 	if (state.shared.browserSurfacesRouted !== true) state.shared.browserSurfacesRouted = registerBrowserSurfaceRoute(ctx, browserSurfaces);
@@ -5416,7 +5995,7 @@ async function applyPiPackage(ctx, options) {
 		}
 		return rendered;
 	}));
-	__setSubagentSessionFactory(async (subagentOptions) => {
+	state.subagentSessionFactory = async (subagentOptions) => {
 		const created = await createBridgedAgentSession(subagentHost(), subagentOptions);
 		const parent = agentSession(currentAgent(state));
 		const parentId = parent === void 0 ? "" : String(parent.id ?? "");
@@ -5430,7 +6009,7 @@ async function applyPiPackage(ctx, options) {
 			ctx.effect(() => dispose);
 		}
 		return created;
-	});
+	};
 	const subagentHost = () => ({
 		cordis: ctx,
 		cwd: () => cwdOf(currentAgent(state)),
@@ -5451,7 +6030,6 @@ async function applyPiPackage(ctx, options) {
 		messageSource: state.messageSource,
 		packageName: state.packageName
 	});
-	ctx.effect(() => () => __setSubagentSessionFactory(void 0));
 	await registerPromptCommands(ctx, state, rootDir, options.manifest);
 	const onExtensionError = (failure) => logger(ctx).warn(`[pi2dsh] extension entry failed and was skipped (matching Pi's per-extension error isolation): ${failure}`);
 	const onCapabilityGap = (gap) => capabilityLedgerOf(ctx, state).reportUnusable({
@@ -5466,21 +6044,28 @@ async function applyPiPackage(ctx, options) {
 		guidance: "",
 		packageName: state.packageName
 	});
-	const mountExtensions = () => loadExtensions(rootDir, options.manifest, createPiApi(ctx, state), onExtensionError, onCapabilityGap, onHostInfraReference);
+	const mountExtensions = () => runInPiRuntime(state, currentAgent(state), () => loadExtensions(rootDir, options.manifest, createPiApi(ctx, state), onExtensionError, onCapabilityGap, onHostInfraReference));
 	await mountExtensions();
-	const remounts = shared.packageRemounts ??= /* @__PURE__ */ new Map();
+	await flushPendingSessionStarts(ctx, state);
+	const remounts = packageRemountsOf(ctx, shared);
 	remounts.set(state.packageName, async () => {
+		state.extensionsReady = false;
 		state.handlers.clear();
 		state.eventBus.removeAllListeners();
-		await registerPromptCommands(ctx, state, rootDir, options.manifest);
-		await mountExtensions();
+		try {
+			await registerPromptCommands(ctx, state, rootDir, options.manifest);
+			await mountExtensions();
+			await restartReloadedPiSessions(ctx, state);
+		} finally {
+			state.extensionsReady = true;
+		}
 	});
 	ctx.effect(() => () => {
 		remounts.delete(state.packageName);
 	});
 	const health = state.shared.capabilityLedger?.healthOf(state.packageName);
 	const healthSuffix = health === void 0 || health.status === "ok" ? "" : ` — ${health.status.toUpperCase()}: missing Pi capabilities ${health.gaps.join(", ")}`;
-	logger(ctx).info(`[pi2dsh] loaded ${options.manifest.package.name}: ${state.tools.size} tools, ${state.commands.size} commands, ${options.manifest.skillDirs.length} skill roots${healthSuffix}`);
+	logger(ctx).info(`[pi2dsh] loaded ${options.manifest.package.name}: ${state.tools.size} tools, ${state.commands.size} commands, ${options.manifest.skillDirs.length} skill roots${healthSuffix}${state.hostAnchor ? " (host anchor)" : ""}`);
 }
 const runtimeInternals = {
 	compactionReason,
@@ -5497,4 +6082,4 @@ const runtimeInternals = {
 //#endregion
 export { runtimeInternals as i, normalizeToolSchema as n, registerVisionCompanions as r, applyPiPackage as t };
 
-//# sourceMappingURL=runtime-DEjs_Qlf.mjs.map
+//# sourceMappingURL=runtime-Bb9Bfk4M.mjs.map