@agimon-ai/doompi-core 0.0.1-alpha.70

package/dist/systems/main/adapters/headlessSessionHost.mjs

@@ -0,0 +1,649 @@
+import { DOOM_CHILD_SESSION_SERVICE } from "../../child/types/childSession.mjs";
+import { createDirectHarnessRuntime } from "../../../server/directHarnessRuntime.mjs";
+import { createHistoryOwnership } from "../../../history-ownership.mjs";
+import { createHeadlessChildSessionServiceProvider } from "../../child/adapters/headlessChildSessionService.mjs";
+import { buildContextDetail } from "../../../context-detail.mjs";
+import { writeContextDetail } from "../../../context-detail-store.mjs";
+import { DOOM_CONTEXT_ENTRY_TYPE, projectContext } from "../../../context-projection.mjs";
+import { createHeadlessClient } from "../../../services/headlessClient/index.mjs";
+import { HeadlessHost, headlessHarnessSkill } from "./headlessHost.mjs";
+import path from "node:path";
+import { value } from "@earendil-works/pi-agent-core/harness/session";
+import { BACKGROUND_CONTEXT } from "@earendil-works/pi-agent-core/harness/context";
+import { ModelRuntime, SettingsManager, getAgentDir, parseArgs, resolveCliModel, resolveModelScopeWithDiagnostics } from "@earendil-works/pi-coding-agent";
+//#region src/systems/main/adapters/headlessSessionHost.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : void 0;
+}
+/** Restores the last accepted live selection from journal projections, falling back on launch configuration. */
+function restoreHeadlessSelection(entries, fallback) {
+	let projected;
+	for (let index = entries.length - 1; index >= 0 && projected === void 0; index -= 1) {
+		const entry = entries[index];
+		if (!isRecord(entry) || entry.type !== "custom" || !isRecord(entry.data)) continue;
+		if (projected === void 0 && entry.customType === "doom-context") {
+			const selection = entry.data.selection;
+			if (!isRecord(selection) || typeof selection.majorMode !== "string") continue;
+			const domains = stringArray(selection.domains);
+			if (domains === void 0 || selection.profile !== void 0 && typeof selection.profile !== "string") continue;
+			projected = {
+				majorMode: selection.majorMode,
+				domains,
+				...typeof selection.profile === "string" ? { profile: selection.profile } : {}
+			};
+		}
+	}
+	return {
+		...fallback,
+		...projected
+	};
+}
+function isJsonValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return value.every(isJsonValue);
+	return isRecord(value) && Object.values(value).every(isJsonValue);
+}
+function isJsonObject(value) {
+	return isRecord(value) && Object.values(value).every(isJsonValue);
+}
+function isToolContent(value) {
+	return Array.isArray(value) && value.every((part) => {
+		if (!isRecord(part)) return false;
+		if (part.type === "text") return typeof part.text === "string";
+		return part.type === "image" && typeof part.data === "string" && typeof part.mimeType === "string";
+	});
+}
+function isUsage(value) {
+	if (!isRecord(value) || !isRecord(value.cost)) return false;
+	const cost = value.cost;
+	return [
+		"input",
+		"output",
+		"cacheRead",
+		"cacheWrite",
+		"totalTokens"
+	].every((key) => typeof value[key] === "number" && Number.isFinite(value[key])) && [
+		"input",
+		"output",
+		"cacheRead",
+		"cacheWrite",
+		"total"
+	].every((key) => typeof cost[key] === "number" && Number.isFinite(cost[key]));
+}
+function isAgentMessage(value) {
+	if (!isRecord(value) || typeof value.timestamp !== "number" || !Number.isFinite(value.timestamp)) return false;
+	if (value.role === "user") return typeof value.content === "string" || Array.isArray(value.content);
+	if (!Array.isArray(value.content)) return false;
+	if (value.role === "assistant") return typeof value.api === "string" && typeof value.provider === "string" && typeof value.model === "string" && typeof value.stopReason === "string" && isUsage(value.usage);
+	return value.role === "toolResult" && typeof value.toolCallId === "string" && typeof value.toolName === "string" && typeof value.isError === "boolean";
+}
+function isCompactResult(value) {
+	return isRecord(value) && typeof value.summary === "string" && typeof value.tokensBefore === "number" && Number.isFinite(value.tokensBefore) && Array.isArray(value.retainedTail) && value.retainedTail.every(isAgentMessage) && (value.usage === void 0 || isUsage(value.usage)) && (value.details === void 0 || isJsonValue(value.details));
+}
+const unsupported = (parsed) => {
+	const match = [
+		["--help", parsed.help],
+		["--version", parsed.version],
+		["--mode", parsed.mode],
+		["--print", parsed.print],
+		["--export", parsed.export],
+		["--no-session", parsed.noSession],
+		["--continue", parsed.continue],
+		["--resume", parsed.resume],
+		["--fork", parsed.fork],
+		["--list-models", parsed.listModels],
+		["--offline", parsed.offline],
+		["--tui-mode", parsed.tuiMode],
+		["--extensions", parsed.extensions],
+		["--no-extensions", parsed.noExtensions],
+		["--skills", parsed.skills],
+		["--no-skills", parsed.noSkills],
+		["--prompt-templates", parsed.promptTemplates],
+		["--no-prompt-templates", parsed.noPromptTemplates],
+		["--themes", parsed.themes],
+		["--no-themes", parsed.noThemes],
+		["--no-context-files", parsed.noContextFiles],
+		["--tools", parsed.tools],
+		["--exclude-tools", parsed.excludeTools],
+		["--no-tools", parsed.noTools],
+		["--no-builtin-tools", parsed.noBuiltinTools],
+		["--project-trust-override", parsed.projectTrustOverride],
+		["--verbose", parsed.verbose]
+	].find(([, value]) => value !== void 0 && value !== false);
+	if (match) return `Direct headless mode does not support ${match[0]}.`;
+	if (parsed.messages.length > 0 || parsed.fileArgs.length > 0) return "Direct headless mode does not support positional prompts or files.";
+	const unknown = parsed.unknownFlags.keys().next().value;
+	return typeof unknown === "string" ? `Direct headless mode does not support --${unknown}.` : void 0;
+};
+/** Validate the Pi flags that remain after Doom's harness flags are removed. */
+function validateDirectHeadlessArgs(agentArgs) {
+	const parsed = parseArgs([...agentArgs]);
+	const diagnostics = parsed.diagnostics.filter((diagnostic) => diagnostic.type === "error");
+	if (diagnostics.length) throw new Error(diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+	if (agentArgs.includes("--mode")) throw new Error("Direct headless mode does not support --mode.");
+	const error = unsupported(parsed);
+	if (error) throw new Error(error);
+	return parsed;
+}
+function modelIdentity(model) {
+	return {
+		provider: model.provider,
+		id: model.id
+	};
+}
+async function resolveModel(parsed, modelRuntime, settings) {
+	const cli = resolveCliModel({
+		cliProvider: parsed.provider,
+		cliModel: parsed.model,
+		cliThinking: parsed.thinking,
+		modelRuntime
+	});
+	if (cli.error) throw new Error(cli.error);
+	let scoped;
+	if (parsed.models !== void 0 && parsed.models.length > 0) {
+		scoped = (await resolveModelScopeWithDiagnostics(parsed.models, modelRuntime)).scopedModels[0]?.model;
+		if (scoped === void 0) throw new Error(`No configured model matched --models ${parsed.models.join(", ")}.`);
+	}
+	const configured = cli.model ?? scoped ?? (settings.getDefaultProvider() && settings.getDefaultModel() ? modelRuntime.getModel(settings.getDefaultProvider(), settings.getDefaultModel()) : void 0) ?? (await modelRuntime.getAvailable())[0];
+	if (configured === void 0) throw new Error("Direct headless mode could not resolve a configured model.");
+	return {
+		model: configured,
+		thinkingLevel: cli.thinkingLevel ?? parsed.thinking ?? settings.getModelThinkingLevel(configured.provider, configured.id) ?? settings.getDefaultThinkingLevel()
+	};
+}
+function mapResources(resources) {
+	const skills = [];
+	const promptTemplates = [];
+	const context = [];
+	for (const resource of resources) if (resource.kind === "skill") skills.push(headlessHarnessSkill(resource));
+	else if (resource.kind === "prompt") promptTemplates.push({
+		name: resource.name,
+		content: resource.text
+	});
+	else context.push(resource.text);
+	return {
+		harness: {
+			skills,
+			promptTemplates
+		},
+		context
+	};
+}
+function toolAdapter(tool, executionContext, reportedErrors) {
+	return {
+		name: tool.name,
+		label: tool.label ?? tool.name,
+		description: tool.description,
+		parameters: tool.parameters,
+		...tool.promptSnippet === void 0 ? {} : { promptSnippet: tool.promptSnippet },
+		...tool.promptGuidelines === void 0 ? {} : { promptGuidelines: tool.promptGuidelines },
+		...tool.executionMode === void 0 ? {} : { executionMode: tool.executionMode === "parallel" ? "parallel" : "sequential" },
+		async execute(toolCallId, parameters, onUpdate, _toolContext, _invocation, context) {
+			const result = await tool.execute(toolCallId, parameters, context.abortSignal, (partial) => onUpdate({
+				content: partial.content,
+				details: partial.details
+			}), executionContext());
+			if (result.isError === true) reportedErrors.add(toolCallId);
+			return {
+				content: result.content,
+				details: result.details
+			};
+		}
+	};
+}
+function eventHook(event) {
+	return {
+		run_start: "agent_start",
+		run_resume: "agent_start",
+		run_end: "agent_settled",
+		turn_start: "turn_start",
+		turn_end: "turn_end",
+		message_start: "message_start",
+		message_update: "message_update",
+		message_end: "message_end",
+		tool_start: "tool_execution_start",
+		tool_update: "tool_execution_update",
+		tool_end: "tool_execution_end",
+		compaction_end: "session_compact",
+		navigation_end: "session_tree"
+	}[event];
+}
+function emitTo(listeners, frame) {
+	const snapshot = [...listeners];
+	for (const listener of snapshot) try {
+		listener(frame);
+	} catch {}
+}
+function createHeadlessCompositionPublisher(runtime, host, environment, groups) {
+	let countTokens;
+	let contextRevision = 0;
+	let publishedContext;
+	return async (selection = host.context.selection) => {
+		countTokens ??= (await import("gpt-tokenizer")).countTokens;
+		const inventory = host.getContextInventory(selection, countTokens);
+		const context = projectContext({
+			revision: contextRevision + 1,
+			majorMode: selection.majorMode,
+			...selection.profile === void 0 ? {} : { profile: selection.profile },
+			groups: groups(selection),
+			domains: selection.domains,
+			sources: inventory.sources,
+			skills: inventory.skills,
+			attribution: inventory.attribution,
+			countTokens
+		});
+		const contextKey = JSON.stringify({
+			...context,
+			revision: 0
+		});
+		if (contextKey !== publishedContext) {
+			const revision = contextRevision + 1;
+			const details = buildContextDetail({
+				sources: inventory.sources,
+				skills: inventory.skills,
+				countTokens
+			});
+			await runtime.appendCustomEntry(DOOM_CONTEXT_ENTRY_TYPE, {
+				...context,
+				revision
+			});
+			writeContextDetail(runtime.sessionId, revision, details, environment);
+			contextRevision = revision;
+			publishedContext = contextKey;
+		}
+	};
+}
+/** Create the gated, same-process host used by direct-headless startup tests. */
+async function createHeadlessSessionHost(options) {
+	const parsed = validateDirectHeadlessArgs(options.agentArgs);
+	const agentDir = getAgentDir();
+	const settings = SettingsManager.create(options.cwd, agentDir);
+	const modelRuntime = await ModelRuntime.create({
+		authPath: path.join(agentDir, "auth.json"),
+		modelsPath: path.join(agentDir, "models.json"),
+		refreshOnCreate: false
+	});
+	const resolved = await resolveModel(parsed, modelRuntime, settings);
+	if (parsed.apiKey !== void 0) await modelRuntime.setRuntimeApiKey(resolved.model.provider, parsed.apiKey);
+	const reportedToolErrors = /* @__PURE__ */ new Set();
+	let promptPreparationFailed = false;
+	let headlessReady = false;
+	const initialSystemPrompt = [parsed.systemPrompt, ...parsed.appendSystemPrompt ?? []].filter(Boolean).join("\n\n");
+	const runtime = await createDirectHarnessRuntime({
+		cwd: options.cwd,
+		sessionId: options.sessionId,
+		...options.parentSessionId === void 0 ? {} : { parentSessionId: options.parentSessionId },
+		storage: "sqlite",
+		historyOwnership: createHistoryOwnership({ sourceFormat: "sqlite" }),
+		sessionName: parsed.name ?? options.sessionName,
+		...parsed.session === void 0 ? {} : { sessionPath: parsed.session },
+		sessionsRoot: parsed.sessionDir ?? path.join(agentDir, "server", "sessions"),
+		models: modelRuntime,
+		model: resolved.model,
+		...resolved.thinkingLevel === void 0 ? {} : { thinkingLevel: resolved.thinkingLevel },
+		beforeModelRequest: async ({ phase }) => {
+			if (!headlessReady || !headlessHost) throw new Error("Headless capabilities are not installed.");
+			if (phase === "turn") await headlessHost.inheritSelection(await options.inheritedSelection?.() ?? {});
+		},
+		transformContext: async (event) => {
+			if (!headlessReady || !headlessHost) throw new Error("Headless capabilities are not installed.");
+			const patches = await headlessHost.dispatchHook("context", event);
+			let messages = event.messages;
+			let systemPrompt = event.systemPrompt;
+			for (const patch of patches) {
+				if (!isRecord(patch)) continue;
+				if (patch.messages !== void 0) {
+					if (!Array.isArray(patch.messages)) throw new Error("Invalid headless context messages");
+					messages = patch.messages;
+				}
+				if (patch.systemPrompt !== void 0) {
+					if (typeof patch.systemPrompt !== "string") throw new Error("Invalid headless context system prompt");
+					systemPrompt = patch.systemPrompt;
+				}
+			}
+			return {
+				messages,
+				systemPrompt
+			};
+		},
+		beforeTool: async (event) => {
+			if (!headlessReady || !headlessHost) throw new Error("Headless capabilities are not installed.");
+			const patches = await headlessHost.dispatchHook("tool_call", event);
+			let args = event.args;
+			let block;
+			for (const patch of patches) {
+				if (!isRecord(patch)) continue;
+				if (patch.args !== void 0) {
+					if (!isJsonObject(patch.args)) throw new Error("Invalid headless tool arguments");
+					args = patch.args;
+				}
+				if (patch.block === void 0) continue;
+				if (!isRecord(patch.block) || typeof patch.block.reason !== "string" || patch.block.terminate !== void 0 && typeof patch.block.terminate !== "boolean") throw new Error("Invalid headless tool denial");
+				block = {
+					reason: patch.block.reason,
+					...typeof patch.block.terminate === "boolean" ? { terminate: patch.block.terminate } : {}
+				};
+				break;
+			}
+			return {
+				...args === event.args ? {} : { args },
+				...block === void 0 ? {} : { block }
+			};
+		},
+		afterTool: async (event) => {
+			if (!headlessReady || !headlessHost) throw new Error("Headless capabilities are not installed.");
+			const original = reportedToolErrors.delete(event.toolCallId) ? {
+				...event,
+				isError: true
+			} : event;
+			const patches = await headlessHost.dispatchHook("tool_result", original);
+			let content = original.content;
+			let details = original.details;
+			let isError = original.isError;
+			let usage = original.usage;
+			let terminate;
+			for (const patch of patches) {
+				if (!isRecord(patch)) continue;
+				if (isToolContent(patch.content)) content = patch.content;
+				if ("details" in patch && isJsonValue(patch.details)) details = patch.details;
+				if (typeof patch.isError === "boolean") isError = patch.isError;
+				if (isUsage(patch.usage)) usage = patch.usage;
+				if (typeof patch.terminate === "boolean") terminate = patch.terminate;
+			}
+			return {
+				...content === event.content ? {} : { content },
+				...details === event.details ? {} : { details },
+				...isError === event.isError ? {} : { isError },
+				...usage === event.usage ? {} : { usage },
+				...terminate === void 0 ? {} : { terminate }
+			};
+		},
+		beforePayload: async (event) => {
+			if (!headlessReady || !headlessHost) throw new Error("Headless capabilities are not installed.");
+			const patches = await headlessHost.dispatchHook("before_provider_request", event);
+			let payload = event.payload;
+			for (const patch of patches) {
+				if (patch === void 0 || patch === null) continue;
+				if (!isRecord(patch) || !("payload" in patch)) throw new Error("Invalid headless provider payload patch");
+				payload = patch.payload;
+			}
+			return { payload };
+		},
+		beforeCompaction: async (event) => {
+			if (!headlessReady || !headlessHost) throw new Error("Headless capabilities are not installed.");
+			const patches = await headlessHost.dispatchHook("session_before_compact", {
+				reason: event.reason,
+				preparation: event.preparation,
+				...event.customInstructions === void 0 ? {} : {
+					instructions: event.customInstructions,
+					customInstructions: event.customInstructions
+				}
+			});
+			try {
+				for (const patch of patches) {
+					if (patch === void 0 || patch === null) continue;
+					if (!isRecord(patch)) throw new Error("Invalid headless compaction patch");
+					if (patch.cancel !== void 0 && typeof patch.cancel !== "boolean") throw new Error("Invalid headless compaction cancellation");
+					if (patch.decline !== void 0 && typeof patch.decline !== "boolean") throw new Error("Invalid headless compaction decline");
+					const decline = patch.cancel === true || patch.decline === true;
+					if (decline && patch.compaction !== void 0) throw new Error("Conflicting headless compaction patch");
+					if (decline) return { decline: true };
+					if (patch.compaction !== void 0) {
+						if (!isCompactResult(patch.compaction)) throw new Error("Invalid headless compaction result");
+						return { compaction: patch.compaction };
+					}
+				}
+			} catch (error) {
+				options.onNotice?.(`Headless compaction hook rejected: ${error instanceof Error ? error.message : String(error)}`);
+				return { decline: true };
+			}
+		},
+		systemPrompt: async () => {
+			try {
+				if (!headlessHost) throw new Error("Headless capabilities are not installed.");
+				const resources = await headlessHost.readResources();
+				let prompt = [initialSystemPrompt, ...mapResources(resources).context].filter(Boolean).join("\n\n");
+				const patches = await headlessHost.dispatchHook("before_agent_start", { systemPrompt: prompt });
+				for (const patch of patches) if (patch && typeof patch === "object" && "systemPrompt" in patch && typeof patch.systemPrompt === "string") prompt = patch.systemPrompt;
+				promptPreparationFailed = false;
+				return prompt;
+			} catch {
+				promptPreparationFailed = true;
+				return "";
+			}
+		},
+		listCommands: () => {
+			if (!headlessReady || !headlessHost) throw new Error("Headless capabilities are not installed.");
+			return headlessHost.listCommands();
+		},
+		dispatchCommand: async (text) => {
+			const match = /^\/(\S+)(?:\s+([\s\S]*))?$/.exec(text);
+			if (!match) return false;
+			if (!headlessReady || !headlessHost) throw new Error("Headless capabilities are not installed.");
+			const name = match[1];
+			const args = match[2] ?? "";
+			if (!headlessHost.listCommands().some((entry) => entry.name === name)) return false;
+			await headlessHost.dispatchCommand(name, args);
+			return true;
+		},
+		guardModelRequest: () => {
+			if (!headlessReady || promptPreparationFailed || !headlessHost?.status.ready) throw new Error("Headless capability preparation is not ready.");
+		}
+	});
+	await runtime.session.setValue(value("doompi.session", "workspaceRoot"), options.repoRoot, BACKGROUND_CONTEXT);
+	let currentModel = await runtime.lane.getModel(BACKGROUND_CONTEXT);
+	const entries = (await Promise.all([DOOM_CONTEXT_ENTRY_TYPE].map((customType) => runtime.lane.findEntries({
+		type: "custom",
+		customType,
+		order: "newestFirst",
+		limit: 1
+	}, BACKGROUND_CONTEXT)))).flat();
+	const listeners = /* @__PURE__ */ new Set();
+	const initialSelection = restoreHeadlessSelection(entries, options.selection);
+	let headlessHost;
+	let client;
+	let disposed = false;
+	let disposePromise;
+	let publishComposition = async () => {
+		throw new Error("Direct headless composition publisher is not installed.");
+	};
+	const childSessionProvider = createHeadlessChildSessionServiceProvider({
+		parentSessionId: runtime.sessionId,
+		cwd: options.cwd,
+		sessionsRoot: parsed.sessionDir ?? path.join(agentDir, "server", "sessions"),
+		models: modelRuntime,
+		defaultModel: () => currentModel
+	});
+	const executionContext = (selection) => ({
+		cwd: options.cwd,
+		repoRoot: options.repoRoot,
+		sessionId: runtime.sessionId,
+		environment: options.environment,
+		client: client.client,
+		model: currentModel === void 0 ? void 0 : modelIdentity(currentModel),
+		selection,
+		textCompletion: {
+			available(reference) {
+				const separator = reference.indexOf("/");
+				return separator > 0 && !!modelRuntime.getModel(reference.slice(0, separator), reference.slice(separator + 1)) && modelRuntime.hasConfiguredAuth(reference.slice(0, separator));
+			},
+			async complete(reference, request) {
+				if (disposed || !headlessReady || promptPreparationFailed || !headlessHost?.status.ready) throw new Error("Headless capability preparation is not ready.");
+				const separator = reference.indexOf("/");
+				const model = separator > 0 ? modelRuntime.getModel(reference.slice(0, separator), reference.slice(separator + 1)) : void 0;
+				if (!model || !modelRuntime.hasConfiguredAuth(model.provider)) throw new Error(`Model is not configured: ${reference}`);
+				if (!runtime.completeModel) throw new Error("The runtime does not support auxiliary model requests.");
+				const response = await runtime.completeModel(model, {
+					systemPrompt: request.systemPrompt,
+					messages: [{
+						role: "user",
+						content: request.input,
+						timestamp: Date.now()
+					}]
+				}, {
+					signal: request.signal,
+					maxTokens: request.maxTokens,
+					cacheRetention: request.cacheRetention,
+					reasoningEffort: "none",
+					maxRetries: 0
+				});
+				if (response.stopReason === "error" || response.stopReason === "aborted") throw new Error(response.errorMessage ?? `Model stopped: ${response.stopReason}`);
+				return response.content.filter((part) => part.type === "text").map((part) => part.text).join("").trim();
+			}
+		},
+		session: {
+			async forkSource() {
+				const metadata = runtime.session.metadata;
+				if (typeof metadata.path !== "string") throw new Error("The parent session has no persisted journal.");
+				const { leafId } = await runtime.readEntries();
+				return {
+					kind: "v4-fork",
+					sessionFile: metadata.path,
+					branch: runtime.laneName,
+					...leafId === null ? {} : { entryId: leafId }
+				};
+			},
+			entries: async (query) => await runtime.lane.findEntries({
+				...query,
+				order: query?.limit === void 0 ? "oldestFirst" : "newestFirst"
+			}, BACKGROUND_CONTEXT),
+			async appendCustomEntry(type, data) {
+				await runtime.appendCustomEntry(type, data);
+			},
+			prompt: (text, delivery) => delivery === "steer" ? runtime.steer(text) : delivery === "followUp" ? runtime.followUp(text) : runtime.prompt(text),
+			async admitPrompt(text, delivery) {
+				if (delivery === "steer") return runtime.steer(text);
+				if (delivery === "followUp") return runtime.followUp(text);
+				(await runtime.submitPrompt(text)).settled.catch((error) => client.client.notify({
+					body: error instanceof Error ? error.message : String(error),
+					level: "error"
+				}));
+			},
+			abort: () => runtime.abort(),
+			compact: (instructions) => runtime.compact(instructions),
+			async activity() {
+				const state = await runtime.readState();
+				return {
+					hasPendingMessages: Number(state.pendingMessageCount) > 0,
+					isIdle: !state.isStreaming && !state.isCompacting
+				};
+			}
+		},
+		shutdown: () => stop()
+	});
+	client = createHeadlessClient({
+		appendCustomEntry: async (type, data) => {
+			await runtime.appendCustomEntry(type, data);
+		},
+		emitFrame: (frame) => emitTo(listeners, frame)
+	});
+	const unsubscribePresentation = runtime.onPresentationFrame((frame) => emitTo(listeners, frame));
+	const unsubscribeEvents = runtime.onEvent(async (event, _context) => {
+		if (event.type === "config_update" && event.property === "model") {
+			currentModel = await runtime.lane.getModel(BACKGROUND_CONTEXT);
+			if (headlessHost !== void 0 && currentModel !== void 0 && headlessHost.status.ready) await headlessHost.dispatchHook("model_select", { model: currentModel });
+		}
+		const hook = eventHook(event.type);
+		if (headlessHost !== void 0 && hook !== void 0 && headlessHost.status.ready) await headlessHost.dispatchHook(hook, event);
+	});
+	const prepareFacets = (root) => {
+		root.plugin((context) => {
+			context.provide(DOOM_CHILD_SESSION_SERVICE, childSessionProvider.get());
+			context.effect(() => () => childSessionProvider.close(), "headless child session service lifetime");
+		});
+		if (headlessHost !== void 0) throw new Error("Direct headless facets were prepared more than once.");
+		headlessHost = new HeadlessHost(root, {
+			candidates: options.candidates,
+			selection: initialSelection,
+			selectionOverrides: [.../* @__PURE__ */ new Set([...options.selectionOverrides ?? [], ...[
+				"majorMode",
+				"domains",
+				"profile"
+			].filter((axis) => JSON.stringify(initialSelection[axis]) !== JSON.stringify(options.selection[axis]))])],
+			context: executionContext,
+			resolveSelection: options.resolveSelection,
+			applyTools: async (tools) => runtime.replaceTools(tools.map((tool) => toolAdapter(tool, () => headlessHost.context, reportedToolErrors))),
+			applyResources: async (next) => {
+				const mapped = mapResources(next);
+				await runtime.replaceResources(mapped.harness);
+			},
+			onApplied: async (selection) => {
+				if (headlessReady) await publishComposition(selection);
+				options.publishSelectionStatus?.((source, text) => client.client.setStatus(source, text), selection);
+			},
+			onError: (error) => options.onNotice?.(`Headless selection failed: ${error instanceof Error ? error.message : String(error)}`)
+		});
+		publishComposition = createHeadlessCompositionPublisher(runtime, headlessHost, options.environment, (selection) => options.contextGroups?.(root, selection) ?? []);
+	};
+	const activateFacets = async (installed) => {
+		if (headlessHost === void 0) throw new Error("Direct headless host was not prepared.");
+		headlessHost.setAvailableSources(installed.installedPackages);
+		await headlessHost.select(initialSelection);
+		headlessReady = headlessHost.status.ready;
+		if (headlessReady) {
+			await headlessHost.dispatchHook("session_start", {});
+			await publishComposition();
+		}
+	};
+	const dispose = () => {
+		disposePromise ??= (async () => {
+			if (disposed) return;
+			disposed = true;
+			headlessReady = false;
+			const failures = [];
+			try {
+				if (headlessHost?.status.ready) await headlessHost.dispatchHook("session_shutdown", {});
+			} catch (error) {
+				failures.push(error);
+			}
+			try {
+				await headlessHost?.close();
+			} catch (error) {
+				failures.push(error);
+			}
+			try {
+				await childSessionProvider.close();
+			} catch (error) {
+				failures.push(error);
+			}
+			client?.dispose();
+			unsubscribePresentation();
+			unsubscribeEvents();
+			try {
+				await runtime.dispose();
+			} catch (error) {
+				failures.push(error);
+			}
+			if (failures.length) throw new AggregateError(failures, "Headless session shutdown failed");
+		})();
+		return disposePromise;
+	};
+	const stop = () => {
+		dispose().catch((error) => options.onNotice?.(error instanceof Error ? error.message : String(error)));
+	};
+	return {
+		runtime,
+		get host() {
+			return headlessHost;
+		},
+		prepareFacets,
+		activateFacets,
+		canDispatch: () => !disposed && headlessReady && !promptPreparationFailed && headlessHost?.status.ready === true,
+		onPresentationFrame(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		respondToExtensionUi(frame) {
+			return client?.receive(frame) ?? false;
+		},
+		dispose
+	};
+}
+//#endregion
+export { createHeadlessSessionHost, restoreHeadlessSelection, validateDirectHeadlessArgs };
+
+//# sourceMappingURL=headlessSessionHost.mjs.map