@agimon-ai/po-core 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/headlessHub.mjs

@@ -1,13 +1,18 @@
+import { SessionMetadataDoc } from "./src/services/durableSession/docs.mjs";
+import { PROFILE_ICON_MIME_TYPES } from "./src/schemas/profileIdentity.mjs";
+import "./src/schemas/hubChannel.mjs";
+import { parseHomeProjection } from "./src/schemas/home.mjs";
 import "./src/schemas/notification.mjs";
-import "./src/server/directHarnessRuntime.mjs";
-import { createDoomPluginRegistry } from "./src/schemas/pluginProtocol.mjs";
+import "./src/schemas/sessionProtocol.mjs";
+import "./src/constants/agentSettled.mjs";
+import { createPoPluginRegistry } from "./src/schemas/pluginProtocol.mjs";
 import "./pluginProtocol.mjs";
-import { PROFILE_ICON_MIME_TYPES } from "./src/schemas/profileIdentity.mjs";
-import { createDoomServerHost } from "./src/services/serverFacet/index.mjs";
-import { installServerFacets } from "./src/server/serverFacetLoader.mjs";
-import "./serverFacet.mjs";
+import { createPoServerHost } from "./src/services/serverHost/index.mjs";
+import { PoServerScope } from "./src/server/serverScope.mjs";
+import "./serverPlugin.mjs";
 import { readSessionGitStatus } from "./src/services/sessionGitStatus/index.mjs";
 import crypto from "node:crypto";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 //#region src/server/headlessHub.ts
 const AUTHORIZATION_HEADER = "authorization";
 const CHANNEL_PRIORITY = {
@@ -32,6 +37,16 @@ async function lastSettledAt(host) {
 		return;
 	}
 }
