@agimon-ai/po-core 0.0.0-alpha.0

package/dist/src/services/piExtensionHost/index.mjs

@@ -0,0 +1,885 @@
+import { DOOM_CORDIS_SERVER_SERVICES, connectDoomCordisHost } from "../../../runtimeCordisHost.mjs";
+import { toDoomHeadlessToolResult } from "../../schemas/headless.mjs";
+import { SessionIdentityDoc, SessionMetadataDoc } from "../../../sqliteSessionStorage.mjs";
+import { contextTokensOf, contextUsageOf, latestAssistantUsage } from "../contextUsage/index.mjs";
+import { fromPiSessionEntry, toPiFileEntries, toPiSessionEntries, toPiSessionEntry } from "../piSessionEntries/index.mjs";
+import { readFileSync } from "node:fs";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { isDeepStrictEqual } from "node:util";
+import { DefaultPackageManager, DefaultResourceLoader, ExtensionRunner, ModelRegistry, SessionManager, SettingsManager, createEventBus, discoverAndLoadExtensions, initTheme, loadSkills, sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
+//#region src/services/piExtensionHost/index.ts
+/**
+* Extension entries of the packages listed under `packages` in Pi's settings.json.
+*
+* Interactive Pi expands that list through its resource loader, which this server does not run,
+* so a provider package such as a local Claude Code bridge would load under `pi` and be missing
+* here. Only `packages` entries are taken: Pi's top-level `extensions` list can name Po
+* itself, and the auto-discovered `extensions/` folders are already loaded by
+* `discoverAndLoadExtensions`. A package that is not installed is skipped, never installed, so
+* starting a session cannot trigger a network install.
+*/
+async function resolvePiSettingsPackageEntries(options) {
+	try {
+		return (await new DefaultPackageManager({
+			cwd: options.cwd,
+			agentDir: options.agentDir,
+			settingsManager: options.settings
+		}).resolve(async (source) => {
+			options.onNotice?.(`Pi package ${source} is not installed; skipped. Install it with pi to load it here.`);
+			return "skip";
+		})).extensions.filter((resource) => resource.enabled && resource.metadata.origin === "package").map((resource) => resource.path);
+	} catch (error) {
+		options.onNotice?.(`Pi settings packages: ${error instanceof Error ? error.message : String(error)}`);
+		return [];
+	}
+}
+async function loadWithResourceLoader(options, factories, events) {
+	const loader = new DefaultResourceLoader({
+		cwd: options.cwd,
+		agentDir: options.agentDir,
+		settingsManager: SettingsManager.inMemory(),
+		eventBus: events,
+		additionalExtensionPaths: [...options.extensionPaths],
+		extensionFactories: [...factories],
+		noExtensions: true,
+		noSkills: true,
+		noPromptTemplates: true,
+		noThemes: true,
+		noContextFiles: true
+	});
+	await loader.reload();
+	return loader.getExtensions();
+}
+/**
+* Load Pi extensions and apply their provider registrations to the model runtime.
+*
+* `pi.registerProvider` only queues into the extension runtime while extensions load; Pi drains
+* that queue in `ExtensionRunner.bindCore`. The runner cannot exist before the harness runtime,
+* and the harness runtime is built from an already-resolved model, so waiting for `bindCore`
+* would resolve the session's default model before extension providers exist and silently fall
+* back to the first available model. Draining the queue here puts provider registration ahead of
+* model resolution.
+*
+* The result is returned so `createPiExtensionHost` reuses it instead of discovering again, which
+* keeps every extension factory running exactly once.
+*/
+async function preloadPiExtensions(options) {
+	const factories = options.extensionFactories ?? [];
+	if (options.extensionPaths.length === 0 && factories.length === 0) return void 0;
+	const events = createEventBus();
+	const result = options.extensionFactories === void 0 ? await discoverAndLoadExtensions([...options.extensionPaths], options.cwd, options.agentDir, events) : await loadWithResourceLoader(options, factories, events);
+	for (const failure of result.errors) options.onNotice?.(`Pi extension ${failure.path}: ${failure.error}`);
+	const registry = new ModelRegistry(options.models);
+	const report = (extensionPath, error) => options.onNotice?.(`Pi extension ${extensionPath}: provider registration failed: ${error instanceof Error ? error.message : String(error)}`);
+	for (const pending of result.runtime.pendingProviderRegistrations) try {
+		registry.registerProvider(pending.name, pending.config);
+	} catch (error) {
+		report(pending.extensionPath, error);
+	}
+	for (const pending of result.runtime.pendingNativeProviderRegistrations) try {
+		registry.registerProvider(pending.provider);
+	} catch (error) {
+		report(pending.extensionPath, error);
+	}
+	result.runtime.pendingProviderRegistrations = [];
+	result.runtime.pendingNativeProviderRegistrations = [];
+	return Object.assign(result, { events });
+}
+/**
+* Pi native extensions are session lifetime. They contribute tools once and are never
+* retracted, so they are merged at the harness apply boundary rather than contributed to the
+* headless kernel, whose active layers come solely from server bundle candidates and would
+* drop any owner that is not a declared facet package.
+*
+* Their event handlers are a second surface. Pi drives them from an interactive
+* AgentSession this server does not run, so the handful the harness can speak to
+* faithfully are bridged here: the two agent-loop notifications an extension needs
+* to observe a turn, and the three hooks that let one shape or replace context.
+* Everything else stays undelivered rather than being approximated.
+*/
+function formatSkillsForSystemPrompt(skills) {
+	const escape = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+	const visible = skills.filter((skill) => !skill.disableModelInvocation);
+	return visible.length ? `\n\n<available_skills>\n${visible.map((skill) => `<skill><name>${escape(skill.name)}</name><description>${escape(skill.description)}</description><location>${escape(skill.filePath)}</location></skill>`).join("\n")}\n</available_skills>` : "";
+}
+/**
+* The compaction boundary, named the way Pi names it.
+*
+* Pi identifies the cut by the first entry it keeps; the harness carries the kept
+* messages inline instead. Counting whole entries back from the tip until the kept
+* messages are covered recovers the id, and {@link retainedTailFrom} is its exact
+* inverse, so an extension that echoes the id it was given gets its own tail back.
+*/
+function boundaryEntryId(branchEntries, retainedCount) {
+	let remaining = retainedCount;
+	for (let index = branchEntries.length - 1; index >= 0; index -= 1) {
+		const entry = branchEntries[index];
+		if (entry === void 0) continue;
+		if (remaining <= 0) return entry.id;
+		remaining -= sessionEntryToContextMessages(entry).length;
+		if (remaining <= 0) return entry.id;
+	}
+	return branchEntries[0]?.id;
+}
+/** The messages an entry id keeps, which is what the harness stores on the compaction entry. */
+function retainedTailFrom(branchEntries, firstKeptEntryId) {
+	const index = branchEntries.findIndex((entry) => entry.id === firstKeptEntryId);
+	if (index === -1) return [];
+	return branchEntries.slice(index).flatMap((entry) => sessionEntryToContextMessages(entry));
+}
+function toPiCompactionPreparation(preparation, branchEntries) {
+	return {
+		firstKeptEntryId: boundaryEntryId(branchEntries, preparation.retainedTail.length) ?? "",
+		messagesToSummarize: preparation.messagesToSummarize,
+		turnPrefixMessages: preparation.turnPrefixMessages,
+		isSplitTurn: preparation.isSplitTurn,
+		tokensBefore: preparation.tokensBefore,
+		...preparation.previousSummary === void 0 ? {} : { previousSummary: preparation.previousSummary },
+		fileOps: preparation.fileOps,
+		settings: preparation.settings
+	};
+}
+function toHarnessCompactResult(result, branchEntries) {
+	return {
+		summary: result.summary,
+		tokensBefore: result.tokensBefore,
+		retainedTail: retainedTailFrom(branchEntries, result.firstKeptEntryId),
+		...result.usage === void 0 ? {} : { usage: result.usage },
+		...result.details === void 0 ? {} : { details: result.details }
+	};
+}
+function piBranchEntries(entries) {
+	return toPiSessionEntries(entries);
+}
+async function executePiTool(registered, runner, isActive, toolCallId, parameters, signal, onUpdate, alreadyPrepared = false) {
+	const definition = registered.definition;
+	if (!isActive(definition.name)) throw new Error(`Tool '${definition.name}' is no longer active`);
+	const prepared = !alreadyPrepared && definition.prepareArguments ? definition.prepareArguments(parameters) : parameters;
+	const result = await definition.execute(toolCallId, prepared, signal, (partial) => onUpdate?.(toDoomHeadlessToolResult(partial)), runner().createToolContext(toolCallId, signal));
+	return toDoomHeadlessToolResult(result);
+}
+function toHarnessTool(registered, runner, isActive) {
+	const definition = registered.definition;
+	return {
+		name: definition.name,
+		label: definition.label ?? definition.name,
+		description: definition.description,
+		parameters: definition.parameters,
+		prepareArguments: definition.prepareArguments,
+		...definition.executionMode === void 0 ? {} : { executionMode: definition.executionMode },
+		async execute(toolCallId, parameters, onUpdate, _toolContext, _invocation, context) {
+			const result = await executePiTool(registered, runner, isActive, toolCallId, parameters, context.abortSignal, (partial) => onUpdate({
+				content: partial.content,
+				details: partial.details
+			}), true);
+			if (result.isError) {
+				const text = result.content.map((part) => part.type === "text" ? part.text : "").join("\n");
+				throw new Error(text || `Tool '${definition.name}' failed`);
+			}
+			return {
+				content: result.content,
+				details: result.details
+			};
+		}
+	};
+}
+/**
+* Resolves the skills Pi extensions contribute.
+*
+* Pi wires this through AgentSession's resource loader, which the headless server does not use,
+* so the pipeline is rebuilt here against the harness. Pi's own loader parses and validates the
+* frontmatter; only the body has to be read, because Pi's Skill record carries a path where the
+* harness wants inline content.
+*/
+async function loadPiSkills(runner, cwd, agentDir, onNotice) {
+	const discovered = await runner.emitResourcesDiscover(cwd, "startup");
+	if (discovered.skillPaths.length === 0) return [];
+	const loaded = loadSkills({
+		cwd,
+		agentDir,
+		skillPaths: discovered.skillPaths.map((entry) => entry.path),
+		includeDefaults: false
+	});
+	for (const diagnostic of loaded.diagnostics) onNotice?.(`Pi skill ${diagnostic.path}: ${diagnostic.message}`);
+	const resolved = [];
+	for (const skill of loaded.skills) try {
+		resolved.push({
+			name: skill.name,
+			description: skill.description,
+			content: readFileSync(skill.filePath, "utf8"),
+			filePath: skill.filePath,
+			...skill.disableModelInvocation ? { disableModelInvocation: true } : {}
+		});
+	} catch (error) {
+		onNotice?.(`Pi skill ${skill.filePath}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return resolved;
+}
+/**
+* A SessionManager backed by the session the server already has open.
+*
+* Pi extensions read history through a SessionManager, which is JSONL backed, while the server
+* persists to SQLite through the harness. Rather than opening a second connection and taking a
+* second history lease, the manager is hydrated in memory from the live session and its writes
+* are mirrored back through the same harness runtime.
+*
+* `_persist` is public in Pi's source and in its shipped types, but it is not a documented
+* extension point, so the guard below turns a rename in a future Pi release into an immediate,
+* named failure instead of history that silently stops being recorded.
+*/
+/**
+* Pi's default theme, reached through public API only.
+*
+* The singleton lives in Pi's interactive theme module, which the package `exports` map does not
+* expose, so a deep import fails with ERR_PACKAGE_PATH_NOT_EXPORTED. A freshly constructed runner
+* still carries Pi's own no-op UI context, whose `theme` getter returns that singleton, so reading
+* it back before binding is the supported route. The getter throws until `initTheme` has run.
+*/
+function resolveDefaultTheme(runner) {
+	try {
+		return runner.getUIContext().theme;
+	} catch {
+		initTheme(void 0, false);
+		return runner.getUIContext().theme;
+	}
+}
+/**
+* Pi's extension UI surface, backed by the headless client the server already speaks.
+*
+* Dialogs, notifications and status text have a real transport, so they are wired through. The
+* members that need a live TUI (custom components, widgets, footer, header, editor component,
+* autocomplete, terminal input, themes) have no headless equivalent and degrade to the same no-ops
+* Pi's own RPC mode uses, rather than throwing into extension code that checked `hasUI` first.
+*/
+function createHeadlessUiContext(client, theme) {
+	const ask = async (request, signal) => {
+		const target = client();
+		if (target === void 0) return void 0;
+		return await target.request(request, signal);
+	};
+	return {
+		async select(title, options, opts) {
+			const answer = await ask({
+				kind: "select",
+				title,
+				options: options.map((option) => ({
+					label: option,
+					value: option
+				}))
+			}, opts?.signal);
+			return typeof answer === "string" ? answer : void 0;
+		},
+		async confirm(title, message, opts) {
+			return await ask({
+				kind: "confirm",
+				title,
+				message
+			}, opts?.signal) === true;
+		},
+		async input(title, _placeholder, opts) {
+			const answer = await ask({
+				kind: "input",
+				title
+			}, opts?.signal);
+			return typeof answer === "string" ? answer : void 0;
+		},
+		async editor(title, prefill) {
+			const answer = await ask({
+				kind: "input",
+				title,
+				multiline: true,
+				...prefill === void 0 ? {} : { initialValue: prefill }
+			});
+			return typeof answer === "string" ? answer : void 0;
+		},
+		notify(message, type) {
+			if (message.length === 0) return;
+			client()?.notify({
+				body: message,
+				...type === void 0 ? {} : { level: type }
+			});
+		},
+		setStatus(key, text) {
+			client()?.setStatus(key, text);
+		},
+		pasteToEditor(text) {
+			client()?.appendComposerText?.(text);
+		},
+		onTerminalInput: () => () => {},
+		setWorkingMessage: () => {},
+		setWorkingVisible: () => {},
+		setWorkingIndicator: () => {},
+		setHiddenThinkingLabel: () => {},
+		setWidget: () => {},
+		setFooter: () => {},
+		setHeader: () => {},
+		setTitle: () => {},
+		custom: async () => void 0,
+		setEditorText: () => {},
+		getEditorText: () => "",
+		addAutocompleteProvider: () => {},
+		setEditorComponent: () => {},
+		getEditorComponent: () => void 0,
+		theme,
+		getAllThemes: () => [],
+		getTheme: () => void 0,
+		setTheme: () => ({
+			success: false,
+			error: "Themes are not available in the headless server"
+		}),
+		getToolsExpanded: () => false,
+		setToolsExpanded: () => {}
+	};
+}
+const bridgedSessionSync = /* @__PURE__ */ new WeakMap();
+async function createBridgedSessionManager(runtime, cwd, onNotice, branchEntries) {
+	const identity = await runtime.session.snapshot(SessionIdentityDoc, BACKGROUND_CONTEXT);
+	const storedMetadata = await runtime.session.snapshot(SessionMetadataDoc, BACKGROUND_CONTEXT);
+	const metadata = {
+		id: runtime.sessionId,
+		cwd: storedMetadata?.workspaceRoot || cwd,
+		createdAt: identity?.createdAt ?? Date.now(),
+		parentSessionId: identity?.parentSessionId || void 0
+	};
+	const entries = branchEntries ?? (await runtime.readEntries()).entries;
+	const header = {
+		id: metadata.id,
+		cwd: metadata.cwd ?? cwd,
+		createdAt: metadata.createdAt,
+		...metadata.parentSessionId === void 0 ? {} : { parentSessionId: metadata.parentSessionId }
+	};
+	const manager = SessionManager.inMemory(header.cwd, {
+		id: metadata.id,
+		...metadata.parentSessionId === void 0 ? {} : { parentSession: metadata.parentSessionId }
+	}, toPiFileEntries(header, entries));
+	if (typeof manager._persist !== "function") throw new Error("Pi's SessionManager no longer exposes '_persist'; the headless session bridge must be updated");
+	const append = manager._appendEntry;
+	if (typeof append !== "function") throw new Error("Pi's SessionManager no longer exposes '_appendEntry'; the live session bridge must be updated");
+	let syncingHarnessEntry = false;
+	const pendingMirrors = [];
+	const harnessToPiId = /* @__PURE__ */ new Map();
+	const piToHarnessId = /* @__PURE__ */ new Map();
+	const persist = manager._persist.bind(manager);
+	manager._persist = (entry) => {
+		persist(entry);
+		if (syncingHarnessEntry) return;
+		const mirrored = fromPiSessionEntry(entry);
+		if (mirrored === void 0) return;
+		const pending = {
+			entry,
+			mirrored
+		};
+		pendingMirrors.push(pending);
+		runtime.appendCustomEntry(mirrored.customType, mirrored.data).catch((error) => {
+			const index = pendingMirrors.indexOf(pending);
+			if (index !== -1) pendingMirrors.splice(index, 1);
+			onNotice?.(`Pi session write for '${mirrored.customType}' was not mirrored: ${error instanceof Error ? error.message : String(error)}`);
+		});
+	};
+	const resolvePiId = (entryId) => {
+		if (entryId === null) return null;
+		return harnessToPiId.get(entryId) ?? entryId;
+	};
+	bridgedSessionSync.set(manager, {
+		append(entry) {
+			if (manager.getEntry(resolvePiId(entry.id) ?? entry.id) !== void 0) return;
+			if (entry.type === "custom") {
+				const pendingIndex = pendingMirrors.findIndex((pending) => pending.mirrored.customType === entry.customType && isDeepStrictEqual(pending.mirrored.data, entry.data));
+				if (pendingIndex !== -1) {
+					const pending = pendingMirrors.splice(pendingIndex, 1)[0];
+					if (pending !== void 0) {
+						harnessToPiId.set(entry.id, pending.entry.id);
+						piToHarnessId.set(pending.entry.id, entry.id);
+					}
+					return;
+				}
+			}
+			const converted = entry.type === "compaction" ? toPiSessionEntry(entry, boundaryEntryId(manager.getBranch(), entry.retainedTail.length)) : toPiSessionEntry(entry);
+			if (converted === void 0) return;
+			const parentId = resolvePiId(converted.parentId);
+			syncingHarnessEntry = true;
+			try {
+				append.call(manager, parentId === converted.parentId ? converted : {
+					...converted,
+					parentId
+				});
+			} finally {
+				syncingHarnessEntry = false;
+			}
+		},
+		toHarnessId: (entryId) => piToHarnessId.get(entryId) ?? entryId,
+		toPiId: resolvePiId
+	});
+	return manager;
+}
+function createPiExtensionHost(options) {
+	const { cwd, agentDir, models, runtime, preload } = options;
+	let runner;
+	let sessionManager;
+	let sessionSync;
+	let tools = [];
+	let skills = [];
+	let registered = [];
+	let activeNames = /* @__PURE__ */ new Set();
+	let unsubscribeEvents;
+	let unsubscribeLifecycle;
+	let cordisConnection;
+	let contextTokens = null;
+	let currentOperation = null;
+	let nativeQueuedMessages = 0;
+	let retainedQueuedMessages = 0;
+	let pendingRead = 0;
+	let logicalLoopActive = false;
+	let turnIndex = 0;
+	let runMessages = [];
+	const turnEntryIds = /* @__PURE__ */ new Set();
+	const toolArguments = /* @__PURE__ */ new Map();
+	/** Whether the compaction now running came from a Pi extension rather than the harness. */
+	let compactionFromExtension = false;
+	/**
+	* Set once shutdown begins. The session disposes its runtime before extensions see
+	* session_shutdown, so tool changes made from that handler have no runtime to reach.
+	*/
+	let shuttingDown = false;
+	const report = (source, error) => options.onNotice?.(`Pi extension ${source}: ${error instanceof Error ? error.message : String(error)}`);
+	const activeTools = () => tools.filter((tool) => activeNames.has(tool.name));
+	const requireRunner = () => {
+		if (runner === void 0) throw new Error("The Pi extension host is not loaded");
+		return runner;
+	};
+	/**
+	* Where one custom message goes, following Pi's own order in `sendCustomMessage`.
+	*
+	* `nextTurn` is staged before considering triggerTurn, even when it is false.
+	* Otherwise a running turn takes the message unless the caller opted out; an
+	* idle agent is woken only when the caller asked for a turn.
+	* Pi's remaining branch, deferring an append made mid-turn, needs no counterpart:
+	* the lane already holds a write until the operation reaches a safe commit point.
+	*/
+	const deliverMessage = (message, sendOptions) => {
+		if (sendOptions?.deliverAs === "nextTurn") return runtime.submitInternalMessage(message, "nextTurn");
+		if (sendOptions?.triggerTurn === false) return runtime.appendMessage(message);
+		if (currentOperation === "run" || sendOptions?.triggerTurn === true) return runtime.submitInternalMessage(message, sendOptions?.deliverAs === "steer" || currentOperation === "run" && sendOptions?.deliverAs === void 0 ? "steer" : "followUp");
+		return runtime.appendMessage(message);
+	};
+	const actions = {
+		sendMessage: (message, sendOptions) => {
+			const custom = {
+				role: "custom",
+				customType: message.customType,
+				content: message.content ?? [],
+				display: message.display,
+				...message.details === void 0 ? {} : { details: message.details },
+				timestamp: Date.now()
+			};
+			deliverMessage(custom, sendOptions).catch((error) => report("send_message", error));
+		},
+		sendUserMessage: (content, sendOptions) => {
+			const deliver = async () => {
+				if (currentOperation === "run" && sendOptions?.deliverAs === void 0) throw new Error("sendUserMessage during streaming requires deliverAs: steer or followUp");
+				const text = typeof content === "string" ? content : content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+				if (sendOptions?.expandPromptTemplates && await runtime.dispatchCommand(text)) return;
+				const message = {
+					role: "user",
+					content,
+					timestamp: Date.now()
+				};
+				(await runtime.submitInternalMessage(message, sendOptions?.deliverAs === "steer" ? "steer" : "followUp")).settled.catch((error) => report("send_user_message", error));
+			};
+			deliver().catch((error) => report("send_user_message", error));
+		},
+		appendEntry: (customType, data) => {
+			runtime.appendCustomEntry(customType, data).catch((error) => report("append_entry", error));
+		},
+		setSessionName: (name) => {
+			runtime.setName(name).catch((error) => report("set_session_name", error));
+		},
+		getSessionName: () => void 0,
+		getSettings: () => options.settings.getSettings(),
+		setLabel: (entryId, label) => {
+			runtime.setLabel(sessionSync?.toHarnessId(entryId) ?? entryId, label).catch((error) => report("set_label", error));
+		},
+		getActiveTools: () => activeTools().map((tool) => tool.name),
+		getAllTools: () => registered.map((tool) => ({
+			name: tool.definition.name,
+			description: tool.definition.description,
+			parameters: tool.definition.parameters,
+			exposure: tool.definition.exposure ?? "direct",
+			...tool.definition.promptGuidelines === void 0 ? {} : { promptGuidelines: tool.definition.promptGuidelines },
+			sourceInfo: tool.sourceInfo
+		})),
+		setActiveTools: (names) => {
+			const known = new Set(registered.map((tool) => tool.definition.name));
+			activeNames = new Set(names.filter((name) => known.has(name)));
+			if (!shuttingDown) options.onActiveToolsChanged?.();
+		},
+		refreshTools: () => {
+			if (!shuttingDown) options.onActiveToolsChanged?.();
+		},
+		getCommands: () => [],
+		setModel: async (model) => {
+			await runtime.setModel({
+				provider: model.provider,
+				id: model.id
+			});
+			return true;
+		},
+		getThinkingLevel: () => options.getThinkingLevel(),
+		setThinkingLevel: (level) => {
+			runtime.setThinkingLevel(level).catch((error) => report("set_thinking_level", error));
+		}
+	};
+	const contextActions = {
+		getModel: () => options.getModel(),
+		getScopedModels: () => [],
+		isIdle: () => currentOperation !== "run" && currentOperation !== "compaction",
+		isProjectTrusted: () => true,
+		getSignal: () => void 0,
+		abort: () => {
+			runtime.abort().catch((error) => report("abort", error));
+		},
+		hasPendingMessages: () => nativeQueuedMessages > 0 || retainedQueuedMessages > 0,
+		shutdown: () => {
+			runtime.stop();
+		},
+		getContextUsage: () => contextUsageOf(contextTokens, options.getModel()?.contextWindow),
+		compact: () => {
+			runtime.compact().catch((error) => report("compact", error));
+		},
+		getSystemPrompt: () => ""
+	};
+	const piCompactionEntry = async (entryId) => {
+		const { entries } = await runtime.readEntries();
+		const converted = toPiSessionEntries(entries).find((entry) => entry.id === entryId);
+		return converted?.type === "compaction" ? converted : void 0;
+	};
+	const turnBoundaryContext = () => {
+		const projection = sessionManager?.buildSessionProjection();
+		const contextEntries = projection?.entries ?? [];
+		const contextMessages = projection?.messages ?? [];
+		return {
+			contextEntries,
+			contextMessages,
+			llmMessages: contextMessages.filter((message) => message.role !== "bashExecution"),
+			pendingMessages: [],
+			canContinue: contextMessages.at(-1)?.role !== "assistant"
+		};
+	};
+	/** Harness events, translated into Pi events in AgentSession order. */
+	const handleHarnessEvent = async (event) => {
+		switch (event.type) {
+			case "run_start":
+				currentOperation = "run";
+				if (logicalLoopActive) return;
+				logicalLoopActive = true;
+				turnIndex = 0;
+				runMessages = [];
+				turnEntryIds.clear();
+				toolArguments.clear();
+				await runner?.emit({ type: "agent_start" });
+				return;
+			case "run_resume":
+				currentOperation = "run";
+				return;
+			case "turn_start":
+				turnEntryIds.clear();
+				await runner?.emit({
+					type: "turn_start",
+					turnIndex,
+					timestamp: Date.now()
+				});
+				return;
+			case "message_start":
+				await runner?.emit({
+					type: "message_start",
+					message: event.message
+				});
+				return;
+			case "message_update":
+				await runner?.emit({
+					type: "message_update",
+					message: event.message,
+					assistantMessageEvent: event.event
+				});
+				return;
+			case "message_end":
+				if (event.runId !== void 0) runMessages.push(event.message);
+				if (event.message.role === "assistant") contextTokens = contextTokensOf(event.message.usage);
+				await runner?.emitMessageEnd({
+					type: "message_end",
+					message: event.message
+				});
+				return;
+			case "tool_start":
+				toolArguments.set(event.toolCallId, event.args);
+				await runner?.emit({
+					type: "tool_execution_start",
+					toolCallId: event.toolCallId,
+					toolName: event.toolName,
+					args: event.args
+				});
+				return;
+			case "tool_update":
+				await runner?.emit({
+					type: "tool_execution_update",
+					toolCallId: event.toolCallId,
+					toolName: event.toolName,
+					args: toolArguments.get(event.toolCallId),
+					partialResult: event.partialResult
+				});
+				return;
+			case "tool_end":
+				toolArguments.delete(event.toolCallId);
+				await runner?.emit({
+					type: "tool_execution_end",
+					toolCallId: event.toolCallId,
+					toolName: event.toolName,
+					result: event.result,
+					isError: event.isError
+				});
+				return;
+			case "entry_added":
+				sessionSync?.append(event.entry);
+				if (event.entry.type === "message") turnEntryIds.add(event.entry.id);
+				return;
+			case "queue_update":
+				nativeQueuedMessages = event.queues.filter((item) => item.kind !== "write").length;
+				return;
+			case "turn_end": {
+				const entries = (sessionManager?.getBranch() ?? []).filter((entry) => turnEntryIds.has(sessionSync?.toHarnessId(entry.id) ?? entry.id));
+				turnEntryIds.clear();
+				const messageEntryId = entries.findLast((entry) => entry?.type === "message" && entry.message.role === "assistant")?.id;
+				const toolResultEntryIds = event.toolResults.map((result) => entries.findLast((entry) => entry?.type === "message" && entry.message.role === "toolResult" && entry.message.toolCallId === result.toolCallId)?.id);
+				if (messageEntryId === void 0 || toolResultEntryIds.some((id) => id === void 0)) {
+					report("turn_end", /* @__PURE__ */ new Error("The persisted current-turn entries were not available for the Pi boundary"));
+					turnIndex += 1;
+					return;
+				}
+				await runner?.emitBoundary({
+					type: "turn_end",
+					turnIndex,
+					message: event.message,
+					toolResults: event.toolResults,
+					messageEntryId,
+					toolResultEntryIds,
+					outcome: event.message.stopReason === "aborted" ? "aborted" : event.message.stopReason === "error" ? "error" : "completed"
+				}, turnBoundaryContext);
+				turnIndex += 1;
+				return;
+			}
+			case "run_end": {
+				if (event.successorActive) return;
+				++pendingRead;
+				const state = await runtime.readState();
+				++pendingRead;
+				if (!shuttingDown) retainedQueuedMessages = Number(state.pendingMessageCount) || 0;
+				currentOperation = null;
+				if (logicalLoopActive) {
+					logicalLoopActive = false;
+					await runner?.emit({
+						type: "agent_end",
+						messages: runMessages
+					});
+					await runner?.emit({ type: "agent_settled" });
+				}
+				runMessages = [];
+				turnEntryIds.clear();
+				toolArguments.clear();
+				return;
+			}
+			case "compaction_start":
+				currentOperation = "compaction";
+				return;
+			case "compaction_end": {
+				currentOperation = null;
+				const fromExtension = compactionFromExtension;
+				compactionFromExtension = false;
+				if (event.status !== "completed") {
+					await runner?.emit({
+						type: "session_compact_failed",
+						reason: event.reason,
+						...event.status === "failed" ? { errorMessage: event.error?.message } : {},
+						aborted: event.status === "aborted",
+						willRetry: event.reason === "overflow",
+						fromExtension
+					});
+					return;
+				}
+				contextTokens = null;
+				const compactionEntry = event.entryId === void 0 ? void 0 : await piCompactionEntry(event.entryId);
+				if (compactionEntry === void 0) return;
+				await runner?.emit({
+					type: "session_compact",
+					compactionEntry,
+					fromExtension,
+					reason: event.reason,
+					willRetry: event.reason === "overflow"
+				});
+				return;
+			}
+			case "navigation_start":
+				turnEntryIds.clear();
+				currentOperation = "navigation";
+				return;
+			case "navigation_end": {
+				currentOperation = null;
+				if (event.status !== "completed") return;
+				const newLeafId = sessionSync?.toPiId(event.tipId) ?? event.tipId;
+				const oldLeafId = sessionSync?.toPiId(event.fromTipId) ?? event.fromTipId;
+				if (newLeafId === null) sessionManager?.resetLeaf();
+				else if (sessionManager?.getEntry(newLeafId) !== void 0) sessionManager.branch(newLeafId);
+				const leaf = newLeafId === null ? void 0 : sessionManager?.getEntry(newLeafId);
+				await runner?.emit({
+					type: "session_tree",
+					newLeafId,
+					oldLeafId,
+					...leaf?.type === "branch_summary" ? { summaryEntry: leaf } : {}
+				});
+				return;
+			}
+			case "value_update":
+				if (event.value === "session_name") await runner?.emit({
+					type: "session_info_changed",
+					name: event.name
+				});
+				return;
+			case "config_update":
+				if (event.property === "model") {
+					const model = models.getModel(event.value.provider, event.value.modelId);
+					const previous = event.previous;
+					const previousModel = typeof previous?.provider === "string" && typeof previous.modelId === "string" ? models.getModel(previous.provider, previous.modelId) : void 0;
+					if (model !== void 0) await runner?.emit({
+						type: "model_select",
+						model,
+						previousModel,
+						source: "set"
+					});
+				} else if (event.property === "thinkingLevel") await runner?.emit({
+					type: "thinking_level_select",
+					level: event.value,
+					previousLevel: event.previous
+				});
+				return;
+			default: return;
+		}
+	};
+	const onHarnessEvent = (event) => handleHarnessEvent(event).catch((error) => report(`event '${event.type}'`, error));
+	const transformContext = async (messages) => {
+		if (runner === void 0) return messages;
+		const { entries, leafId } = await runtime.readEntries();
+		for (const entry of entries) sessionSync?.append(entry);
+		const leaf = sessionSync?.toPiId(leafId) ?? leafId;
+		if (sessionManager && leaf !== null && sessionManager.getEntry(leaf) !== void 0) sessionManager.branch(leaf);
+		return runner.emitContext(messages);
+	};
+	const beforeCompaction = async (event) => {
+		if (runner === void 0) return void 0;
+		const branchEntries = piBranchEntries((await runtime.readEntries()).entries);
+		const result = await runner.emit({
+			type: "session_before_compact",
+			preparation: toPiCompactionPreparation(event.preparation, branchEntries),
+			branchEntries,
+			...event.customInstructions === void 0 ? {} : { customInstructions: event.customInstructions },
+			reason: event.reason,
+			willRetry: event.reason === "overflow",
+			signal: new AbortController().signal
+		});
+		if (result?.cancel === true) return { decline: true };
+		if (result?.compaction === void 0) return void 0;
+		compactionFromExtension = true;
+		return { compaction: toHarnessCompactResult(result.compaction, branchEntries) };
+	};
+	return {
+		transformContext,
+		beforeCompaction,
+		get tools() {
+			return activeTools();
+		},
+		get toolGuidance() {
+			return registered.filter((tool) => activeNames.has(tool.definition.name)).map((tool) => ({
+				name: tool.definition.name,
+				...tool.definition.promptSnippet === void 0 ? {} : { promptSnippet: tool.definition.promptSnippet },
+				...tool.definition.promptGuidelines === void 0 ? {} : { promptGuidelines: tool.definition.promptGuidelines }
+			}));
+		},
+		get skills() {
+			return skills;
+		},
+		getService(name) {
+			return cordisConnection?.root.get(name);
+		},
+		executeTool(name, toolCallId, parameters, signal, onUpdate) {
+			const tool = registered.find((entry) => entry.definition.name === name);
+			if (tool === void 0) throw new Error(`Unknown Pi extension tool '${name}'`);
+			return executePiTool(tool, requireRunner, (candidate) => activeNames.has(candidate), toolCallId, parameters, signal, onUpdate);
+		},
+		async load() {
+			if (runner !== void 0) throw new Error("The Pi extension host was loaded more than once");
+			if (preload === void 0) return;
+			const { entries } = await runtime.readEntries();
+			contextTokens = contextTokensOf(latestAssistantUsage(entries));
+			const loaded = [...preload.extensions];
+			sessionManager = await createBridgedSessionManager(runtime, cwd, options.onNotice, entries);
+			const manager = sessionManager;
+			sessionSync = bridgedSessionSync.get(manager);
+			if (sessionSync === void 0) throw new Error("The live Pi session bridge was not initialized");
+			runner = new ExtensionRunner(loaded, preload.runtime, cwd, manager, new ModelRegistry(models));
+			runner.setUIContext(createHeadlessUiContext(options.client, resolveDefaultTheme(runner)), "rpc");
+			runner.bindCore(actions, contextActions);
+			registered = loaded.flatMap((extension) => [...extension.tools.values()]);
+			tools = registered.map((tool) => toHarnessTool(tool, requireRunner, (name) => activeNames.has(name)));
+			activeNames = new Set(tools.map((tool) => tool.name));
+			unsubscribeEvents = runtime.onEvent(onHarnessEvent);
+			currentOperation = (await runtime.readLifecycle()).operation?.kind ?? null;
+			retainedQueuedMessages = Number((await runtime.readState()).pendingMessageCount) || 0;
+			unsubscribeLifecycle = runtime.onPresentationFrame((frame) => {
+				if (frame.type !== "lifecycle_update" || !frame.lifecycle || typeof frame.lifecycle !== "object") return;
+				const lifecycle = frame.lifecycle;
+				const read = ++pendingRead;
+				runtime.readState().then((state) => {
+					if (!shuttingDown && read === pendingRead) retainedQueuedMessages = Number(state.pendingMessageCount) || 0;
+				}).catch((error) => report("pending_messages", error));
+				currentOperation = lifecycle.operation?.kind ?? null;
+			});
+			if (preload.events !== void 0) {
+				cordisConnection = await connectDoomCordisHost({ events: preload.events }, "headless-pi-extension-host", { optional: true });
+				if (cordisConnection !== void 0 && options.serverServices !== void 0) {
+					if (options.serverServices.sessionId !== runtime.sessionId) throw new Error("Server services belong to a different session");
+					cordisConnection.root.provide(DOOM_CORDIS_SERVER_SERVICES, options.serverServices);
+				}
+			}
+			await runner.emit({
+				type: "session_start",
+				reason: "startup"
+			});
+			skills = await loadPiSkills(runner, cwd, agentDir, options.onNotice);
+		},
+		async shutdown() {
+			shuttingDown = true;
+			pendingRead++;
+			unsubscribeEvents?.();
+			unsubscribeEvents = void 0;
+			unsubscribeLifecycle?.();
+			unsubscribeLifecycle = void 0;
+			sessionSync = void 0;
+			sessionManager = void 0;
+			runMessages = [];
+			turnEntryIds.clear();
+			toolArguments.clear();
+			const connection = cordisConnection;
+			cordisConnection = void 0;
+			try {
+				if (runner !== void 0) await runner.emit({
+					type: "session_shutdown",
+					reason: "quit"
+				});
+			} finally {
+				await connection?.dispose();
+			}
+		}
+	};
+}
+//#endregion
+export { createBridgedSessionManager, createPiExtensionHost, formatSkillsForSystemPrompt, preloadPiExtensions, resolvePiSettingsPackageEntries };
+
+//# sourceMappingURL=index.mjs.map