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

package/dist/src/systems/main/adapters/headlessHost.d.mts

@@ -0,0 +1,111 @@
+import { CountTokens } from "../../../services/toolCost/index.mjs";
+import "../../../../toolInventory.mjs";
+import { DoomHeadlessActivity, DoomHeadlessCommand, DoomHeadlessEventName, DoomHeadlessExecutionContext, DoomHeadlessHook, DoomHeadlessHostService, DoomHeadlessRegistration, DoomHeadlessResource, DoomHeadlessSelection, DoomHeadlessSelectionChange, DoomHeadlessTool, DoomHeadlessToolRestriction } from "../../../schemas/headless.mjs";
+import "../../../../headless.mjs";
+import { HeadlessContextInventory, HeadlessHostOptions, HeadlessSelectionStatus, ResolvedHeadlessResource } from "../types/headlessHost.mjs";
+import { TSchema } from "typebox";
+import { Context, Service } from "@deepseek-ai/cordis";
+//#region src/systems/main/adapters/headlessHost.d.ts
+/**
+ * Maps one typed headless resource to the exact skill shape installed in AgentHarness.
+ *
+ * Prefers the resource's own `description` and `path`. The fallbacks below are what
+ * every skill used to get, and they are only good enough for explicit invocation,
+ * which matches on name: `doom-headless://` is not a path any tool can open, and
+ * "Headless skill from <source>" gives the model nothing to select on. A skill is
+ * only advertised in the prompt once it carries a real path.
+ */
+export declare function headlessHarnessSkill(resource: ResolvedHeadlessResource): {
+  name: string;
+  description: string;
+  content: string;
+  filePath: string;
+};
+/**
+ * The load tool's description with the session's skills appended, so the agent sees what it can
+ * load where it decides to call the tool. Rebuilt whenever the applied skills change.
+ */
+export declare function describeLoadSkillTool(base: string, skills: readonly ResolvedHeadlessResource[]): string;
+/** Retains facets and their state; only kernel-computed active contributions change. */
+export declare class HeadlessHost extends Service<DoomHeadlessHostService> implements DoomHeadlessHostService {
+  private readonly kernel;
+  private readonly selectionListeners;
+  private restrictions;
+  private restrictionsChanged;
+  private contributionsChanged;
+  private readonly options;
+  private readonly selectionOverrides;
+  private applied;
+  private requested;
+  private applying;
+  private refreshing;
+  private requestedRevision;
+  private appliedRevision;
+  private ready;
+  private disposed;
+  private failure;
+  private tail;
+  private activeSources;
+  private availableSources;
+  private tools;
+  private resources;
+  private resolvedResources;
+  private commands;
+  private hooks;
+  private readonly activities;
+  constructor(context: Context, options: HeadlessHostOptions);
+  get context(): DoomHeadlessExecutionContext;
+  get status(): HeadlessSelectionStatus;
+  /**
+   * The resources the last applied selection resolved to.
+   *
+   * `readResources` re-reads them for a live request and refuses while a
+   * selection is mid-apply. A reader describing the applied composition wants
+   * the same snapshot `getContextInventory` reports against, and wants it at
+   * the same moments, so it reads this instead of dispatching.
+   */
+  get appliedResources(): readonly ResolvedHeadlessResource[];
+  readSkill(name: string): string | undefined;
+  inspectCapabilities(): ReturnType<DoomHeadlessHostService['inspectCapabilities']>;
+  /**
+   * Every tool name this composition's eligible owners declare, including the
+   * ones a condition or a restriction currently gates out.
+   *
+   * `appliedTools` answers what runs now. A merge that places another surface's
+   * tools beside these needs what is spoken for, so a name a facet deliberately
+   * withheld is not handed to an unreconciled surface instead. Owner
+   * eligibility stays the outer gate: a package the selection excluded declares
+   * nothing here.
+   */
+  get declaredToolNames(): ReadonlySet<string>;
+  getContextInventory(selection?: DoomHeadlessSelection, countTokens?: CountTokens): HeadlessContextInventory;
+  setAvailableSources(sources: readonly string[]): void;
+  private matches;
+  private selected;
+  assertActive(source?: string): void;
+  subscribeSelection(listener: (selection: DoomHeadlessSelection) => void | Promise<void>): () => void;
+  /** Shared by facet reconciliation and the final Pi/facet merge. */
+  allowsTool(name: string): boolean;
+  registerToolRestriction(restriction: DoomHeadlessToolRestriction): DoomHeadlessRegistration;
+  private eligible;
+  changeSelection(change: DoomHeadlessSelectionChange): Promise<void>;
+  private refreshChangedSelection;
+  /** Refresh inherited defaults only at turn admission, keeping explicit session axes. */
+  inheritSelection(selection: Partial<DoomHeadlessSelection>): Promise<void>;
+  select(patch: Partial<DoomHeadlessSelection>): Promise<void>;
+  private assertReady;
+  private add;
+  registerTool<TParameters extends TSchema>(tool: DoomHeadlessTool<TParameters>): DoomHeadlessRegistration;
+  registerResource(resource: DoomHeadlessResource): DoomHeadlessRegistration;
+  registerCommand(command: DoomHeadlessCommand): DoomHeadlessRegistration;
+  registerHook(hook: DoomHeadlessHook): DoomHeadlessRegistration;
+  registerActivity(activity: DoomHeadlessActivity): DoomHeadlessRegistration;
+  listCommands(): Array<Pick<DoomHeadlessCommand, 'name' | 'description'>>;
+  dispatchCommand(name: string, args: string): Promise<void>;
+  dispatchHook(event: DoomHeadlessEventName, payload: Readonly<Record<string, unknown>>): Promise<unknown[]>;
+  private resolveResources;
+  readResources(): Promise<readonly ResolvedHeadlessResource[]>;
+  close(): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=headlessHost.d.mts.map

package/dist/src/systems/main/adapters/headlessHost.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headlessHost.d.mts","names":[],"sources":["../../../../../src/systems/main/adapters/headlessHost.ts"],"mappings":";;;;;;;;;;;;;;;;;wBAoEgB,qBAAqB,UAAU;EAE3C;EACA;EACA;EACA;;;;;;wBAYY,sBAAsB,cAAc,iBAAiB;;qBAoBxD,qBAAqB,QAAQ,oCAAoC;mBAC3D;mBACA;UACT;UACA;UACA;mBACS;mBACA;UACT;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;mBACS;EAEjB,YAAY,SAAS,SAAS,SAAS;MAiEnC,WAAW;MAIX,UAAU;;;;;;;;;MA0BV,6BAA6B;EAIjC,UAAU;EAKV,uBAAuB,WAAW;;;;;;;;;;;MAqE9B,qBAAqB;EAGzB,oBACE,YAAW,uBACX,cAAc,cACb;EA6EH,oBAAoB;UAGZ;UAMA;EAIR,aAAa;EAMb,mBAAmB,WAAW,WAAW,iCAAiC;;EAQ1E,WAAW;EAYX,wBAAwB,aAAa,8BAA8B;UAI3D;EAWR,gBAAgB,QAAQ,8BAA8B;UAQxC;;EA2BR,iBAAiB,WAAW,QAAQ,yBAAyB;EAqB7D,OAAO,OAAO,QAAQ,yBAAyB;UA0D7C;UAKA;EA4BR,aAAa,oBAAoB,SAAS,MAAM,iBAAiB,eAAe;EAGhF,iBAAiB,UAAU,uBAAuB;EAGlD,gBAAgB,SAAS,sBAAsB;EAG/C,aAAa,MAAM,mBAAmB;EAGtC,iBAAiB,UAAU,uBAAuB;EAIlD,gBAAgB,MAAM,KAAK;EAKrB,gBAAgB,cAAc,eAAe;EAO7C,aAAa,OAAO,uBAAuB,SAAS,SAAS,2BAA2B;UA+DhF;EA6BR,iBAAiB,iBAAiB;EASlC,SAAS"}

package/dist/src/systems/main/adapters/headlessHost.mjs

@@ -0,0 +1,552 @@
+import { createDoomKernel } from "../../../services/kernel/index.mjs";
+import { DOOM_HEADLESS_HOST_SERVICE, readDoomHeadlessOwner } from "../../../schemas/headless.mjs";
+import { Service } from "@deepseek-ai/cordis";
+import { formatSkillsForSystemPrompt } from "@earendil-works/pi-agent-core";
+//#region src/systems/main/adapters/headlessHost.ts
+function sameStrings(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function sameValues(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function sameSelection(left, right) {
+	return left.majorMode === right.majorMode && left.profile === right.profile && sameStrings(left.activeLayers, right.activeLayers) && sameStrings(left.domains, right.domains) && JSON.stringify(left.state ?? {}) === JSON.stringify(right.state ?? {});
+}
+/**
+* Maps one typed headless resource to the exact skill shape installed in AgentHarness.
+*
+* Prefers the resource's own `description` and `path`. The fallbacks below are what
+* every skill used to get, and they are only good enough for explicit invocation,
+* which matches on name: `doom-headless://` is not a path any tool can open, and
+* "Headless skill from <source>" gives the model nothing to select on. A skill is
+* only advertised in the prompt once it carries a real path.
+*/
+function headlessHarnessSkill(resource) {
+	return {
+		name: resource.name,
+		description: resource.description ?? `Headless skill from ${resource.source}`,
+		content: resource.text,
+		filePath: resource.path ?? `doom-headless://${resource.source}/${resource.name}`
+	};
+}
+function escapeXml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/**
+* The load tool's description with the session's skills appended, so the agent sees what it can
+* load where it decides to call the tool. Rebuilt whenever the applied skills change.
+*/
+function describeLoadSkillTool(base, skills) {
+	const listed = skills.filter((skill, index, all) => skill.kind === "skill" && all.findIndex((entry) => entry.name === skill.name) === index);
+	if (listed.length === 0) return base;
+	return [
+		base,
+		"",
+		"<available_skills>",
+		...listed.flatMap((skill) => [
+			"  <skill>",
+			`    <name>${escapeXml(skill.name)}</name>`,
+			`    <description>${escapeXml(headlessHarnessSkill(skill).description)}</description>`,
+			"  </skill>"
+		]),
+		"</available_skills>"
+	].join("\n");
+}
+/** Retains facets and their state; only kernel-computed active contributions change. */
+var HeadlessHost = class extends Service {
+	kernel = createDoomKernel();
+	selectionListeners = /* @__PURE__ */ new Set();
+	restrictions = [];
+	restrictionsChanged = false;
+	contributionsChanged = false;
+	options;
+	selectionOverrides;
+	applied;
+	requested;
+	applying;
+	refreshing = false;
+	requestedRevision = 0;
+	appliedRevision = 0;
+	ready = false;
+	disposed = false;
+	failure;
+	tail = Promise.resolve();
+	activeSources = /* @__PURE__ */ new Set();
+	availableSources = /* @__PURE__ */ new Set();
+	tools = /* @__PURE__ */ new Map();
+	resources = [];
+	resolvedResources = [];
+	commands = /* @__PURE__ */ new Map();
+	hooks = [];
+	activities = /* @__PURE__ */ new Map();
+	constructor(context, options) {
+		super(context, DOOM_HEADLESS_HOST_SERVICE);
+		this.options = options;
+		this.selectionOverrides = new Set(options.selectionOverrides);
+		this.applied = structuredClone(options.selection);
+		this.requested = this.applied;
+		this.applying = this.applied;
+		context.effect(() => () => this.close(), "headless host lifetime");
+		this.kernel.defineSlot("restrictions", (entries) => {
+			this.restrictionsChanged = true;
+			this.restrictions = entries.map((entry) => entry.value).filter((restriction) => this.matches(restriction.when));
+		});
+		this.kernel.defineSlot("tools", async (entries) => {
+			const next = /* @__PURE__ */ new Map();
+			for (const entry of this.selected(entries)) {
+				if (!this.allowsTool(entry.value.name)) continue;
+				if (!next.has(entry.value.name)) next.set(entry.value.name, entry);
+			}
+			const tools = [...next.values()].map((entry) => ({
+				...entry.value,
+				execute: async (id, parameters, signal, onUpdate) => {
+					this.assertReady();
+					if (this.tools.get(entry.value.name) !== entry || !this.activeSources.has(entry.source)) throw new Error(`Tool '${entry.value.name}' is no longer active`);
+					return entry.value.execute(id, parameters, signal, onUpdate, this.context);
+				}
+			}));
+			await this.options.applyTools(tools);
+			this.tools = next;
+		});
+		this.kernel.defineSlot("resources", async (entries) => {
+			this.resources = this.selected(entries);
+			this.resolvedResources = await this.resolveResources(this.applying);
+			await this.options.applyResources(this.resolvedResources);
+		});
+		this.kernel.defineSlot("commands", (entries) => {
+			const next = /* @__PURE__ */ new Map();
+			for (const entry of this.selected(entries)) if (!next.has(entry.value.name)) next.set(entry.value.name, entry);
+			this.commands = next;
+		});
+		this.kernel.defineSlot("hooks", (entries) => {
+			this.hooks = this.selected(entries);
+		});
+		this.kernel.defineSlot("activities", async (entries) => {
+			const desired = new Set(this.selected(entries));
+			for (const [entry, stop] of [...this.activities].reverse()) {
+				if (desired.has(entry)) continue;
+				await stop();
+				this.activities.delete(entry);
+			}
+			for (const entry of desired) {
+				if (this.activities.has(entry)) continue;
+				try {
+					const stop = await entry.value.start(this.options.context(this.applying));
+					this.activities.set(entry, stop);
+				} catch (error) {
+					if (this.options.candidates.some((candidate) => candidate.packageName === entry.source && candidate.required)) throw error;
+					this.options.onError?.(error);
+				}
+			}
+		});
+	}
+	get context() {
+		return this.options.context(this.applied);
+	}
+	get status() {
+		return {
+			requestedRevision: this.requestedRevision,
+			appliedRevision: this.appliedRevision,
+			ready: this.ready,
+			...this.failure === void 0 ? {} : { error: this.failure instanceof Error ? this.failure.message : typeof this.failure === "string" ? this.failure : "Headless selection failed" }
+		};
+	}
+	/**
+	* The resources the last applied selection resolved to.
+	*
+	* `readResources` re-reads them for a live request and refuses while a
+	* selection is mid-apply. A reader describing the applied composition wants
+	* the same snapshot `getContextInventory` reports against, and wants it at
+	* the same moments, so it reads this instead of dispatching.
+	*/
+	get appliedResources() {
+		return this.resolvedResources;
+	}
+	readSkill(name) {
+		return this.resolvedResources.findLast((entry) => entry.kind === "skill" && entry.name === name)?.text;
+	}
+	inspectCapabilities() {
+		const ready = this.ready && !this.disposed;
+		const capabilities = [];
+		if (ready) {
+			for (const entry of this.kernel.activeValues("tools")) {
+				const active = this.tools.get(entry.value.name) === entry;
+				const reason = active ? void 0 : !this.matches(entry.value.when) ? "inactive" : !this.allowsTool(entry.value.name) ? "restricted" : "shadowed";
+				capabilities.push({
+					source: entry.source,
+					name: entry.value.name,
+					kind: "tool",
+					when: structuredClone(entry.value.when),
+					active,
+					discoverable: active,
+					...reason ? { reason } : {}
+				});
+			}
+			const resolved = new Map(this.resolvedResources.filter((entry) => entry.kind === "skill").map((entry) => [entry.name, entry]));
+			for (const entry of this.kernel.activeValues("resources")) {
+				if (entry.value.kind !== "skill") continue;
+				const current = resolved.get(entry.value.name);
+				const selected = this.matches(entry.value.when);
+				const active = selected && current?.source === entry.source && current.path === entry.value.path && current.text.trim().length > 0;
+				const discoverable = active && !!current?.path && !!current.description?.trim();
+				const reason = !selected ? "inactive" : current && current.source !== entry.source ? "shadowed" : !active ? "unavailable" : !discoverable ? "not-discoverable" : void 0;
+				capabilities.push({
+					source: entry.source,
+					name: entry.value.name,
+					kind: "skill",
+					when: structuredClone(entry.value.when),
+					active,
+					discoverable,
+					...reason ? { reason } : {}
+				});
+			}
+		}
+		return {
+			revision: this.appliedRevision,
+			ready,
+			capabilities
+		};
+	}
+	/**
+	* Every tool name this composition's eligible owners declare, including the
+	* ones a condition or a restriction currently gates out.
+	*
+	* `appliedTools` answers what runs now. A merge that places another surface's
+	* tools beside these needs what is spoken for, so a name a facet deliberately
+	* withheld is not handed to an unreconciled surface instead. Owner
+	* eligibility stays the outer gate: a package the selection excluded declares
+	* nothing here.
+	*/
+	get declaredToolNames() {
+		return new Set(this.kernel.activeValues("tools").map((entry) => entry.value.name));
+	}
+	getContextInventory(selection = this.applied, countTokens) {
+		const currentSources = new Set(this.options.candidates.filter((candidate) => candidate.scopes.includes("session") && candidate.owners.some((owner) => owner.majorMode === selection.majorMode)).map((candidate) => candidate.packageName));
+		const conditionAttribution = (when) => when?.attribution ?? (when?.domain === void 0 ? void 0 : {
+			kind: "domain",
+			mode: when.domain
+		});
+		const toolsBySource = /* @__PURE__ */ new Map();
+		for (const contribution of this.kernel.contributions("tools")) {
+			if (!currentSources.has(contribution.source)) continue;
+			const tool = contribution.value.value;
+			const contextAttribution = conditionAttribution(tool.when);
+			const entry = {
+				name: tool.name,
+				description: tool.name === "load_skill" ? describeLoadSkillTool(tool.description, this.resolvedResources) : tool.description,
+				parameters: tool.parameters,
+				...tool.promptSnippet === void 0 ? {} : { promptSnippet: tool.promptSnippet },
+				...tool.promptGuidelines === void 0 ? {} : { promptGuidelines: tool.promptGuidelines },
+				active: this.tools.get(tool.name) === contribution.value,
+				...contextAttribution === void 0 ? {} : { contextAttribution }
+			};
+			const tools = toolsBySource.get(contribution.source);
+			if (tools) tools.push(entry);
+			else toolsBySource.set(contribution.source, [entry]);
+		}
+		const sources = [...toolsBySource].map(([source, tools]) => ({
+			key: source,
+			label: `${source} · extension`,
+			kind: "extension",
+			packageName: source,
+			tools
+		}));
+		const framingTokens = countTokens === void 0 ? 0 : countTokens(formatSkillsForSystemPrompt([]));
+		const skills = this.resolvedResources.flatMap((resource, index) => {
+			if (resource.kind !== "skill") return [];
+			const skill = headlessHarnessSkill(resource);
+			const contextAttribution = conditionAttribution(this.resources[index]?.value.when);
+			return [{
+				name: skill.name,
+				description: skill.description,
+				group: "extensions",
+				owner: resource.source,
+				modelInvocable: true,
+				body: skill.content,
+				...countTokens === void 0 ? {} : { promptTokens: Math.max(0, countTokens(formatSkillsForSystemPrompt([skill])) - framingTokens) },
+				...contextAttribution === void 0 ? {} : { contextAttribution }
+			}];
+		});
+		const attribution = {};
+		for (const candidate of this.options.candidates) {
+			const owner = candidate.owners.find((entry) => entry.majorMode === selection.majorMode && (entry.layer === "default" || selection.activeLayers.includes(entry.layer))) ?? candidate.owners.find((entry) => entry.majorMode === selection.majorMode);
+			if (owner && attribution[candidate.packageName] === void 0) attribution[candidate.packageName] = {
+				kind: "major",
+				mode: selection.majorMode,
+				layer: owner.layer
+			};
+		}
+		return {
+			sources,
+			skills,
+			attribution
+		};
+	}
+	setAvailableSources(sources) {
+		this.availableSources = new Set(sources);
+	}
+	matches(when) {
+		return Object.entries(when?.state ?? {}).every(([key, value]) => this.applying.state?.[key]?.includes(value)) && (when?.domain === void 0 || this.applying.domains.includes(when.domain));
+	}
+	selected(entries) {
+		return entries.filter(({ value }) => this.matches(value.when));
+	}
+	assertActive(source) {
+		this.assertReady();
+		if (source !== void 0 && !this.activeSources.has(source)) throw new Error(`Contribution owner '${source}' is inactive`);
+	}
+	subscribeSelection(listener) {
+		this.selectionListeners.add(listener);
+		return () => {
+			this.selectionListeners.delete(listener);
+		};
+	}
+	/** Shared by facet reconciliation and the final Pi/facet merge. */
+	allowsTool(name) {
+		const allowed = this.options.allowedTools?.(this.applying);
+		return (allowed === void 0 || allowed.includes(name)) && this.restrictions.every((restriction) => (restriction.allowedTools === void 0 || restriction.allowedTools.includes(name)) && !restriction.excludedTools?.includes(name));
+	}
+	registerToolRestriction(restriction) {
+		return this.add("restrictions", restriction);
+	}
+	eligible(entry, selection) {
+		return entry.scopes.includes("session") && entry.owners.some((owner) => owner.majorMode === selection.majorMode && (owner.layer === "default" || selection.activeLayers.includes(owner.layer)));
+	}
+	changeSelection(change) {
+		this.selectionOverrides.add(change.axis);
+		if (change.axis === "majorMode") return this.select({ majorMode: change.majorMode });
+		if (change.axis === "domains") return this.select({ domains: change.domains });
+		if (change.axis === "profile") return this.select({ profile: change.profile });
+		return this.select({ state: {
+			...this.requested.state,
+			[change.key]: [...change.values]
+		} });
+	}
+	async refreshChangedSelection(previous, selection, previousValues) {
+		const majorChanged = previous.majorMode !== selection.majorMode || !sameStrings(previous.activeLayers, selection.activeLayers);
+		const domainsChanged = !sameStrings(previous.domains, selection.domains);
+		const profileChanged = previous.profile !== selection.profile;
+		const stateChanged = JSON.stringify(previous.state ?? {}) !== JSON.stringify(selection.state ?? {});
+		if (this.appliedRevision === 0) return;
+		const refresh = async (slot) => {
+			if (sameValues(previousValues.get(slot) ?? [], this.kernel.activeValues(slot))) await this.kernel.refresh(slot);
+		};
+		if (stateChanged) await refresh("restrictions");
+		if (majorChanged || domainsChanged || stateChanged || this.restrictionsChanged) await refresh("tools");
+		if (majorChanged || domainsChanged || profileChanged || stateChanged) await refresh("resources");
+		if (domainsChanged || stateChanged) {
+			await refresh("commands");
+			await refresh("hooks");
+			await refresh("activities");
+		}
+	}
+	/** Refresh inherited defaults only at turn admission, keeping explicit session axes. */
+	async inheritSelection(selection) {
+		const patch = {
+			...!this.selectionOverrides.has("majorMode") && selection.majorMode !== void 0 ? { majorMode: selection.majorMode } : {},
+			...!this.selectionOverrides.has("domains") && selection.domains !== void 0 ? { domains: selection.domains } : {},
+			...!this.selectionOverrides.has("profile") && Object.hasOwn(selection, "profile") ? { profile: selection.profile } : {}
+		};
+		if ((patch.majorMode === void 0 || patch.majorMode === this.requested.majorMode) && (patch.domains === void 0 || sameStrings(patch.domains, this.requested.domains)) && (!Object.hasOwn(patch, "profile") || patch.profile === this.requested.profile)) return;
+		await this.select(patch);
+	}
+	async select(patch) {
+		if (this.disposed) throw new Error("The headless host is disposed");
+		const requested = structuredClone({
+			...this.requested,
+			...patch
+		});
+		this.requested = requested;
+		const revision = ++this.requestedRevision;
+		this.ready = false;
+		const apply = async () => {
+			if (this.disposed) throw new Error("The headless host is disposed");
+			const selection = structuredClone(await this.options.resolveSelection?.(requested) ?? requested);
+			await this.options.validateSelection?.(selection);
+			if (revision === this.requestedRevision) this.requested = selection;
+			const eligible = this.options.candidates.filter((entry) => this.eligible(entry, selection));
+			const missing = eligible.find((entry) => entry.required && !this.availableSources.has(entry.packageName));
+			if (missing) throw new Error(`Required headless package '${missing.packageName}' is unavailable`);
+			this.applying = selection;
+			this.refreshing = true;
+			let compositionChanged = false;
+			try {
+				const previousValues = new Map(this.kernel.slots.map((slot) => [slot, this.kernel.activeValues(slot)]));
+				await this.kernel.setActiveLayers(eligible.map((entry) => entry.packageName));
+				await this.refreshChangedSelection(this.applied, selection, previousValues);
+				compositionChanged = this.appliedRevision === 0 || !sameSelection(this.applied, selection) || this.restrictionsChanged || this.contributionsChanged || !sameValues(previousValues.get("tools") ?? [], this.kernel.activeValues("tools")) || !sameValues(previousValues.get("resources") ?? [], this.kernel.activeValues("resources"));
+				this.restrictionsChanged = false;
+				this.contributionsChanged = false;
+			} finally {
+				this.refreshing = false;
+			}
+			if (this.disposed) throw new Error("The headless host is disposed");
+			this.activeSources = new Set(eligible.map((entry) => entry.packageName));
+			this.applied = selection;
+			this.appliedRevision = revision;
+			this.failure = void 0;
+			this.ready = revision === this.requestedRevision;
+			for (const listener of this.selectionListeners) await listener(selection);
+			if (compositionChanged) await this.options.onApplied?.(selection, revision);
+		};
+		const result = this.tail.catch(() => void 0).then(apply);
+		this.tail = result.catch((error) => {
+			this.failure = error;
+			this.ready = false;
+			if (!this.disposed) this.options.onError?.(error);
+		});
+		return result;
+	}
+	assertReady() {
+		if (this.disposed || !this.ready) throw new Error("Headless dispatch is blocked until selection is coherently applied");
+	}
+	add(slot, value) {
+		const owner = readDoomHeadlessOwner(this.ctx);
+		if (!owner) throw new Error("A headless contribution must have descriptor-owned package identity");
+		this.ready = false;
+		this.contributionsChanged = true;
+		const registration = this.kernel.contribute(slot, {
+			source: owner.packageName,
+			layer: owner.packageName,
+			value: {
+				source: owner.packageName,
+				value
+			}
+		});
+		let disposed = false;
+		const dispose = () => {
+			if (disposed) return;
+			disposed = true;
+			this.ready = false;
+			this.contributionsChanged = true;
+			registration.dispose();
+			if (this.appliedRevision > 0 && !this.disposed && !this.refreshing) this.select({}).catch(() => void 0);
+		};
+		this.ctx.effect(() => dispose, `headless ${slot} contribution`);
+		if (this.appliedRevision > 0 && !this.refreshing) this.select({}).catch(() => void 0);
+		return { dispose };
+	}
+	registerTool(tool) {
+		return this.add("tools", tool);
+	}
+	registerResource(resource) {
+		return this.add("resources", resource);
+	}
+	registerCommand(command) {
+		return this.add("commands", command);
+	}
+	registerHook(hook) {
+		return this.add("hooks", hook);
+	}
+	registerActivity(activity) {
+		return this.add("activities", activity);
+	}
+	listCommands() {
+		this.assertReady();
+		return [...this.commands.values()].map(({ value }) => ({
+			name: value.name,
+			description: value.description
+		}));
+	}
+	async dispatchCommand(name, args) {
+		this.assertReady();
+		const command = this.commands.get(name);
+		if (!command) throw new Error(`Command '${name}' is inactive or unknown`);
+		await command.value.execute(args, this.context);
+	}
+	async dispatchHook(event, payload) {
+		this.assertReady();
+		const results = [];
+		const revision = this.appliedRevision;
+		let current = payload;
+		for (const hook of this.hooks.filter((entry) => entry.value.event === event)) {
+			this.assertReady();
+			if (!this.hooks.includes(hook)) continue;
+			let result;
+			try {
+				result = await hook.value.handle(current, this.context);
+			} catch (error) {
+				this.options.onError?.(error);
+				continue;
+			}
+			if (event === "session_start") {
+				await this.tail;
+				this.assertReady();
+			}
+			results.push(result);
+			if (result && typeof result === "object" && !Array.isArray(result)) {
+				const patch = result;
+				const fields = event === "context" ? ["messages", "systemPrompt"] : event === "tool_call" ? ["args"] : event === "tool_result" ? [
+					"content",
+					"details",
+					"isError",
+					"usage"
+				] : event === "before_agent_start" ? ["systemPrompt"] : event === "before_provider_request" ? ["payload"] : [];
+				for (const field of fields) {
+					if (event === "before_agent_start" && typeof patch[field] !== "string") continue;
+					if (patch[field] !== void 0) current = {
+						...current,
+						[field]: patch[field]
+					};
+				}
+				if (event === "tool_call" && patch.block !== void 0) break;
+				if (event === "session_before_compact" && (patch.cancel !== void 0 || patch.decline !== void 0 || patch.compaction !== void 0)) break;
+			}
+		}
+		if (event === "before_agent_start" || event === "context" || event === "tool_call") {
+			this.assertReady();
+			if (revision !== this.appliedRevision) throw new Error(event === "before_agent_start" ? "Selection changed while preparing the system prompt" : `Selection changed while dispatching ${event}`);
+		}
+		return results;
+	}
+	async resolveResources(selection) {
+		const context = this.options.context(selection);
+		const result = [];
+		for (const resource of this.resources) {
+			let value;
+			try {
+				value = await resource.value.read(context);
+			} catch (error) {
+				this.options.onError?.(new Error(`Could not read headless resource '${resource.source}/${resource.value.name}'`, { cause: error }));
+				continue;
+			}
+			result.push({
+				source: resource.source,
+				name: resource.value.name,
+				kind: resource.value.kind,
+				...resource.value.description === void 0 ? {} : { description: resource.value.description },
+				...resource.value.path === void 0 ? {} : { path: resource.value.path },
+				text: value
+			});
+		}
+		return result;
+	}
+	async readResources() {
+		this.assertReady();
+		const revision = this.appliedRevision;
+		const result = await this.resolveResources(this.applied);
+		this.assertReady();
+		if (revision !== this.appliedRevision) throw new Error("Selection changed while reading resources");
+		return result;
+	}
+	async close() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.ready = false;
+		this.selectionListeners.clear();
+		await this.tail.catch(() => void 0);
+		const failures = [];
+		for (const stop of [...this.activities.values()].reverse()) try {
+			await stop();
+		} catch (error) {
+			failures.push(error);
+		}
+		this.activities.clear();
+		this.kernel.dispose();
+		if (failures.length) throw new AggregateError(failures, "Headless activities failed to stop");
+	}
+};
+//#endregion
+export { HeadlessHost, describeLoadSkillTool, headlessHarnessSkill };
+
+//# sourceMappingURL=headlessHost.mjs.map