+/** The groups a resumed session was saved with. Sessions from before groups existed have none. */
+async function storedGroups(host, onNotice) {
+	try {
+		const { groups } = await host.runtime.session.snapshot(SessionMetadataDoc, BACKGROUND_CONTEXT);
+		return Array.isArray(groups) ? groups.filter((group) => typeof group === "string") : [];
+	} catch (error) {
+		onNotice?.(`Session groups could not be read: ${String(error)}`);
+		return [];
+	}
+}
 function scopeOf(session) {
 	return {
 		sessionId: session.id,
@@ -43,6 +58,7 @@ function scopeOf(session) {
 }
 /** Owns direct, same-process session and channel state for presentation adapters. */
 function createHeadlessHub(options) {
+	const readGitStatus = options.readGitStatus ?? ((cwd) => readSessionGitStatus(options.platform.env(cwd), cwd));
 	const sessions = /* @__PURE__ */ new Map();
 	const pendingSetups = /* @__PURE__ */ new Map();
 	const activities = /* @__PURE__ */ new Map();
@@ -56,7 +72,8 @@ function createHeadlessHub(options) {
 			...activity === void 0 ? {} : { activity }
 		};
 	};
-	const pluginRegistry = createDoomPluginRegistry();
+	const pluginRegistry = createPoPluginRegistry();
+	const editPresence = /* @__PURE__ */ new Map();
 	const channels = /* @__PURE__ */ new Map();
 	const listeners = /* @__PURE__ */ new Set();
 	const subscriptions = /* @__PURE__ */ new Set();
@@ -70,13 +87,18 @@ function createHeadlessHub(options) {
 	const maxDirectEventLatest = 4096;
 	const communicationEndpoints = /* @__PURE__ */ new Map();
 	let closed = false;
-	const mounts = /* @__PURE__ */ new Map();
-	const disposeMount = async (mounted) => {
-		try {
-			await mounted.installed.dispose();
-		} finally {
-			mounted.host.dispose();
+	/** The mount table each served global or workspace scope publishes, by mount key. */
+	const scopeHosts = /* @__PURE__ */ new Map();
+	let globalScope;
+	const workspaceScopes = /* @__PURE__ */ new Map();
+	const openGlobalScope = () => globalScope ??= PoServerScope.open("global");
+	const openWorkspaceScope = (workspaceId) => {
+		let scope = workspaceScopes.get(workspaceId);
+		if (scope === void 0) {
+			scope = openGlobalScope().then((global) => PoServerScope.open("workspace", global));
+			workspaceScopes.set(workspaceId, scope);
 		}
+		return scope;
 	};
 	const workspaces = /* @__PURE__ */ new Map();
 	const worktreeProvisioners = /* @__PURE__ */ new Map();
@@ -84,11 +106,17 @@ function createHeadlessHub(options) {
 	const mountKey = (mount) => mount.scope === "global" ? "global" : mount.scope === "workspace" ? `workspace:${mount.workspaceId}` : `session:${mount.sessionId}`;
 	const belongs = (mount, session) => mount.scope === "global" || (mount.scope === "workspace" ? session.workspaceId === mount.workspaceId : session.id === mount.sessionId);
 	const canClose = (mount, session) => belongs(mount, session) || mount.scope === "session" && session.parentSessionId === mount.sessionId;
+	const peers = (a, b) => {
+		if (a.sessionProvenance === "remote-conversation" || b.sessionProvenance === "remote-conversation") return false;
+		const root = a.host.sessionContext?.checkoutRoot;
+		if (root !== void 0 && root === b.host.sessionContext?.checkoutRoot) return true;
+		return (a.groups ?? []).some((group) => b.groups?.includes(group) === true);
+	};
 	const canCommunicate = (sourceId, targetId) => {
 		if (closed || sourceId === targetId) return false;
 		const source = sessions.get(sourceId);
 		const target = sessions.get(targetId);
-		return source !== void 0 && target !== void 0 && (source.parentSessionId === target.id || target.parentSessionId === source.id);
+		return source !== void 0 && target !== void 0 && (source.parentSessionId === target.id || target.parentSessionId === source.id || peers(source, target));
 	};
 	const registerReservedWorktreeProvisioner = (mount, provisioner) => {
 		const key = mountKey(mount);
@@ -198,6 +226,9 @@ function createHeadlessHub(options) {
 		};
 		endpoint = {
 			sessionId,
+			get sessionName() {
+				return sessions.get(sessionId)?.name;
+			},
 			publish(targetSessionId, type, payload) {
 				if (!canCommunicate(sessionId, targetSessionId)) return false;
 				const target = communicationEndpoints.get(targetSessionId);
@@ -222,6 +253,20 @@ function createHeadlessHub(options) {
 				} else for (const [peerSessionId, peer] of communicationEndpoints) if (peer.ready && canCommunicate(sessionId, peerSessionId)) listener(peerSessionId);
 				return () => readyListeners.delete(listener);
 			},
+			describePeer(peerSessionId) {
+				if (!canCommunicate(sessionId, peerSessionId)) return void 0;
+				const peer = sessions.get(peerSessionId);
+				if (peer === void 0) return void 0;
+				const own = sessions.get(sessionId).groups ?? [];
+				const sharedGroups = (peer.groups ?? []).filter((group) => own.includes(group));
+				const profile = peer.profile?.displayName ?? peer.profile?.name;
+				return {
+					sessionId: peerSessionId,
+					name: peer.name,
+					...profile === void 0 ? {} : { profile },
+					sharedGroups
+				};
+			},
 			close() {
 				if (communicationEndpoints.get(sessionId)?.endpoint !== endpoint) return;
 				communicationEndpoints.delete(sessionId);
@@ -299,6 +344,8 @@ function createHeadlessHub(options) {
 		};
 	};
 	const channelHost = (frameType, mount) => ({
+		homeDirectory: options.platform.homeDirectory,
+		sessionStorage: options.platform.sessions,
 		sessions: () => sessionScopes().filter((scope) => {
 			const session = sessions.get(scope.sessionId);
 			return session !== void 0 && serves(mount, frameType, session);
@@ -419,7 +466,7 @@ function createHeadlessHub(options) {
 		if (!connectionId) return false;
 		const session = sessions.get(sessionId);
 		if (!session || !belongs(mount, session)) return false;
-		const started = channels.get(`${mountKey(mount)}:${frameType}`);
+		const started = selectedChannel(session, frameType);
 		if (!started?.channel.receive) return false;
 		started.channel.receive(scopeOf(session), payload, { connectionId });
 		return true;
@@ -435,6 +482,7 @@ function createHeadlessHub(options) {
 			options.computerUse?.forgetSession?.(sessionId);
 		} finally {
 			sessions.delete(sessionId);
+			pendingSetups.delete(sessionId);
 			activities.delete(sessionId);
 			sessionCleanups.delete(sessionId);
 			presentationCleanups.get(sessionId)?.();
@@ -451,12 +499,17 @@ function createHeadlessHub(options) {
 	const startSessionShutdown = (session, closeOptions) => {
 		const existing = sessionShutdowns.get(session.id);
 		if (existing !== void 0) return existing.promise;
+		const { id, workspaceId, parentSessionId } = session;
 		const shutdown = {
-			session,
+			session: {
+				id,
+				workspaceId,
+				parentSessionId
+			},
 			promise: Promise.resolve(),
 			pending: true
 		};
-		const promise = Promise.resolve().then(() => closeOptions === void 0 ? options.manager.closeSession(session.id) : options.manager.closeSession(session.id, closeOptions));
+		const promise = Promise.resolve().then(() => closeOptions === void 0 ? options.manager.closeSession(id) : options.manager.closeSession(id, closeOptions));
 		shutdown.promise = promise;
 		sessionShutdowns.set(session.id, shutdown);
 		promise.then(() => {
@@ -484,7 +537,7 @@ function createHeadlessHub(options) {
 		sessions.set(session.id, current);
 		announceCommunicationReady(session.id);
 		const refreshGit = () => {
-			(options.readGitStatus ?? readSessionGitStatus)(session.cwd).then((git) => {
+			readGitStatus(session.cwd).then((git) => {
 				if (closed || sessions.get(session.id)?.host !== session.host) return;
 				if (git?.branch === current.git?.branch && git?.dirty === current.git?.dirty) return;
 				const { git: _previous, ...rest } = current;
@@ -503,7 +556,7 @@ function createHeadlessHub(options) {
 			if (sessions.get(session.id)?.host !== session.host) return;
 			const type = typeof frame.type === "string" ? frame.type : "";
 			const entry = frame.entry;
-			if (type === "entry_appended" && entry?.customType === "doom-notification") {
+			if (type === "entry_appended" && entry?.customType === "po-notification") {
 				emit({
 					kind: "frame",
 					sessionId: session.id,
@@ -511,7 +564,7 @@ function createHeadlessHub(options) {
 				});
 				return;
 			}
-			if (type !== "agent_start" && type !== "agent_settled" && type !== "message_end" && type !== "session_info_changed" && type !== "extension_ui_request" && type !== "extension_ui_answered") return;
+			if (type !== "agent_start" && type !== "agent_settled" && type !== "message_end" && type !== "session_info_changed" && type !== "session_groups_changed" && type !== "extension_ui_request" && type !== "extension_ui_answered") return;
 			const now = (/* @__PURE__ */ new Date()).toISOString();
 			const phase = type === "agent_start" ? "turn" : type === "agent_settled" ? "idle" : current.phase;
 			const phaseChanged = phase !== current.phase;
@@ -523,9 +576,11 @@ function createHeadlessHub(options) {
 				"editor"
 			].includes(method);
 			const awaitingInput = dialog ? true : type === "extension_ui_answered" || type === "agent_settled" ? false : current.awaitingInput;
+			const groups = type === "session_groups_changed" && Array.isArray(frame.groups) ? frame.groups.filter((group) => typeof group === "string") : current.groups;
 			current = {
 				...current,
 				name: type === "session_info_changed" && typeof frame.name === "string" ? frame.name : current.name,
+				...groups === void 0 ? {} : { groups },
 				updatedAt: now,
 				phase,
 				phaseSince: phaseChanged ? now : current.phaseSince,
@@ -538,6 +593,7 @@ function createHeadlessHub(options) {
 				kind: "upsert",
 				session: current
 			});
+			if (type === "session_groups_changed") announceCommunicationReady(session.id);
 			if (dialog) {
 				const text = (key) => typeof frame[key] === "string" ? { [key]: frame[key] } : {};
 				emit({
@@ -555,16 +611,30 @@ function createHeadlessHub(options) {
 			if (type === "agent_settled") refreshGit();
 		});
 		let registered = false;
+		const root = () => session.workspaceId && workspaces.get(session.workspaceId)?.root || session.cwd;
+		let compositionMode;
+		const applyCompositions = (majorMode) => {
+			if (!options.publishSessionCompositions || majorMode === compositionMode) return false;
+			compositionMode = majorMode;
+			try {
+				const { webComposition, nativeComposition } = options.publishSessionCompositions(session.id, root(), majorMode);
+				current = {
+					...current,
+					webComposition,
+					nativeComposition
+				};
+				return true;
+			} catch (error) {
+				options.onNotice?.(`session ${session.id} plugins for major mode "${majorMode}" could not be published (${error instanceof Error ? error.message : String(error)})`);
+				return false;
+			}
+		};
 		const applyProfile = (profileName) => {
-			if (closed || sessions.get(session.id)?.host !== session.host) return;
 			let identity;
-			if (profileName) {
-				const root = session.workspaceId && workspaces.get(session.workspaceId)?.root || session.cwd;
-				try {
-					identity = options.resolveProfileIdentity?.(root, profileName);
-				} catch (error) {
-					options.onNotice?.(`session ${session.id} profile "${profileName}" could not be resolved (${error instanceof Error ? error.message : String(error)})`);
-				}
+			if (profileName) try {
+				identity = options.resolveProfileIdentity?.(root(), profileName);
+			} catch (error) {
+				options.onNotice?.(`session ${session.id} profile "${profileName}" could not be resolved (${error instanceof Error ? error.message : String(error)})`);
 			}
 			const icon = identity?.icon;
 			if (icon) avatarIcons.set(session.id, icon);
@@ -575,22 +645,43 @@ function createHeadlessHub(options) {
 				...icon ? { iconVersion: crypto.createHash("sha256").update(icon).digest("hex").slice(0, ICON_VERSION_LENGTH) } : {}
 			} : void 0;
 			const previous = current.profile;
-			if (previous?.name === profile?.name && previous?.displayName === profile?.displayName && previous?.iconVersion === profile?.iconVersion) return;
+			if (previous?.name === profile?.name && previous?.displayName === profile?.displayName && previous?.iconVersion === profile?.iconVersion) return false;
 			const { profile: _previous, ...rest } = current;
 			current = profile === void 0 ? rest : {
 				...rest,
 				profile
 			};
+			return true;
+		};
+		const applySelection = (selection) => {
+			if (closed || sessions.get(session.id)?.host !== session.host) return;
+			const compositionsChanged = applyCompositions(selection.majorMode);
+			const profileChanged = applyProfile(selection.profile);
+			if (!compositionsChanged && !profileChanged) return;
 			sessions.set(session.id, current);
 			if (registered) emit({
 				kind: "upsert",
 				session: current
 			});
 		};
-		const stopSelection = session.host.onSelection?.((selection) => applyProfile(selection.profile));
+		const stopSelection = session.host.onSelection?.(applySelection);
+		const stopBackgroundWork = session.host.onBackgroundWork?.((backgroundWorkActive) => {
+			if (closed || sessions.get(session.id)?.host !== session.host) return;
+			if (current.backgroundWorkActive === backgroundWorkActive) return;
+			current = {
+				...current,
+				backgroundWorkActive
+			};
+			sessions.set(session.id, current);
+			if (registered) emit({
+				kind: "upsert",
+				session: current
+			});
+		});
 		presentationCleanups.set(session.id, () => {
 			stopPresentation();
 			stopSelection?.();
+			stopBackgroundWork?.();
 		});
 		for (const { source } of selectedChannels(current)) source.sessionAdded?.(scopeOf(session));
 		const active = () => sessions.get(session.id)?.host === session.host && !closed;
@@ -665,7 +756,7 @@ function createHeadlessHub(options) {
 		canCommunicate,
 		bindCommunication
 	};
-	const installMount = async (facets, suppliedContext, announceWorkspace) => {
+	const serveScope = async (suppliedContext, packages = []) => {
 		if (closed) throw new Error("The headless hub is closed.");
 		const context = suppliedContext ?? {
 			scope: "global",
@@ -674,18 +765,20 @@ function createHeadlessHub(options) {
 			directEvents,
 			onNotice: (message) => options.onNotice?.(message)
 		};
-		if (context.scope === "session") throw new Error("Session facets belong to their session host.");
+		if (context.scope === "session") throw new Error("Session packages belong to their session host.");
 		if (context.scope === "workspace" && (!context.workspaceId || !context.workspaceRoot)) throw new Error("Workspace mounts require an admitted identity and root.");
 		const mount = context.scope === "global" ? { scope: "global" } : {
 			scope: "workspace",
 			workspaceId: context.workspaceId
 		};
 		const key = mountKey(mount);
-		if (mounts.has(key)) throw new Error(`The '${key}' facets are already mounted.`);
-		const host = createDoomServerHost({
+		if (scopeHosts.has(key)) throw new Error(`The '${key}' scope is already served.`);
+		const host = createPoServerHost({
 			scope: context.scope,
 			context: {
 				...context,
+				homeDirectory: context.homeDirectory ?? options.platform.homeDirectory,
+				sessionStorage: options.platform.sessions,
 				sessionService: channelHost("", mount).sessionService,
 				directEvents: channelHost("", mount).directEvents,
 				receiveChannel: (sessionId, frameType, payload, connectionId) => receiveMountedChannel(mount, sessionId, frameType, payload, connectionId)
@@ -703,23 +796,20 @@ function createHeadlessHub(options) {
 			},
 			pluginRegistry
 		});
+		let scope;
 		try {
-			const installed = await installServerFacets({
+			scope = await (mount.scope === "global" ? openGlobalScope() : openWorkspaceScope(mount.workspaceId));
+			await scope.serve({
 				host,
-				facets,
-				onNotice: options.onNotice
+				platform: options.platform
 			});
-			if (closed) {
-				await installed.dispose();
-				throw new Error("The headless hub was closed while mounting facets.");
-			}
-			mounts.set(key, {
+			scopeHosts.set(key, {
 				host,
-				installed,
-				context,
-				facets
+				scope
 			});
-			if (announceWorkspace && mount.scope === "workspace") {
+			await scope.install(packages, { onNotice: (message) => options.onNotice?.(message) });
+			if (closed) throw new Error("The headless hub was closed while serving a scope.");
+			if (mount.scope === "workspace") {
 				const workspace = {
 					id: mount.workspaceId,
 					root: context.workspaceRoot,
@@ -732,50 +822,148 @@ function createHeadlessHub(options) {
 				});
 			}
 		} catch (error) {
+			if (scopeHosts.get(key)?.host === host) scopeHosts.delete(key);
 			host.dispose();
+			if (mount.scope === "workspace") workspaceScopes.delete(mount.workspaceId);
+			else globalScope = void 0;
+			await scope?.dispose();
 			throw error;
 		}
 	};
-	const mountFacets = (facets, suppliedContext) => installMount(facets, suppliedContext, true);
-	const replacements = /* @__PURE__ */ new Map();
-	const replaceFacets = (mount, facets) => {
-		if (mount.scope === "session") return Promise.reject(/* @__PURE__ */ new Error("Session facets belong to their session host."));
-		const key = mountKey(mount);
-		const run = (replacements.get(key) ?? Promise.resolve()).then(async () => {
-			if (closed) throw new Error("The headless hub is closed.");
-			const previous = mounts.get(key);
-			if (previous === void 0) throw new Error(`The '${key}' facets are not mounted.`);
-			mounts.delete(key);
-			await disposeMount(previous);
-			if (closed || mount.scope === "workspace" && !workspaces.has(mount.workspaceId)) return;
-			try {
-				await installMount(facets, previous.context, false);
-			} catch (error) {
-				await installMount(previous.facets, previous.context, false).catch((rollbackError) => options.onNotice?.(`The '${key}' facets could not be restored (${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)})`));
-				throw error;
-			}
-		});
-		const settled = run.then(() => void 0, () => void 0);
-		replacements.set(key, settled);
-		settled.then(() => {
-			if (replacements.get(key) === settled) replacements.delete(key);
-		});
-		return run;
+	const installPackages = async (mount, packages) => {
+		if (mount.scope === "session") throw new Error("Session packages belong to their session host.");
+		if (closed) throw new Error("The headless hub is closed.");
+		const served = scopeHosts.get(mountKey(mount));
+		if (served === void 0) throw new Error(`The '${mountKey(mount)}' scope is not served.`);
+		await served.scope.install(packages, { onNotice: (message) => options.onNotice?.(message) });
 	};
 	return {
 		sessionService,
 		directEvents,
 		...options.computerUse === void 0 ? {} : { computerUse: options.computerUse },
+		async readHome(request, authorizeSession) {
+			if (!request || typeof request !== "object" || Array.isArray(request) || request.source !== void 0 && (typeof request.source !== "string" || request.source.length > 128) || request.workspaceId !== void 0 && (typeof request.workspaceId !== "string" || request.workspaceId.length > 256)) throw new Error("Invalid Home request.");
+			const offset = Number.isSafeInteger(request?.offset) && request.offset >= 0 ? request.offset : 0;
+			const limit = Number.isSafeInteger(request?.limit) && request.limit > 0 ? Math.min(request.limit, 50) : 50;
+			const counts = {
+				decision: 0,
+				failure: 0,
+				blocked: 0,
+				running: 0,
+				queued: 0,
+				paused: 0,
+				completed: 0
+			};
+			const statuses = /* @__PURE__ */ new Map();
+			const entities = /* @__PURE__ */ new Map();
+			let examined = 0;
+			let projectors = 0;
+			for (const session of sessions.values()) {
+				if (closed || !authorizeSession(session.id) || request.workspaceId !== void 0 && request.workspaceId !== session.workspaceId) continue;
+				for (const { channel, source } of selectedChannels(session)) {
+					if (!source.homeFor || request.source !== void 0 && request.source !== channel.frameType) continue;
+					const key = JSON.stringify([channel.frameType, session.workspaceId]);
+					const status = statuses.get(key) ?? {
+						source: channel.frameType,
+						...session.workspaceId === void 0 ? {} : { workspaceId: session.workspaceId },
+						coverage: "ready"
+					};
+					statuses.set(key, status);
+					if (examined >= 1e3 || projectors++ >= 1e3) {
+						status.coverage = "partial";
+						continue;
+					}
+					try {
+						const projection = parseHomeProjection(source.homeFor(scopeOf(session)));
+						if (!projection) {
+							status.coverage = "partial";
+							continue;
+						}
+						if (projection.coverage === "partial" || status.coverage === "partial") status.coverage = "partial";
+						else if (projection.coverage === "unavailable") status.coverage = "unavailable";
+						for (const entity of projection.entities) {
+							examined += 1;
+							if (examined > 1e3) {
+								status.coverage = "partial";
+								break;
+							}
+							if (![entity.sessionId, ...entity.relatedSessionIds ?? []].every((id) => {
+								const referenced = sessions.get(id);
+								return referenced !== void 0 && referenced.workspaceId === session.workspaceId && authorizeSession(id);
+							})) {
+								status.coverage = "partial";
+								continue;
+							}
+							const { relatedSessionIds: _related, ...publicEntity } = entity;
+							const identity = JSON.stringify([
+								channel.frameType,
+								session.workspaceId,
+								entity.id
+							]);
+							const previous = entities.get(identity);
+							if (!previous || Date.parse(entity.updatedAt) > Date.parse(previous.updatedAt)) entities.set(identity, {
+								...publicEntity,
+								source: channel.frameType,
+								...session.workspaceId === void 0 ? {} : { workspaceId: session.workspaceId }
+							});
+						}
+					} catch {
+						status.coverage = "partial";
+					}
+				}
+			}
+			for (const status of statuses.values()) status.counts = {
+				decision: 0,
+				failure: 0,
+				blocked: 0,
+				running: 0,
+				queued: 0,
+				paused: 0,
+				completed: 0
+			};
+			for (const entity of entities.values()) {
+				const status = statuses.get(JSON.stringify([entity.source, entity.workspaceId]));
+				if (status?.counts) status.counts[entity.kind] += 1;
+			}
+			const attention = [...entities.values()].filter((entity) => {
+				counts[entity.kind] += 1;
+				return [
+					"decision",
+					"failure",
+					"blocked",
+					"paused"
+				].includes(entity.kind);
+			}).sort((a, b) => [
+				"decision",
+				"failure",
+				"blocked",
+				"paused"
+			].indexOf(a.kind) - [
+				"decision",
+				"failure",
+				"blocked",
+				"paused"
+			].indexOf(b.kind) || Date.parse(b.updatedAt) - Date.parse(a.updatedAt) || a.id.localeCompare(b.id) || a.source.localeCompare(b.source));
+			return {
+				version: 1,
+				observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				sources: [...statuses.values()],
+				counts,
+				items: attention.slice(offset, offset + limit),
+				total: attention.length,
+				...offset + limit < attention.length ? { nextOffset: offset + limit } : {}
+			};
+		},
 		snapshot: () => [...sessions.values()].map(present),
 		session: (sessionId) => {
 			const session = sessions.get(sessionId);
 			return session === void 0 ? void 0 : present(session);
 		},
 		setPendingSessionSetups(sessionId, pending) {
-			if (JSON.stringify(pendingSetups.get(sessionId) ?? []) === JSON.stringify(pending)) return;
-			pendingSetups.set(sessionId, Object.freeze([...pending]));
 			const session = sessions.get(sessionId);
-			if (session) emit({
+			if (!session || JSON.stringify(pendingSetups.get(sessionId) ?? []) === JSON.stringify(pending)) return;
+			pendingSetups.set(sessionId, Object.freeze([...pending]));
+			emit({
 				kind: "upsert",
 				session: present(session)
 			});
@@ -817,8 +1005,18 @@ function createHeadlessHub(options) {
 				sessionId
 			});
 		},
-		mountFacets,
-		replaceFacets,
+		notifyDormantChanged(sessionId) {
+			emit({
+				kind: "dormant_changed",
+				sessionId
+			});
+		},
+		serveScope,
+		installPackages,
+		sessionParentScope: (workspaceId) => {
+			if (closed) return Promise.reject(/* @__PURE__ */ new Error("The headless hub is closed."));
+			return workspaceId === void 0 ? openGlobalScope() : openWorkspaceScope(workspaceId);
+		},
 		workspaces: () => [...workspaces.values()],
 		registerWorkspace(workspace) {
 			workspaces.set(workspace.id, workspace);
@@ -837,17 +1035,23 @@ function createHeadlessHub(options) {
 				scope: "workspace",
 				workspaceId: id
 			});
-			const mounted = mounts.get(key);
-			if (!workspaces.has(id)) return;
-			options.onWorkspaceRemoved?.(id);
-			workspaces.delete(id);
-			emit({
-				kind: "workspace_removed",
-				workspaceId: id
-			});
-			if (!mounted) return;
-			mounts.delete(key);
-			await disposeMount(mounted);
+			const served = scopeHosts.get(key);
+			scopeHosts.delete(key);
+			const scope = workspaceScopes.get(id);
+			workspaceScopes.delete(id);
+			if (workspaces.has(id)) {
+				options.onWorkspaceRemoved?.(id);
+				workspaces.delete(id);
+				emit({
+					kind: "workspace_removed",
+					workspaceId: id
+				});
+			}
+			try {
+				await (await scope)?.dispose();
+			} finally {
+				served?.host.dispose();
+			}
 		},
 		async requestApi(mount, basePath, request) {
 			if (closed) return Response.json({ error: "Server is closed." }, { status: 503 });
@@ -864,11 +1068,12 @@ function createHeadlessHub(options) {
 					body: request.body === null ? void 0 : new Uint8Array(await request.arrayBuffer())
 				});
 			}
-			const handler = mounts.get(mountKey(mount))?.host.handlerFor(basePath);
+			const handler = scopeHosts.get(mountKey(mount))?.scope.apiHandler(basePath);
 			if (!handler) return Response.json({ error: `API '${basePath}' is not mounted in ${mountKey(mount)}.` }, { status: 404 });
 			return handler.fetch(request);
 		},
 		pluginRegistry,
+		editPresence,
 		invokePlugin: (call, direction, caller) => pluginRegistry.invoke(call, direction, caller),
 		async create(sessionOptions) {
 			const id = sessionOptions.sessionId;
@@ -877,6 +1082,7 @@ function createHeadlessHub(options) {
 			if (sessionShutdowns.get(id)?.pending) throw new Error(`Session '${id}' is still shutting down.`);
 			const host = await options.manager.create(sessionOptions);
 			const settledAt = await lastSettledAt(host);
+			const groups = await storedGroups(host, options.onNotice);
 			const session = {
 				id: sessionOptions.sessionId,
 				workspaceId: sessionOptions.workspaceId,
@@ -892,6 +1098,7 @@ function createHeadlessHub(options) {
 					everPrompted: true,
 					lastSettledAt: settledAt
 				},
+				groups,
 				host
 			};
 			try {
@@ -935,15 +1142,7 @@ function createHeadlessHub(options) {
 			}
 			return frames;
 		},
-		threadJournal(sessionId, threadId) {
-			const session = sessions.get(sessionId);
-			if (session === void 0) return void 0;
-			const scope = scopeOf(session);
-			for (const { source } of selectedChannels(session)) {
-				const journal = source.threadJournal?.(scope, threadId);
-				if (journal !== void 0) return journal;
-			}
-		},
+		childThread: (sessionId, threadId) => sessions.get(sessionId)?.host.childThread?.(threadId),
 		receiveChannel(sessionId, frameType, payload, connectionId, desktopAuthorized = false, computerUseAuthorized = false) {
 			if (connectionId === "") return;
 			const session = sessions.get(sessionId);
@@ -969,20 +1168,8 @@ function createHeadlessHub(options) {
 			for (const cleanup of presentationCleanups.values()) cleanup();
 			presentationCleanups.clear();
 			const failures = [];
-			for (const mounted of [...mounts.values()].reverse()) {
-				try {
-					await mounted.installed.dispose();
-				} catch (error) {
-					failures.push(error);
-				}
-				try {
-					mounted.host.dispose();
-				} catch (error) {
-					failures.push(error);
-				}
-			}
-			mounts.clear();
 			pluginRegistry.dispose();
+			editPresence.clear();
 			workspaces.clear();
 			for (const { source } of channels.values()) source.close();
 			channels.clear();
@@ -995,6 +1182,18 @@ function createHeadlessHub(options) {
 			sessions.clear();
 			const outcomes = await Promise.allSettled(shutdowns);
 			for (const outcome of outcomes) if (outcome.status === "rejected") failures.push(outcome.reason);
+			try {
+				await (await globalScope)?.dispose();
+			} catch (error) {
+				failures.push(error);
+			}
+			for (const { host } of scopeHosts.values()) try {
+				host.dispose();
+			} catch (error) {
+				failures.push(error);
+			}
+			scopeHosts.clear();
+			workspaceScopes.clear();
 			if (failures.length) throw new AggregateError(failures, "Mount shutdown failed");
 		}
 	};