pi2dsh 0.2.0

package/dist/runtime-D84Hv_3m.mjs

@@ -0,0 +1,1499 @@
+
+import { t as getAgentDir } from "./pi-config-shim-CZ1wFzqM.mjs";
+import { x as Theme } from "./pi-coding-agent-Dsg6_0ua.mjs";
+import { createRequire } from "node:module";
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { EventEmitter } from "node:events";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createJiti } from "jiti";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+//#region src/session-bridge.ts
+function sidecarDir() {
+	return join(getAgentDir(), "session-entries");
+}
+function sessionEvents(session) {
+	const events = session.events;
+	return typeof events === "function" ? events.call(session) : events ?? [];
+}
+function dshToPiContent$1(content) {
+	if (!Array.isArray(content)) return [{
+		type: "text",
+		text: String(content ?? "")
+	}];
+	return content.map((block) => {
+		if (typeof block !== "object" || block === null) return {
+			type: "text",
+			text: String(block)
+		};
+		const record = block;
+		if (record.type === "text") return {
+			type: "text",
+			text: String(record.text ?? "")
+		};
+		if (record.type === "reasoning") return {
+			type: "thinking",
+			thinking: String(record.text ?? "")
+		};
+		if (record.type === "tool-call") return {
+			type: "toolCall",
+			id: record.id,
+			name: record.name,
+			arguments: record.arguments
+		};
+		return { type: record.type };
+	});
+}
+var PiSessionBridge = class {
+	records = /* @__PURE__ */ new Map();
+	loaded = /* @__PURE__ */ new Set();
+	sidecarPath(sessionId) {
+		const safe = sessionId.replace(/[^a-zA-Z0-9._-]+/gu, "_");
+		return join(sidecarDir(), `${safe}.jsonl`);
+	}
+	load(sessionId) {
+		if (this.loaded.has(sessionId)) return;
+		this.loaded.add(sessionId);
+		const path = this.sidecarPath(sessionId);
+		if (!existsSync(path)) {
+			this.records.set(sessionId, this.records.get(sessionId) ?? []);
+			return;
+		}
+		const parsed = [];
+		for (const line of readFileSync(path, "utf8").split("\n")) {
+			if (line.trim().length === 0) continue;
+			try {
+				parsed.push(JSON.parse(line));
+			} catch {}
+		}
+		this.records.set(sessionId, parsed);
+	}
+	persist(sessionId, record) {
+		this.load(sessionId);
+		const list = this.records.get(sessionId) ?? [];
+		list.push(record);
+		this.records.set(sessionId, list);
+		mkdirSync(sidecarDir(), { recursive: true });
+		appendFileSync(this.sidecarPath(sessionId), `${JSON.stringify(record)}\n`);
+	}
+	appendCustomEntry(sessionId, customType, data) {
+		const id = randomUUID();
+		this.persist(sessionId, {
+			kind: "custom",
+			id,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			customType,
+			...data === void 0 ? {} : { data }
+		});
+		return id;
+	}
+	appendLabel(sessionId, targetId, label) {
+		this.persist(sessionId, {
+			kind: "label",
+			id: randomUUID(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			targetId,
+			...label === void 0 ? {} : { label }
+		});
+	}
+	setName(sessionId, name) {
+		const sanitized = name.replace(/[\r\n]+/gu, " ").trim();
+		this.persist(sessionId, {
+			kind: "name",
+			id: randomUUID(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			name: sanitized
+		});
+	}
+	getName(sessionId) {
+		this.load(sessionId);
+		const list = this.records.get(sessionId) ?? [];
+		for (let i = list.length - 1; i >= 0; i -= 1) if (list[i].kind === "name") return list[i].name;
+	}
+	labels(sessionId) {
+		this.load(sessionId);
+		const labels = /* @__PURE__ */ new Map();
+		for (const record of this.records.get(sessionId) ?? []) {
+			if (record.kind !== "label" || record.targetId === void 0) continue;
+			if (record.label === void 0) labels.delete(record.targetId);
+			else labels.set(record.targetId, record.label);
+		}
+		return labels;
+	}
+	/**
+	* Project the DSH durable log plus sidecar records into Pi's entry-chain
+	* shape. DSH history is linear, so the projection is a single-branch tree:
+	* every entry's parent is its predecessor.
+	*/
+	projectEntries(session) {
+		this.load(session.id);
+		const merged = [];
+		for (const event of sessionEvents(session)) {
+			const seq = Number(event.seq ?? 0);
+			const time = Number(event.time ?? 0);
+			const data = event.data ?? {};
+			const type = event.type;
+			if (type === "user/message") merged.push({
+				time,
+				entry: {
+					type: "message",
+					id: `dsh-${seq}`,
+					timestamp: new Date(time).toISOString(),
+					message: {
+						role: "user",
+						content: dshToPiContent$1(data.content)
+					}
+				}
+			});
+			else if (type === "assistant/message") {
+				const message = data.message ?? {};
+				merged.push({
+					time,
+					entry: {
+						type: "message",
+						id: `dsh-${seq}`,
+						timestamp: new Date(time).toISOString(),
+						message: {
+							role: "assistant",
+							content: dshToPiContent$1(message.content)
+						}
+					}
+				});
+			} else if (type === "tool/result") {
+				const message = data.message ?? {};
+				const tool = (Array.isArray(message.content) ? message.content : []).find((block) => block.type === "tool-result");
+				merged.push({
+					time,
+					entry: {
+						type: "message",
+						id: `dsh-${seq}`,
+						timestamp: new Date(time).toISOString(),
+						message: {
+							role: "toolResult",
+							toolCallId: tool?.toolCallId,
+							content: dshToPiContent$1(tool?.content ?? []),
+							isError: tool?.isError === true
+						}
+					}
+				});
+			}
+		}
+		for (const record of this.records.get(session.id) ?? []) {
+			const time = Date.parse(record.timestamp);
+			if (record.kind === "custom") merged.push({
+				time,
+				entry: {
+					type: "custom",
+					id: record.id,
+					timestamp: record.timestamp,
+					customType: record.customType,
+					...record.data === void 0 ? {} : { data: record.data }
+				}
+			});
+			else if (record.kind === "label") merged.push({
+				time,
+				entry: {
+					type: "label",
+					id: record.id,
+					timestamp: record.timestamp,
+					targetId: record.targetId,
+					label: record.label
+				}
+			});
+			else merged.push({
+				time,
+				entry: {
+					type: "session_info",
+					id: record.id,
+					timestamp: record.timestamp,
+					name: record.name
+				}
+			});
+		}
+		merged.sort((left, right) => left.time - right.time);
+		const entries = [];
+		let parentId = null;
+		for (const item of merged) {
+			const entry = {
+				...item.entry,
+				parentId
+			};
+			entries.push(entry);
+			parentId = entry.id;
+		}
+		return entries;
+	}
+	/** The exact 14-method surface Pi exposes as ctx.sessionManager. */
+	readonlySessionManager(session, cwd) {
+		const entriesOf = () => this.projectEntries(session);
+		const leafOf = () => entriesOf().at(-1);
+		return {
+			getCwd: () => cwd,
+			getSessionDir: () => sidecarDir(),
+			getSessionId: () => session.id,
+			getSessionFile: () => this.sidecarPath(session.id),
+			getLeafId: () => leafOf()?.id ?? null,
+			getLeafEntry: () => leafOf(),
+			getEntry: (id) => entriesOf().find((entry) => entry.id === id),
+			getLabel: (id) => this.labels(session.id).get(id),
+			getBranch: (fromId) => {
+				const entries = entriesOf();
+				if (fromId === void 0) return entries;
+				const index = entries.findIndex((entry) => entry.id === fromId);
+				return index === -1 ? [] : entries.slice(0, index + 1);
+			},
+			buildContextEntries: () => entriesOf().filter((entry) => entry.type === "message" || entry.type === "compaction" || entry.type === "branch_summary" || entry.type === "custom_message"),
+			getHeader: () => ({
+				type: "session",
+				version: 3,
+				id: session.id,
+				timestamp: new Date(Number(sessionEvents(session)[0]?.time ?? Date.now())).toISOString(),
+				cwd
+			}),
+			getEntries: () => entriesOf(),
+			getTree: () => {
+				const entries = entriesOf();
+				const labels = this.labels(session.id);
+				let root;
+				let cursor;
+				for (const entry of entries) {
+					const node = {
+						entry,
+						children: [],
+						...labels.has(entry.id) ? { label: labels.get(entry.id) } : {}
+					};
+					if (cursor === void 0) root = node;
+					else cursor.children.push(node);
+					cursor = node;
+				}
+				return root === void 0 ? [] : [root];
+			},
+			getSessionName: () => this.getName(session.id)
+		};
+	}
+};
+//#endregion
+//#region src/runtime.ts
+function logger(ctx) {
+	const candidate = ctx.logger;
+	return {
+		warn: (message) => candidate?.warn?.(message) ?? console.warn(message),
+		info: (message) => candidate?.info?.(message) ?? console.info(message),
+		debug: (message) => candidate?.debug?.(message) ?? void 0
+	};
+}
+function cloneJson(value) {
+	return structuredClone(value);
+}
+function jsonEqual(left, right) {
+	try {
+		return JSON.stringify(left) === JSON.stringify(right);
+	} catch {
+		return false;
+	}
+}
+function jsonValue(value) {
+	if (value === void 0) return null;
+	try {
+		return JSON.parse(JSON.stringify(value));
+	} catch {
+		return String(value);
+	}
+}
+function textBlocks(content) {
+	if (!Array.isArray(content)) return [{
+		type: "text",
+		text: String(content ?? "")
+	}];
+	return content.map((block) => {
+		if (typeof block === "object" && block !== null && block.type === "text") return {
+			type: "text",
+			text: String(block.text ?? "")
+		};
+		if (typeof block === "object" && block !== null && block.type === "image") return {
+			type: "text",
+			text: `[Pi tool returned ${String(block.mimeType ?? "image")}; binary image output requires a native DSH attachment adapter]`
+		};
+		return {
+			type: "text",
+			text: String(block)
+		};
+	});
+}
+function normalizeToolResult(result) {
+	if (typeof result !== "object" || result === null || Array.isArray(result)) return {
+		content: [{
+			type: "text",
+			text: String(result ?? "")
+		}],
+		details: null
+	};
+	const record = result;
+	return {
+		content: textBlocks(record.content),
+		details: jsonValue(record.details),
+		...record.isError === true ? { isError: true } : {},
+		...record.usage !== void 0 ? { usage: jsonValue(record.usage) } : {},
+		...record.terminate === true ? { terminate: true } : {}
+	};
+}
+async function piToDshContent(ctx, content) {
+	const values = Array.isArray(content) ? content : [{
+		type: "text",
+		text: String(content ?? "")
+	}];
+	const blocks = [];
+	for (const value of values) {
+		if (typeof value !== "object" || value === null) {
+			blocks.push({
+				type: "text",
+				text: String(value)
+			});
+			continue;
+		}
+		const block = value;
+		if (block.type === "text") {
+			blocks.push({
+				type: "text",
+				text: String(block.text ?? "")
+			});
+			continue;
+		}
+		if (block.type !== "image") {
+			blocks.push({
+				type: "text",
+				text: String(value)
+			});
+			continue;
+		}
+		const attachments = optionalService(ctx, "attachments");
+		if (attachments === void 0) throw new Error("pi2dsh: Pi image content requires the DSH attachments service");
+		if (typeof block.data !== "string" || typeof block.mimeType !== "string") throw new TypeError("pi2dsh: Pi image content requires base64 data and mimeType");
+		const attachment = await attachments.saveImage({
+			data: Buffer.from(block.data, "base64"),
+			mediaType: block.mimeType,
+			...typeof block.name === "string" ? { name: block.name } : {}
+		});
+		blocks.push({
+			type: "image",
+			attachment
+		});
+	}
+	return blocks;
+}
+async function normalizeToolResultForDsh(ctx, result) {
+	if (typeof result !== "object" || result === null || Array.isArray(result)) return {
+		content: [{
+			type: "text",
+			text: String(result ?? "")
+		}],
+		details: null
+	};
+	const record = result;
+	return {
+		content: await piToDshContent(ctx, record.content),
+		details: jsonValue(record.details),
+		...record.isError === true ? { isError: true } : {},
+		...record.usage !== void 0 ? { usage: jsonValue(record.usage) } : {},
+		...record.terminate === true ? { terminate: true } : {}
+	};
+}
+const SUPPORTED_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"oneOf",
+	"anyOf",
+	"properties",
+	"required",
+	"additionalProperties",
+	"items",
+	"enum",
+	"const",
+	"description",
+	"title",
+	"default",
+	"examples"
+]);
+function normalizeSchemaNode(value, path, warnings) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		warnings.push(`${path}: non-object schema replaced with unconstrained JSON`);
+		return {};
+	}
+	const source = value;
+	const output = {};
+	for (const key of Object.keys(source)) if (!SUPPORTED_SCHEMA_KEYS.has(key)) warnings.push(`${path}.${key}: constraint is not enforced by DSH and was dropped`);
+	const type = source.type;
+	if (typeof type === "string" && [
+		"object",
+		"array",
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"null"
+	].includes(type)) output.type = type;
+	else if (type !== void 0) warnings.push(`${path}.type: unsupported type was dropped`);
+	const union = Array.isArray(source.oneOf) ? source.oneOf : Array.isArray(source.anyOf) ? source.anyOf : void 0;
+	if (union !== void 0) {
+		if (source.anyOf !== void 0) warnings.push(`${path}.anyOf: converted to DSH exact-one oneOf semantics`);
+		output.oneOf = union.map((entry, index) => normalizeSchemaNode(entry, `${path}.oneOf[${index}]`, warnings));
+		delete output.type;
+	}
+	if (output.type === "object") {
+		const properties = typeof source.properties === "object" && source.properties !== null && !Array.isArray(source.properties) ? source.properties : {};
+		output.properties = Object.fromEntries(Object.entries(properties).map(([key, entry]) => [key, normalizeSchemaNode(entry, `${path}.properties.${key}`, warnings)]));
+		if (Array.isArray(source.required)) output.required = source.required.filter((item) => typeof item === "string");
+		if (typeof source.additionalProperties === "boolean") output.additionalProperties = source.additionalProperties;
+		else if (source.additionalProperties !== void 0) {
+			output.additionalProperties = true;
+			warnings.push(`${path}.additionalProperties: schema-valued form widened to true`);
+		}
+	}
+	if (output.type === "array" && source.items !== void 0) output.items = normalizeSchemaNode(source.items, `${path}.items`, warnings);
+	if (Array.isArray(source.enum)) output.enum = source.enum.filter((item) => item === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof item));
+	if (source.const === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof source.const)) output.const = source.const;
+	for (const annotation of ["description", "title"]) if (typeof source[annotation] === "string") output[annotation] = source[annotation];
+	for (const annotation of ["default", "examples"]) if (source[annotation] !== void 0) output[annotation] = jsonValue(source[annotation]);
+	return output;
+}
+function normalizeToolSchema(schema) {
+	const warnings = [];
+	const normalized = normalizeSchemaNode(schema, "$", warnings);
+	if (normalized.type !== "object") throw new TypeError("Pi tool parameters must use an object-root TypeBox schema");
+	return {
+		schema: normalized,
+		warnings
+	};
+}
+function cwdOf(agent) {
+	const session = agent?.session;
+	if (typeof session === "object" && session !== null) {
+		const header = session.header;
+		if (typeof header === "object" && header !== null && typeof header.cwd === "string") return header.cwd;
+	}
+	return process.cwd();
+}
+function unsupported(name) {
+	throw new Error(`pi2dsh: Pi API ${name} requires a native DSH port; inspect the compatibility report`);
+}
+function optionalService(ctx, name) {
+	return ctx.get(name);
+}
+function requireAgent(state, operation) {
+	const agent = currentAgent(state);
+	if (agent === void 0) throw new Error(`pi2dsh: ${operation} requires one active DSH agent context`);
+	return agent;
+}
+function answerText(answer) {
+	if (answer === void 0) return void 0;
+	if (typeof answer.custom === "string" && answer.custom.length > 0) return answer.custom;
+	const selected = answer.selected;
+	return Array.isArray(selected) && typeof selected[0] === "string" ? selected[0] : void 0;
+}
+async function askOne(ctx, agent, signal, question) {
+	const service = optionalService(ctx, "userQuestions");
+	if (service === void 0) unsupported("ctx.ui AskUser");
+	return answerText((await service.ask({
+		questions: [question],
+		...agent !== void 0 ? { agent } : {},
+		signal
+	})).answers.find((answer) => answer.id === question.id));
+}
+function agentSession(agent) {
+	const session = agent?.session;
+	if (typeof session !== "object" || session === null) return void 0;
+	const record = session;
+	if (typeof record.id !== "string") return void 0;
+	return record;
+}
+function thinkingLevelOf(state, agent) {
+	if (agent !== void 0) {
+		const scoped = state.thinkingLevels.get(agent);
+		if (scoped !== void 0) return scoped;
+	}
+	return state.globalThinkingLevel;
+}
+function contextFor(ctx, state, agent, signal, command = false) {
+	const notices = [];
+	const userQuestions = optionalService(ctx, "userQuestions");
+	const ui = {
+		notify(message) {
+			const text = String(message);
+			notices.push(text);
+			state.notifications.push(text);
+			logger(ctx).info(`[pi2dsh] ${text}`);
+		},
+		select: (title, options) => askOne(ctx, agent, signal, {
+			id: "pi2dsh-select",
+			question: String(title),
+			options: options.map((option) => ({ label: String(option) }))
+		}),
+		async confirm(title, message) {
+			return await askOne(ctx, agent, signal, {
+				id: "pi2dsh-confirm",
+				question: String(title),
+				detail: String(message),
+				options: [{ label: "Yes" }, { label: "No" }]
+			}) === "Yes";
+		},
+		input: (title, placeholder) => askOne(ctx, agent, signal, {
+			id: "pi2dsh-input",
+			question: String(title),
+			...placeholder === void 0 ? {} : { detail: String(placeholder) }
+		}),
+		editor: (title, prefill) => askOne(ctx, agent, signal, {
+			id: "pi2dsh-editor",
+			question: String(title),
+			...prefill === void 0 ? {} : { detail: `Current text:\n${String(prefill)}` }
+		}),
+		setStatus: () => void 0,
+		setWidget: () => void 0,
+		onTerminalInput: () => () => void 0,
+		setWorkingMessage: () => void 0,
+		setWorkingVisible: () => void 0,
+		setWorkingIndicator: () => void 0,
+		setHiddenThinkingLabel: () => void 0,
+		setFooter: () => void 0,
+		setHeader: () => void 0,
+		setTitle: () => void 0,
+		custom: async () => void 0,
+		pasteToEditor(text) {
+			if (agent !== void 0) state.editorBuffers.set(agent, (state.editorBuffers.get(agent) ?? "") + String(text));
+		},
+		setEditorText(text) {
+			if (agent !== void 0) state.editorBuffers.set(agent, String(text));
+		},
+		getEditorText: () => agent === void 0 ? "" : state.editorBuffers.get(agent) ?? "",
+		addAutocompleteProvider(factory) {
+			state.autocompleteProviders.push(factory);
+		},
+		setEditorComponent(factory) {
+			state.editorComponentFactory = factory;
+		},
+		getEditorComponent: () => state.editorComponentFactory,
+		get theme() {
+			return state.theme;
+		},
+		getAllThemes: () => [{
+			name: state.theme.name,
+			path: void 0
+		}],
+		getTheme: (name) => name === state.theme.name ? state.theme : void 0,
+		setTheme: (target) => typeof target === "object" || target === state.theme.name ? { success: true } : {
+			success: false,
+			error: `pi2dsh headless mode ships a single theme (${state.theme.name})`
+		},
+		getToolsExpanded: () => state.toolsExpanded,
+		setToolsExpanded(expanded) {
+			state.toolsExpanded = expanded === true;
+		}
+	};
+	const session = agentSession(agent);
+	const base = {
+		ui,
+		mode: "rpc",
+		hasUI: userQuestions !== void 0,
+		cwd: cwdOf(agent),
+		sessionManager: session === void 0 ? state.bridge.readonlySessionManager({
+			id: "pi2dsh-detached",
+			events: []
+		}, cwdOf(agent)) : state.bridge.readonlySessionManager(session, cwdOf(agent)),
+		modelRegistry: {
+			getAll: () => [],
+			getAvailable: () => [],
+			find: (_provider, _modelId) => void 0,
+			getError: () => void 0,
+			hasConfiguredAuth: (_model) => false,
+			getProviderAuthStatus: (_provider) => "none",
+			getProvider: (_provider) => void 0,
+			getProviderDisplayName: (provider) => provider,
+			getProviderAuth: async (_provider) => void 0,
+			getApiKeyForProvider: async (_provider) => void 0,
+			isUsingOAuth: (_model) => false,
+			refresh: async () => ({
+				models: [],
+				errors: []
+			})
+		},
+		model: agent === void 0 ? void 0 : state.modelOverrides.get(agent),
+		scopedModels: [],
+		thinkingLevel: thinkingLevelOf(state, agent),
+		isIdle: () => command,
+		isProjectTrusted: () => false,
+		signal,
+		abort: () => {
+			const target = agent;
+			if (typeof target?.cancel !== "function") unsupported("ctx.abort without a live DSH agent");
+			target.cancel({
+				kind: "hook",
+				reason: "pi2dsh: aborted by migrated Pi extension"
+			});
+		},
+		hasPendingMessages: () => false,
+		shutdown: () => unsupported("ctx.shutdown"),
+		getContextUsage: () => void 0,
+		compact: () => unsupported("ctx.compact"),
+		getSystemPrompt: () => state.currentSystemPrompt,
+		__agent: agent,
+		__notices: notices
+	};
+	if (command) Object.assign(base, {
+		getSystemPromptOptions: () => ({}),
+		waitForIdle: async () => {
+			const wait = agent?.whenIdle;
+			if (typeof wait === "function") await wait.call(agent);
+		},
+		newSession: () => unsupported("ctx.newSession"),
+		fork: () => unsupported("ctx.fork"),
+		navigateTree: () => unsupported("ctx.navigateTree"),
+		switchSession: () => unsupported("ctx.switchSession"),
+		reload: () => unsupported("ctx.reload")
+	});
+	return base;
+}
+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)));
+	return results;
+}
+function dshToPiContent(content) {
+	return content.map((block) => {
+		if (block.type === "text") return {
+			type: "text",
+			text: block.text
+		};
+		if (block.type === "reasoning") return {
+			type: "thinking",
+			thinking: block.text
+		};
+		if (block.type === "tool-call") return {
+			type: "toolCall",
+			id: block.id,
+			name: block.name,
+			arguments: block.arguments
+		};
+		return { type: block.type };
+	});
+}
+function messageFromSessionEvent(event) {
+	const type = event.type;
+	const data = event.data;
+	if (typeof data !== "object" || data === null) return void 0;
+	const record = data;
+	if (type === "user/message") return {
+		role: "user",
+		content: dshToPiContent(record.content ?? [])
+	};
+	if (type === "assistant/message") {
+		const message = record.message;
+		return {
+			role: "assistant",
+			content: dshToPiContent(message?.content ?? [])
+		};
+	}
+	if (type === "tool/result") {
+		const tool = (record.message?.content ?? []).find((block) => block.type === "tool-result");
+		return {
+			role: "toolResult",
+			toolCallId: tool?.toolCallId,
+			content: dshToPiContent(tool?.content ?? []),
+			isError: tool?.isError === true
+		};
+	}
+}
+function sourceReason(value) {
+	return value === "resume" ? "resume" : value === "fork" ? "fork" : "startup";
+}
+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;
+		state.activeAgents.add(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));
+	});
+	cordis.on("agent/disposed", (payload) => {
+		const agent = payload.agent;
+		state.activeAgents.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);
+			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) => {
+		const agent = [...state.activeAgents].find((candidate) => candidate.session === session);
+		const eventContext = contextFor(ctx, state, agent, void 0);
+		const type = event.type;
+		if (type === "turn/start") {
+			const turn = Number(event.data.turn ?? 1);
+			dispatch(state, "agent_start", { type: "agent_start" }, eventContext).catch((error) => warn("agent_start", error));
+			dispatch(state, "turn_start", {
+				type: "turn_start",
+				turnIndex: turn - 1,
+				timestamp: event.time ?? Date.now()
+			}, eventContext).catch((error) => warn("turn_start", error));
+		}
+		if (type === "tool/call") {
+			const data = event.data;
+			let args = {};
+			try {
+				args = JSON.parse(String(data.arguments ?? "{}"));
+			} catch {
+				args = {};
+			}
+			dispatch(state, "tool_execution_start", {
+				type: "tool_execution_start",
+				toolCallId: data.callId,
+				toolName: data.name,
+				args
+			}, eventContext).catch((error) => warn("tool_execution_start", error));
+		}
+		if (type === "assistant/chunk" && (state.handlers.get("message_update")?.length ?? 0) > 0) {
+			const data = event.data;
+			const chunk = data.chunk ?? {};
+			const key = `${String(session.id ?? "")}:${String(data.turn ?? 0)}:${String(data.step ?? 0)}`;
+			const delta = typeof chunk.text === "string" ? chunk.text : typeof chunk.delta === "string" ? chunk.delta : "";
+			const accumulated = (state.streamingTexts.get(key) ?? "") + delta;
+			state.streamingTexts.set(key, accumulated);
+			dispatch(state, "message_update", {
+				type: "message_update",
+				message: {
+					role: "assistant",
+					content: [{
+						type: "text",
+						text: accumulated
+					}]
+				},
+				assistantMessageEvent: chunk
+			}, eventContext).catch((error) => warn("message_update", error));
+		}
+		if (type === "assistant/message") {
+			const data = event.data;
+			state.streamingTexts.delete(`${String(session.id ?? "")}:${String(data.turn ?? 0)}:${String(data.step ?? 0)}`);
+		}
+		if (type === "session/title") {
+			const data = event.data;
+			dispatch(state, "session_info_changed", {
+				type: "session_info_changed",
+				name: typeof data.title === "string" ? data.title : void 0
+			}, eventContext).catch((error) => warn("session_info_changed", error));
+		}
+		if (type === "compaction/start") dispatch(state, "session_before_compact", {
+			type: "session_before_compact",
+			preparation: { ...event.data },
+			branchEntries: [],
+			reason: "threshold",
+			willRetry: false
+		}, eventContext).catch((error) => warn("session_before_compact", error));
+		if (type === "compaction/end" || type === "compaction/summary") {
+			const data = event.data;
+			dispatch(state, "session_compact", {
+				type: "session_compact",
+				compactionEntry: {
+					type: "compaction",
+					id: `dsh-${String(event.seq ?? "")}`,
+					summary: typeof data.summary === "string" ? data.summary : "",
+					...data
+				},
+				fromExtension: false,
+				reason: "threshold",
+				willRetry: false
+			}, eventContext).catch((error) => warn("session_compact", error));
+		}
+		if (type === "request/header") {
+			const header = event.data.header ?? {};
+			const model = header.model ?? header.config?.model;
+			if (model !== void 0 && agent !== void 0) {
+				const previous = state.lastLoggedModels.get(agent);
+				if (previous !== void 0 && previous !== String(model)) dispatch(state, "model_select", {
+					type: "model_select",
+					model: { id: String(model) },
+					previousModel: { id: previous },
+					source: "set"
+				}, eventContext).catch((error) => warn("model_select", error));
+				state.lastLoggedModels.set(agent, String(model));
+			}
+		}
+		const message = messageFromSessionEvent(event);
+		if (message !== void 0) dispatch(state, "message_start", {
+			type: "message_start",
+			message
+		}, eventContext).then(() => dispatch(state, "message_end", {
+			type: "message_end",
+			message
+		}, eventContext)).catch((error) => warn("message lifecycle", error));
+		if (type === "turn/end") {
+			const data = event.data;
+			dispatch(state, "turn_end", {
+				type: "turn_end",
+				turnIndex: Number(data.turn ?? 1) - 1,
+				message: {
+					role: "assistant",
+					content: []
+				},
+				toolResults: []
+			}, eventContext).then(() => dispatch(state, "agent_end", {
+				type: "agent_end",
+				messages: []
+			}, eventContext)).then(() => dispatch(state, "agent_settled", { type: "agent_settled" }, eventContext)).catch((error) => warn("turn end lifecycle", error));
+		}
+	});
+	cordis.on("agent/request", async (payload, next) => {
+		const config = await next();
+		const agent = payload.agent;
+		if (agent === void 0) return config;
+		const override = state.modelOverrides.get(agent);
+		const thinking = state.thinkingLevels.get(agent);
+		if (override === void 0 && thinking === void 0) return config;
+		return {
+			...config,
+			...override?.provider === void 0 ? {} : { provider: override.provider },
+			...override?.model === void 0 ? {} : { model: override.model },
+			...thinking === void 0 || thinking === "off" ? {} : { reasoningEffort: thinking }
+		};
+	});
+	cordis.on("tools/result", (exec, result) => {
+		const agent = exec.agent;
+		dispatch(state, "tool_execution_end", {
+			type: "tool_execution_end",
+			toolCallId: exec.callId,
+			toolName: exec.name,
+			result: {
+				content: dshToPiContent(result.content),
+				details: result.meta ?? null
+			},
+			isError: result.isError
+		}, contextFor(ctx, state, agent, exec.signal)).catch((error) => warn("tool_execution_end", error));
+	});
+	cordis.effect(() => async () => {
+		for (const agent of state.activeAgents) if (typeof agent === "object" && agent !== null && !state.disposedAgents.has(agent)) {
+			state.disposedAgents.add(agent);
+			await dispatch(state, "session_shutdown", {
+				type: "session_shutdown",
+				reason: "quit"
+			}, contextFor(ctx, state, agent, void 0));
+		}
+		state.activeAgents.clear();
+		for (const dispose of state.toolDisposers.values()) dispose();
+		state.toolDisposers.clear();
+		state.eventBus.removeAllListeners();
+	}, "pi2dsh session shutdown");
+}
+function subscribeInterceptors(ctx, state) {
+	const cordis = ctx;
+	cordis.on("tools/pre-execute", async (exec, next) => {
+		const input = cloneJson(exec.arguments);
+		const event = {
+			type: "tool_call",
+			toolName: exec.name,
+			toolCallId: exec.callId,
+			input
+		};
+		const results = await dispatch(state, "tool_call", event, contextFor(ctx, state, exec.agent, exec.signal));
+		if (!jsonEqual(event.input, exec.arguments)) {
+			if (state.tools.has(exec.name)) state.argMutations.set(exec, cloneJson(event.input));
+			else return {
+				kind: "deny",
+				reason: `pi2dsh: a Pi tool_call hook mutated arguments of native DSH tool ${JSON.stringify(exec.name)}; DSH logs arguments before policy, so this mutation cannot be honored`
+			};
+		}
+		for (const result of results) if (typeof result === "object" && result !== null && result.block === true) return {
+			kind: "deny",
+			reason: String(result.reason ?? "blocked by migrated Pi tool_call hook")
+		};
+		return next();
+	});
+	cordis.on("tools/post-execute", async (exec, result, next) => {
+		const downstream = await next();
+		if (downstream.kind === "block") return downstream;
+		const event = {
+			type: "tool_result",
+			toolName: exec.name,
+			toolCallId: exec.callId,
+			input: cloneJson(exec.arguments),
+			content: dshToPiContent(result.content),
+			details: result.meta ?? null,
+			isError: result.isError,
+			usage: void 0
+		};
+		const results = await dispatch(state, "tool_result", event, contextFor(ctx, state, exec.agent, exec.signal));
+		for (const patch of results) {
+			if (typeof patch !== "object" || patch === null) continue;
+			Object.assign(event, patch);
+		}
+		const content = textBlocks(event.content);
+		if (event.isError === true && !result.isError) return {
+			kind: "block",
+			feedback: content
+		};
+		if (event.isError === false && result.isError) logger(ctx).warn("[pi2dsh] a Pi tool_result hook attempted to recover a DSH error; error recovery was ignored");
+		if (!jsonEqual(event.content, dshToPiContent(result.content))) return {
+			kind: "accept",
+			content
+		};
+		return downstream;
+	});
+	cordis.on("system-prompt/assemble", async (assembly, assembleContext, next) => {
+		const downstream = await next();
+		if ((state.handlers.get("before_agent_start")?.length ?? 0) === 0) return downstream;
+		const original = renderPrompt(downstream);
+		state.currentSystemPrompt = original;
+		const event = {
+			type: "before_agent_start",
+			prompt: "",
+			systemPrompt: original,
+			systemPromptOptions: {}
+		};
+		const results = await dispatch(state, "before_agent_start", event, contextFor(ctx, state, assembleContext.scope, assembleContext.signal));
+		let replacement = original;
+		for (const result of results) {
+			if (typeof result === "object" && result !== null && typeof result.systemPrompt === "string") {
+				replacement = result.systemPrompt;
+				event.systemPrompt = replacement;
+			}
+			if (typeof result === "object" && result !== null && result.message !== void 0) logger(ctx).warn("[pi2dsh] before_agent_start custom-message injection is unsupported and was ignored");
+		}
+		state.currentSystemPrompt = replacement;
+		return {
+			...downstream,
+			sections: [{
+				name: "pi2dsh:system-prompt",
+				text: replacement
+			}]
+		};
+	});
+}
+function registerTool(ctx, state, tool) {
+	if (state.tools.has(tool.name)) throw new Error(`Pi tool ${JSON.stringify(tool.name)} is already registered`);
+	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);
+	const definition = {
+		name: tool.name,
+		description: tool.description,
+		parameters: normalized.schema,
+		output: {
+			schema: {},
+			render: (_args, value) => value.content,
+			presentationMeta: (_args, value) => jsonValue(value.details)
+		},
+		isConcurrencySafe: () => tool.executionMode === "parallel",
+		async execute(args, exec) {
+			const mutated = state.argMutations.get(exec);
+			if (mutated !== void 0) state.argMutations.delete(exec);
+			const effective = mutated ?? args;
+			const prepared = tool.prepareArguments?.(cloneJson(effective)) ?? effective;
+			const agent = exec.agent;
+			const result = await normalizeToolResultForDsh(ctx, await state.agentScope.run(agent, () => tool.execute(String(exec.callId), prepared, exec.signal, (update) => {
+				dispatch(state, "tool_execution_update", {
+					type: "tool_execution_update",
+					toolCallId: String(exec.callId),
+					toolName: tool.name,
+					args: prepared,
+					partialResult: jsonValue(update)
+				}, contextFor(ctx, state, agent, exec.signal)).catch((error) => logger(ctx).warn(`[pi2dsh] tool_execution_update handler failed: ${String(error)}`));
+			}, contextFor(ctx, state, agent, exec.signal))));
+			if (result.terminate === true) exec.concludeTurn();
+			if (result.isError === true) {
+				const message = textBlocks(result.content).map((block) => block.text).filter(Boolean).join("\n");
+				throw new Error(message || `Pi tool ${tool.name} failed`);
+			}
+			return result;
+		}
+	};
+	const dispose = ctx.tools.register(definition);
+	state.toolDisposers.set(tool.name, dispose);
+}
+function unregisterTool(state, name) {
+	const dispose = state.toolDisposers.get(name);
+	if (dispose === void 0) return false;
+	dispose();
+	state.toolDisposers.delete(name);
+	state.tools.delete(name);
+	return true;
+}
+function currentAgent(state) {
+	const scoped = state.agentScope.getStore();
+	if (scoped !== void 0) return scoped;
+	if (state.activeAgents.size === 1) return state.activeAgents.values().next().value;
+}
+function toolRuntime(ctx, agent) {
+	return (agent?.ctx)?.tools ?? ctx.tools;
+}
+function getActiveTools(ctx, state) {
+	const agent = currentAgent(state);
+	return toolRuntime(ctx, agent).schemas(agent).map((tool) => tool.name);
+}
+function setActiveTools(ctx, state, names) {
+	const unique = [...new Set(names)];
+	const agent = currentAgent(state);
+	state.pendingActiveTools = unique;
+	if (agent === void 0 || typeof agent !== "object" || agent === null) return;
+	const scopedTools = agent.ctx === void 0 ? void 0 : toolRuntime(ctx, agent);
+	if (scopedTools === void 0 || typeof scopedTools.restrict !== "function") {
+		logger(ctx).warn("[pi2dsh] setActiveTools deferred: the current agent exposes no scoped tools.restrict()");
+		return;
+	}
+	state.toolRestrictions.get(agent)?.();
+	state.toolRestrictions.set(agent, scopedTools.restrict({ allow: unique }));
+}
+function deliverAgentMessage(agent, message, mode) {
+	const deliver = agent[mode];
+	if (typeof deliver !== "function") throw new Error(`pi2dsh: active DSH agent has no ${mode}() delivery method`);
+	deliver.call(agent, message);
+}
+async function sendPiMessage(ctx, state, content, mode) {
+	const agent = requireAgent(state, mode === "inject" ? "sendMessage" : "sendUserMessage");
+	const blocks = await piToDshContent(ctx, typeof content === "string" ? [{
+		type: "text",
+		text: content
+	}] : content);
+	deliverAgentMessage(agent, createUserMessage({
+		content: blocks,
+		source: {
+			kind: "plugin",
+			plugin: state.messageSource
+		}
+	}), mode);
+}
+function combineExecSignal(options) {
+	const controller = new AbortController();
+	let killed = false;
+	let timer;
+	const abort = (reason) => {
+		if (controller.signal.aborted) return;
+		killed = true;
+		controller.abort(reason);
+	};
+	const onAbort = () => abort(options.signal?.reason ?? /* @__PURE__ */ new Error("Pi exec aborted"));
+	if (options.signal?.aborted) onAbort();
+	else options.signal?.addEventListener("abort", onAbort, { once: true });
+	if (typeof options.timeout === "number" && Number.isFinite(options.timeout) && options.timeout > 0) timer = setTimeout(() => abort(/* @__PURE__ */ new Error(`Pi exec timed out after ${options.timeout}ms`)), options.timeout);
+	return {
+		signal: controller.signal,
+		killed: () => killed,
+		cleanup() {
+			if (timer !== void 0) clearTimeout(timer);
+			options.signal?.removeEventListener("abort", onAbort);
+		}
+	};
+}
+async function executePiCommand(service, cwd, command, args, options) {
+	const operation = combineExecSignal(options);
+	try {
+		if (typeof command !== "string" || command.length === 0) throw new TypeError("Pi exec command must be a non-empty string");
+		if (!Array.isArray(args) || args.some((value) => typeof value !== "string")) throw new TypeError("Pi exec args must be strings");
+		const executable = await service.resolveExecutable(command, void 0, operation.signal);
+		const collect = { maxBytes: 67108864 };
+		const handle = service.spawn({
+			argv: [executable, ...args],
+			cwd: options.cwd ?? cwd,
+			stdio: {
+				stdin: "ignore",
+				stdout: collect,
+				stderr: collect
+			},
+			graceMs: 5e3,
+			signal: operation.signal
+		});
+		const outcome = await handle.done;
+		const stdout = handle.collected.stdout?.readFrom(0);
+		const stderr = handle.collected.stderr?.readFrom(0);
+		const truncation = [stdout?.lossy ? "stdout" : "", stderr?.lossy ? "stderr" : ""].filter(Boolean);
+		return {
+			stdout: stdout?.text ?? "",
+			stderr: `${stderr?.text ?? ""}${truncation.length === 0 ? "" : `\n[pi2dsh: ${truncation.join(" and ")} exceeded the 64 MiB compatibility limit]`}`,
+			code: outcome.exitCode ?? 0,
+			killed: operation.killed()
+		};
+	} catch (error) {
+		return {
+			stdout: "",
+			stderr: error instanceof Error ? error.message : String(error),
+			code: operation.signal.aborted ? 0 : 1,
+			killed: operation.killed()
+		};
+	} finally {
+		operation.cleanup();
+	}
+}
+function dshCommandName(ctx, 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 name;
+}
+function registerCommand(ctx, state, command) {
+	if (state.commands.has(command.name)) throw new Error(`Pi command ${JSON.stringify(command.name)} is already registered`);
+	state.commands.set(command.name, command);
+	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;
+	}
+	commands.register({
+		name: dshCommandName(ctx, command.name),
+		description: command.description || `Migrated Pi command /${command.name}`,
+		...command.argumentHint !== void 0 ? { input: { hint: command.argumentHint } } : {},
+		async handler(invocation) {
+			const agent = invocation.agent;
+			const commandContext = contextFor(ctx, state, agent, invocation.signal, true);
+			await state.agentScope.run(agent, () => command.handler(String(invocation.rawInput ?? "").trimStart(), commandContext));
+			const notices = commandContext.__notices;
+			return {
+				kind: "success",
+				...notices.length > 0 ? { text: notices.join("\n") } : {}
+			};
+		}
+	});
+}
+function requireSession(state, operation) {
+	const session = agentSession(currentAgent(state));
+	if (session === void 0) throw new Error(`pi2dsh: ${operation} requires one active DSH agent with a durable session`);
+	return session;
+}
+function createPiApi(ctx, state) {
+	return {
+		on(event, handler) {
+			const list = state.handlers.get(event) ?? [];
+			list.push(handler);
+			state.handlers.set(event, list);
+		},
+		registerTool: (tool) => registerTool(ctx, state, tool),
+		unregisterTool: (name) => unregisterTool(state, name),
+		registerCommand(name, options) {
+			registerCommand(ctx, state, {
+				name,
+				description: typeof options.description === "string" ? options.description : `Migrated Pi command /${name}`,
+				...typeof options.argumentHint === "string" ? { argumentHint: options.argumentHint } : {},
+				handler: options.handler
+			});
+		},
+		registerShortcut(shortcut, options) {
+			state.shortcuts.set(shortcut, options);
+		},
+		registerFlag(name, options) {
+			state.flags.set(name, options.default);
+			logger(ctx).warn(`[pi2dsh] Pi flag --${name} uses its default only; DSH CLI registration is unsupported`);
+		},
+		getFlag: (name) => state.flags.get(name),
+		registerProvider(providerOrName, config) {
+			const name = typeof providerOrName === "string" ? providerOrName : String(providerOrName?.name ?? "unnamed");
+			const value = typeof providerOrName === "string" ? config ?? {} : providerOrName;
+			state.providers.set(name, value);
+			logger(ctx).info(`[pi2dsh] recorded Pi provider ${JSON.stringify(name)}; model calls stay on DSH llm adapters`);
+		},
+		unregisterProvider(name) {
+			state.providers.delete(name);
+		},
+		registerMessageRenderer(customType, renderer) {
+			state.messageRenderers.set(customType, renderer);
+		},
+		registerEntryRenderer(customType, renderer) {
+			state.entryRenderers.set(customType, renderer);
+		},
+		registerMarkdownTransformer(transformer) {
+			state.markdownTransformer = transformer;
+		},
+		sendMessage(message, options = {}) {
+			requireAgent(state, "sendMessage");
+			const mode = options.deliverAs === "steer" ? "steer" : options.deliverAs === "followUp" || options.deliverAs === "nextTurn" || options.triggerTurn === true ? "followup" : "inject";
+			return sendPiMessage(ctx, state, message.content, mode);
+		},
+		sendUserMessage(content, options = {}) {
+			requireAgent(state, "sendUserMessage");
+			return sendPiMessage(ctx, state, content, options.deliverAs === "steer" ? "steer" : "followup");
+		},
+		appendEntry(customType, data) {
+			const session = requireSession(state, "appendEntry");
+			state.bridge.appendCustomEntry(session.id, customType, data);
+		},
+		setSessionName(name) {
+			const session = requireSession(state, "setSessionName");
+			state.bridge.setName(session.id, String(name));
+			dispatch(state, "session_info_changed", {
+				type: "session_info_changed",
+				name: state.bridge.getName(session.id)
+			}, contextFor(ctx, state, currentAgent(state), void 0)).catch((error) => logger(ctx).warn(`[pi2dsh] session_info_changed handler failed: ${String(error)}`));
+		},
+		getSessionName() {
+			const session = agentSession(currentAgent(state));
+			return session === void 0 ? void 0 : state.bridge.getName(session.id);
+		},
+		setLabel(entryId, label) {
+			const session = requireSession(state, "setLabel");
+			state.bridge.appendLabel(session.id, String(entryId), label);
+		},
+		exec(command, args = [], options = {}) {
+			const service = optionalService(ctx, "subprocess");
+			if (service === void 0) unsupported("exec");
+			return executePiCommand(service, cwdOf(currentAgent(state)), command, args, options);
+		},
+		getActiveTools: () => getActiveTools(ctx, state),
+		getAllTools: () => toolRuntime(ctx, currentAgent(state)).schemas(currentAgent(state)).map((tool) => ({
+			name: tool.name,
+			description: tool.description ?? "",
+			parameters: tool.parameters ?? {},
+			source: state.tools.has(tool.name) ? "extension" : "builtin",
+			sourceInfo: {
+				path: "",
+				source: state.tools.has(tool.name) ? "pi2dsh" : "dsh",
+				scope: "session",
+				origin: "runtime"
+			}
+		})),
+		setActiveTools: (names) => setActiveTools(ctx, state, names),
+		getCommands: () => [...state.commands.values()].map((command) => ({
+			name: command.name,
+			description: command.description,
+			source: "extension",
+			sourceInfo: {
+				path: "",
+				source: "pi2dsh",
+				scope: "user",
+				origin: "package"
+			}
+		})),
+		async setModel(model) {
+			const agent = currentAgent(state);
+			if (agent === void 0) return false;
+			const override = {
+				...typeof model?.provider === "string" ? { provider: model.provider } : {},
+				...typeof model?.id === "string" ? { model: model.id } : {}
+			};
+			if (override.model === void 0) return false;
+			state.modelOverrides.set(agent, override);
+			dispatch(state, "model_select", {
+				type: "model_select",
+				model,
+				previousModel: state.modelOverrides.get(agent),
+				source: "set"
+			}, contextFor(ctx, state, agent, void 0)).catch((error) => logger(ctx).warn(`[pi2dsh] model_select handler failed: ${String(error)}`));
+			return true;
+		},
+		getThinkingLevel: () => thinkingLevelOf(state, currentAgent(state)),
+		setThinkingLevel(level) {
+			const agent = currentAgent(state);
+			const previousLevel = thinkingLevelOf(state, agent);
+			if (agent === void 0) state.globalThinkingLevel = String(level);
+			else state.thinkingLevels.set(agent, String(level));
+			dispatch(state, "thinking_level_select", {
+				type: "thinking_level_select",
+				level: String(level),
+				previousLevel
+			}, contextFor(ctx, state, agent, void 0)).catch((error) => logger(ctx).warn(`[pi2dsh] thinking_level_select handler failed: ${String(error)}`));
+		},
+		events: {
+			emit(channel, data) {
+				state.eventBus.emit(channel, data);
+			},
+			on(channel, handler) {
+				const safeHandler = (data) => {
+					Promise.resolve(handler(data)).catch((error) => logger(ctx).warn(`[pi2dsh] package event ${channel} handler failed: ${String(error)}`));
+				};
+				state.eventBus.on(channel, safeHandler);
+				return () => state.eventBus.off(channel, safeHandler);
+			}
+		}
+	};
+}
+function splitArguments(input) {
+	const values = [];
+	let current = "";
+	let quote;
+	for (const character of input) if (quote !== void 0) {
+		if (character === quote) quote = void 0;
+		else current += character;
+	} else if (character === "\"" || character === "'") quote = character;
+	else if (/\s/u.test(character)) {
+		if (current.length > 0) {
+			values.push(current);
+			current = "";
+		}
+	} else current += character;
+	if (current.length > 0) values.push(current);
+	return values;
+}
+function promptBody(text) {
+	const normalized = text.replace(/\r\n?/gu, "\n");
+	if (!normalized.startsWith("---")) return normalized;
+	const endIndex = normalized.indexOf("\n---", 3);
+	if (endIndex === -1) return normalized;
+	return normalized.slice(endIndex + 4).trim();
+}
+function expandPrompt(text, rawInput) {
+	const args = splitArguments(rawInput);
+	const all = args.join(" ");
+	return promptBody(text).replace(/\$\{(\d+|ARGUMENTS|@):-([^}]*)\}|\$\{@:(\d+)(?::(\d+))?\}|\$(ARGUMENTS|@|\d+)/gu, (_match, defaultTarget, fallback, sliceStart, sliceLength, simple) => {
+		if (defaultTarget !== void 0) return (defaultTarget === "@" || defaultTarget === "ARGUMENTS" ? all : args[Number(defaultTarget) - 1]) || fallback || "";
+		if (sliceStart !== void 0) {
+			const offset = Math.max(0, Number(sliceStart) - 1);
+			return args.slice(offset, sliceLength === void 0 ? void 0 : offset + Number(sliceLength)).join(" ");
+		}
+		if (simple === "@" || simple === "ARGUMENTS") return all;
+		return args[Number(simple) - 1] ?? "";
+	});
+}
+async function registerPromptCommands(ctx, state, rootDir, manifest) {
+	for (const prompt of manifest.prompts) {
+		const text = await readFile(join(rootDir, prompt.path), "utf8");
+		registerCommand(ctx, state, {
+			name: prompt.name,
+			description: prompt.description,
+			...prompt.argumentHint !== void 0 ? { argumentHint: prompt.argumentHint } : {},
+			handler(rawInput, commandContext) {
+				const invocationAgent = commandContext.__agent ?? [...state.activeAgents][0];
+				if (invocationAgent === void 0 || typeof invocationAgent.steer !== "function") throw new Error(`pi2dsh: /${prompt.name} requires a live DSH agent`);
+				invocationAgent.steer(createUserMessage({
+					content: [{
+						type: "text",
+						text: expandPrompt(text, rawInput)
+					}],
+					source: {
+						kind: "plugin",
+						plugin: `pi2dsh:${manifest.package.name}`,
+						form: "relay"
+					}
+				}));
+			}
+		});
+	}
+}
+async function loadExtensions(rootDir, manifest, api, onExtensionError) {
+	const resolveShim = async (name) => {
+		const compiled = fileURLToPath(new URL(`./compat/${name}.mjs`, import.meta.url));
+		try {
+			await access(compiled);
+			return compiled;
+		} catch {
+			return fileURLToPath(new URL(`./compat/${name}.ts`, import.meta.url));
+		}
+	};
+	const [codingAgentShim, tuiShim, aiShim] = await Promise.all([
+		resolveShim("pi-coding-agent"),
+		resolveShim("pi-tui"),
+		resolveShim("pi-ai")
+	]);
+	const aliases = {};
+	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;
+	}
+	const require = createRequire(import.meta.url);
+	for (const entry of [
+		"typebox",
+		"typebox/value",
+		"typebox/compile"
+	]) try {
+		const resolved = require.resolve(entry);
+		aliases[entry] = resolved;
+		aliases[entry.replace("typebox", "@sinclair/typebox")] = resolved;
+	} catch {}
+	const jiti = createJiti(import.meta.url, {
+		interopDefault: true,
+		alias: aliases
+	});
+	const failures = [];
+	let mounted = 0;
+	for (const extension of manifest.extensions) try {
+		const loaded = await jiti.import(join(rootDir, extension));
+		const candidate = typeof loaded === "object" && loaded !== null && "default" in loaded ? loaded.default : loaded;
+		if (typeof candidate !== "function") throw new TypeError(`Pi extension ${extension} has no default factory function`);
+		await candidate(api);
+		mounted += 1;
+	} catch (error) {
+		failures.push(`${extension}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (failures.length > 0 && mounted === 0 && manifest.extensions.length > 0) throw new Error(`every Pi extension entry failed to load:\n${failures.map((item) => `- ${item}`).join("\n")}`);
+	for (const failure of failures) onExtensionError?.(failure);
+}
+async function applyPiPackage(ctx, options) {
+	if (options.manifest.schemaVersion !== 1) throw new Error(`unsupported pi2dsh manifest version ${String(options.manifest.schemaVersion)}`);
+	const rootDir = fileURLToPath(options.rootUrl);
+	const state = {
+		handlers: /* @__PURE__ */ new Map(),
+		tools: /* @__PURE__ */ new Map(),
+		toolDisposers: /* @__PURE__ */ new Map(),
+		toolRestrictions: /* @__PURE__ */ new WeakMap(),
+		commands: /* @__PURE__ */ new Map(),
+		flags: /* @__PURE__ */ new Map(),
+		notifications: [],
+		activeAgents: /* @__PURE__ */ new Set(),
+		disposedAgents: /* @__PURE__ */ new WeakSet(),
+		currentSystemPrompt: "",
+		messageSource: `pi2dsh:${options.manifest.package.name}`,
+		eventBus: new EventEmitter(),
+		agentScope: new AsyncLocalStorage(),
+		bridge: new PiSessionBridge(),
+		theme: new Theme(),
+		shortcuts: /* @__PURE__ */ new Map(),
+		messageRenderers: /* @__PURE__ */ new Map(),
+		entryRenderers: /* @__PURE__ */ new Map(),
+		providers: /* @__PURE__ */ new Map(),
+		autocompleteProviders: [],
+		editorBuffers: /* @__PURE__ */ new WeakMap(),
+		toolsExpanded: false,
+		modelOverrides: /* @__PURE__ */ new WeakMap(),
+		thinkingLevels: /* @__PURE__ */ new WeakMap(),
+		globalThinkingLevel: "off",
+		argMutations: /* @__PURE__ */ new WeakMap(),
+		streamingTexts: /* @__PURE__ */ new Map(),
+		lastLoggedModels: /* @__PURE__ */ new WeakMap()
+	};
+	subscribeLifecycle(ctx, state);
+	subscribeInterceptors(ctx, state);
+	if (options.manifest.skillDirs.length > 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, {
+				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 registerPromptCommands(ctx, state, rootDir, options.manifest);
+	await loadExtensions(rootDir, options.manifest, createPiApi(ctx, state), (failure) => logger(ctx).warn(`[pi2dsh] extension entry failed and was skipped (matching Pi's per-extension error isolation): ${failure}`));
+	logger(ctx).info(`[pi2dsh] loaded ${options.manifest.package.name}: ${state.tools.size} tools, ${state.commands.size} commands, ${options.manifest.skillDirs.length} skill roots`);
+}
+const runtimeInternals = {
+	expandPrompt,
+	normalizeToolResult,
+	splitArguments,
+	textBlocks
+};
+//#endregion
+export { normalizeToolSchema as n, runtimeInternals as r, applyPiPackage as t };
+
+//# sourceMappingURL=runtime-D84Hv_3m.mjs.map