@agimon-ai/po 0.0.0-alpha.0

package/dist/src/builders/server/runtime.cjs

@@ -0,0 +1,1428 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_index = require("../../composition/harnessState/index.cjs");
+const require_index$1 = require("../../composition/repository/index.cjs");
+const require_builders_cli_extensionAssembler_index = require("../../../builders/cli/extensionAssembler/index.cjs");
+const require_packageUrl = require("./packageUrl.cjs");
+const require_index$2 = require("../web/index.cjs");
+const require_index$3 = require("../native/index.cjs");
+const require_index$4 = require("../../composition/layerPackageInstaller/index.cjs");
+const require_sessionComposition = require("../cli/sessionComposition.cjs");
+const require_mcpAppBuild = require("./mcpAppBuild.cjs");
+const require_mcpBundle = require("./mcpBundle.cjs");
+const require_index$5 = require("../../composition/syncService/index.cjs");
+const require_backgroundSync = require("./backgroundSync.cjs");
+const require_harnessContext = require("../cli/harnessContext.cjs");
+const require_index$6 = require("../hooks/index.cjs");
+const require_computerUseBinding = require("./computerUseBinding.cjs");
+const require_defaultWorkspace = require("./defaultWorkspace.cjs");
+const require_idleRestart = require("./idleRestart.cjs");
+const require_index$7 = require("./index.cjs");
+const require_logSink = require("./logSink.cjs");
+const require_packageReloadCheck = require("./packageReloadCheck.cjs");
+const require_runtimeResources = require("./runtimeResources.cjs");
+const require_selectionStatus = require("./selectionStatus.cjs");
+const require_sessionArguments = require("./sessionArguments.cjs");
+const require_shutdown = require("./shutdown.cjs");
+const require_webTemplateDecision = require("./webTemplateDecision.cjs");
+const require_workspaceCheckout = require("./workspaceCheckout.cjs");
+let node_fs = require("node:fs");
+node_fs = require_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+let node_os = require("node:os");
+node_os = require_runtime.__toESM(node_os, 1);
+let _agimon_ai_po_config_config = require("@agimon-ai/po-config/config");
+let _agimon_ai_po_config_majorModes = require("@agimon-ai/po-config/majorModes");
+let _agimon_ai_po_config_profiles = require("@agimon-ai/po-config/profiles");
+let _agimon_ai_po_core_runtimeLogSinkTelemetry = require("@agimon-ai/po-core/runtimeLogSinkTelemetry");
+let _agimon_ai_po_core_piSettings = require("@agimon-ai/po-core/piSettings");
+let _agimon_ai_po_core_serverFacet = require("@agimon-ai/po-core/serverFacet");
+let node_crypto = require("node:crypto");
+node_crypto = require_runtime.__toESM(node_crypto, 1);
+let _agimon_ai_po_core_history = require("@agimon-ai/po-core/history");
+let _agimon_ai_po_core_backgroundWork = require("@agimon-ai/po-core/backgroundWork");
+let _agimon_ai_po_core_headlessHub = require("@agimon-ai/po-core/headlessHub");
+let _agimon_ai_po_core_headlessServer = require("@agimon-ai/po-core/headlessServer");
+let _agimon_ai_po_core_headlessSessionManager = require("@agimon-ai/po-core/headlessSessionManager");
+let _agimon_ai_po_core_mcpFacet = require("@agimon-ai/po-core/mcpFacet");
+let _agimon_ai_po_core_packageApi = require("@agimon-ai/po-core/packageApi");
+let _agimon_ai_po_core_packageApiServer = require("@agimon-ai/po-core/packageApiServer");
+let _agimon_ai_po_core_remoteRuntime = require("@agimon-ai/po-core/remoteRuntime");
+let _agimon_ai_po_core_serverTelemetry = require("@agimon-ai/po-core/serverTelemetry");
+let _agimon_ai_po_core_webCompositions = require("@agimon-ai/po-core/webCompositions");
+let _agimon_ai_po_minor_mode = require("@agimon-ai/po-minor-mode");
+let ws = require("ws");
+ws = require_runtime.__toESM(ws, 1);
+let _agimon_ai_po_config_harnessStore = require("@agimon-ai/po-config/harnessStore");
+let _agimon_ai_po_config_harnessState = require("@agimon-ai/po-config/harnessState");
+//#region src/builders/server/runtime.ts
+async function bounded(operation, label, notice) {
+	try {
+		await require_shutdown.withShutdownDeadline(() => operation, label);
+	} catch (error) {
+		notice(`${label} failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+async function runServerRuntime(options, runtime) {
+	const { cwd: baseCwd, environment: incomingEnvironment, notice, resolveHarnessOptions, signal, onExtensionCheck } = runtime;
+	const baseEnvironment = {
+		...incomingEnvironment,
+		LOG_SINK_INSTANCE: "global"
+	};
+	const executionBudget = (0, _agimon_ai_po_core_packageApi.createServerExecutionBudget)(baseEnvironment);
+	await require_logSink.ensureGlobalLogSink({
+		cwd: baseCwd,
+		env: baseEnvironment,
+		notice
+	}).catch((error) => notice(`Global log sink unavailable: ${error instanceof Error ? error.message : String(error)}`));
+	const telemetry = (0, _agimon_ai_po_core_serverTelemetry.createServerTelemetry)({
+		cwd: baseCwd,
+		env: baseEnvironment,
+		warn: notice
+	});
+	const homeDirectory = baseEnvironment.HOME ?? node_os.default.homedir();
+	/** Content-addressed import URLs for every Po package entry this server loads. */
+	const packageUrls = require_packageUrl.createPackageUrls();
+	/** URLs whose live import timed out or threw; skipped by every loader until the content changes. */
+	const poisonedUrls = /* @__PURE__ */ new Set();
+	/** Imports each content-addressed URL once, so a reload imports only what changed. */
+	const importLive = require_packageReloadCheck.createLiveModuleCache();
+	/** The package identities each mounted global and workspace scope last loaded. */
+	const reloadCheck = require_packageReloadCheck.createPackageReloadCheck();
+	/** The hook module descriptor from the root's live registry; sources load in place or from snapshots. */
+	const liveHookModules = (repoRoot) => require_index$6.writeLiveHookModules({
+		repoRoot,
+		homeDirectory,
+		directory: node_path.default.join((0, _agimon_ai_po_config_config.globalDoomConfigDirectory)(homeDirectory), "server", "hook-modules"),
+		artifactFor: (source) => packageUrls.pathFor(source),
+		onNotice: notice
+	});
+	const serverDirectory = node_path.default.join((0, _agimon_ai_po_core_piSettings.piAgentDirectory)(baseEnvironment), "server");
+	const requestReceipts = (0, _agimon_ai_po_core_history.createRequestReceipts)({ directory: node_path.default.join(serverDirectory, "request-receipts-v1") });
+	const activeMedia = /* @__PURE__ */ new Set();
+	const mediaArbitration = {
+		register(busy) {
+			activeMedia.add(busy);
+			return () => {
+				activeMedia.delete(busy);
+			};
+		},
+		available(busy) {
+			return activeMedia.has(busy) && [...activeMedia].every((other) => other === busy || !other());
+		}
+	};
+	const activePeerAgents = /* @__PURE__ */ new Map();
+	const peerAgents = {
+		register(sessionId, agent, hubToken) {
+			if (activePeerAgents.has(sessionId)) throw new Error(`Voice peer agent '${sessionId}' is already registered.`);
+			const entry = {
+				fetch: (request) => agent.fetch(request),
+				hubToken
+			};
+			activePeerAgents.set(sessionId, entry);
+			return () => {
+				if (activePeerAgents.get(sessionId) === entry) activePeerAgents.delete(sessionId);
+			};
+		},
+		get: (sessionId) => activePeerAgents.get(sessionId)
+	};
+	const workspaces = (0, _agimon_ai_po_core_history.createWorkspaceRegistry)({
+		directory: serverDirectory,
+		onNotice: notice
+	});
+	const openSessions = (0, _agimon_ai_po_core_history.createOpenSessionRegistry)({
+		directory: serverDirectory,
+		onNotice: notice
+	});
+	let lastBudgetSnapshot = "";
+	let nextEventLoopTick = performance.now() + 1e3;
+	const eventLoopMonitor = setInterval(() => {
+		const now = performance.now();
+		const budget = executionBudget.getSnapshot();
+		const snapshot = JSON.stringify(budget);
+		if (snapshot !== lastBudgetSnapshot) {
+			lastBudgetSnapshot = snapshot;
+			telemetry.recordEvent("po_server.execution_budget", {
+				host_pid: process.pid,
+				running_jobs: budget.running,
+				queued_jobs: budget.queued,
+				limit: budget.limit
+			}).catch((error) => notice(`execution budget telemetry failed: ${String(error)}`));
+		}
+		const delay = Math.max(0, now - nextEventLoopTick);
+		nextEventLoopTick = now + 1e3;
+		if (delay >= 100) telemetry.recordEvent("po_server.event_loop_delay", { duration_ms: Math.round(delay) }).catch((error) => notice(`event loop telemetry failed: ${String(error)}`));
+	}, 1e3);
+	eventLoopMonitor.unref();
+	const harnessTelemetry = (0, _agimon_ai_po_core_runtimeLogSinkTelemetry.createHarnessTelemetry)({
+		cwd: baseCwd,
+		env: baseEnvironment,
+		warn: notice,
+		deferSpans: true
+	});
+	const baseSessionManager = (0, _agimon_ai_po_core_headlessSessionManager.createHeadlessSessionManager)({
+		publishSelectionStatus: require_selectionStatus.publishHeadlessSelectionStatus,
+		contextGroups: (context) => ((0, _agimon_ai_po_minor_mode.readMinorModeCatalog)(context)?.list() ?? []).filter(({ state }) => state.activation === "active").map(({ descriptor }) => ({
+			id: descriptor.id,
+			label: descriptor.label,
+			kind: "minor"
+		}))
+	});
+	/** The server's environment rooted at one configuration root, with no harness state of its own. */
+	const rootEnvironment = (root) => {
+		const environment = {
+			...baseEnvironment,
+			PO_ROOT: root
+		};
+		for (const key of [_agimon_ai_po_config_harnessStore.HARNESS_STATE_POINTER, ...Object.values(_agimon_ai_po_config_harnessState.HARNESS_STATE_KEYS)]) delete environment[key];
+		return environment;
+	};
+	const pendingSessions = /* @__PURE__ */ new Map();
+	/** The last harness context built to report each repository's MCP projection, kept while it is current. */
+	const repositoryContexts = /* @__PURE__ */ new Map();
+	const sessionArtifacts = /* @__PURE__ */ new Map();
+	/** Each host's facet root, where its session services (background work included) live. */
+	const sessionServiceRoots = /* @__PURE__ */ new WeakMap();
+	let mountSessionApis;
+	/**
+	* Shutdown runs every session through the same close path a user-initiated
+	* close uses, so without this the registry would be emptied by the very event
+	* it exists to survive.
+	*/
+	let shuttingDown = false;
+	const closeManagedSession = async (sessionId, options) => {
+		if (!shuttingDown && options?.keepDormant !== true) openSessions.remove(sessionId);
+		const artifacts = sessionArtifacts.get(sessionId);
+		sessionArtifacts.delete(sessionId);
+		webCompositions?.remove({
+			scope: "session",
+			sessionId
+		});
+		webCompositions?.removeNative({
+			scope: "session",
+			sessionId
+		});
+		const failures = [];
+		try {
+			await require_shutdown.withShutdownDeadline(() => baseSessionManager.closeSession(sessionId), `Session '${sessionId}' runtime shutdown`);
+		} catch (error) {
+			failures.push(error);
+		}
+		try {
+			await require_shutdown.withShutdownDeadline(() => artifacts?.apis.close(), `Session '${sessionId}' API shutdown`);
+		} catch (error) {
+			failures.push(error);
+		}
+		try {
+			await require_shutdown.withShutdownDeadline(() => artifacts?.cleanup(), `Session '${sessionId}' artifact cleanup`);
+		} catch (error) {
+			failures.push(error);
+		}
+		if (failures.length > 0) throw new AggregateError(failures, `Session '${sessionId}' shutdown failed`);
+	};
+	const sessionManager = {
+		async create(sessionOptions) {
+			const setup = pendingSessions.get(sessionOptions.sessionId);
+			let host;
+			try {
+				host = await baseSessionManager.create(sessionOptions);
+			} catch (error) {
+				if (setup !== void 0 && pendingSessions.delete(sessionOptions.sessionId)) await setup.cleanup().catch((cleanupError) => notice(String(cleanupError)));
+				throw error;
+			}
+			if (setup === void 0 || mountSessionApis === void 0) return host;
+			try {
+				const apis = await mountSessionApis(sessionOptions, host);
+				pendingSessions.delete(sessionOptions.sessionId);
+				sessionArtifacts.set(sessionOptions.sessionId, {
+					...setup,
+					apis
+				});
+				return host;
+			} catch (error) {
+				pendingSessions.delete(sessionOptions.sessionId);
+				await baseSessionManager.closeSession(sessionOptions.sessionId).catch((closeError) => notice(String(closeError)));
+				await setup.cleanup().catch((cleanupError) => notice(String(cleanupError)));
+				throw error;
+			}
+		},
+		get: (sessionId) => baseSessionManager.get(sessionId),
+		sessions: () => baseSessionManager.sessions(),
+		closeSession: closeManagedSession,
+		async close() {
+			const ids = baseSessionManager.sessions().map((session) => session.runtime.sessionId);
+			const failures = (await Promise.allSettled(ids.map((id) => closeManagedSession(id)))).filter((outcome) => outcome.status === "rejected").map((outcome) => outcome.reason);
+			if (failures.length > 0) throw new AggregateError(failures, "Headless session shutdown failed");
+		}
+	};
+	let requestSessionApi = async () => Response.json({ error: "Session API unavailable." }, { status: 404 });
+	let openSession = async () => {
+		throw new Error("The cockpit session service is not ready.");
+	};
+	let admitWorkspace = async () => {
+		throw new Error("Workspace admission is not ready.");
+	};
+	let remoteRuntime;
+	const computerUse = await require_computerUseBinding.createComputerUseBinding(process, {
+		isDeviceAuthorized: (id) => remoteRuntime?.remote.isDeviceAuthorized(id) === true,
+		stepUpRequired: () => remoteRuntime?.remote.stepUpRequired("computer-use.activate") === true
+	});
+	let hub;
+	hub = (0, _agimon_ai_po_core_headlessHub.createHeadlessHub)({
+		manager: sessionManager,
+		resolveProfileIdentity: (root, profile) => {
+			const identity = (0, _agimon_ai_po_config_profiles.resolveProfile)(root, profile, homeDirectory).identity;
+			return identity === void 0 ? void 0 : {
+				displayName: identity.name,
+				icon: identity.icon
+			};
+		},
+		admitWorkspace: async ({ root, name }) => admitWorkspace(root === void 0 || root.trim() === "" ? await require_defaultWorkspace.createDefaultWorkspaceFolder(name ?? "", homeDirectory) : root, name),
+		onWorkspaceRemoved: (workspaceId) => {
+			workspaces.remove(workspaceId);
+			reloadCheck.forget(`workspace:${workspaceId}`);
+			webCompositions?.remove({
+				scope: "workspace",
+				workspaceId
+			});
+			webCompositions?.removeNative({
+				scope: "workspace",
+				workspaceId
+			});
+		},
+		createSession: async (request, placement) => {
+			if (placement === void 0) return openSession(request);
+			if (require_workspaceCheckout.checkoutWorkspaceId(workspaces.list(), request.cwd) !== placement.workspaceId) throw new Error("The session directory is outside this workspace.");
+			return openSession(request, void 0, placement.workspaceId);
+		},
+		sessionReservations: {
+			read(id, parentSessionId) {
+				if (!cockpit) throw new Error("Session setup is not ready.");
+				return cockpit.sessionReservations.read(id, parentSessionId);
+			},
+			async prepare(id, parentSessionId, cwd) {
+				if (!cockpit) throw new Error("Session setup is not ready.");
+				return cockpit.sessionReservations.prepare(id, parentSessionId, cwd);
+			},
+			async complete(id, parentSessionId) {
+				if (!cockpit) throw new Error("Session setup is not ready.");
+				return cockpit.sessionReservations.complete(id, parentSessionId);
+			}
+		},
+		onNotice: notice,
+		hubToken: () => attachToken,
+		requestSessionApi: (scope, request) => requestSessionApi(scope, request),
+		...computerUse === void 0 ? {} : { computerUse }
+	});
+	/** Started by the idle restart once the server is serving; until then a restart waits. */
+	let requestRestart;
+	const idleRestart = require_idleRestart.createIdleRestart({
+		...require_idleRestart.testIdleRestartOverrides(baseEnvironment),
+		busy: async () => {
+			const hosts = sessionManager.sessions();
+			if (hosts.some((host) => {
+				const root = sessionServiceRoots.get(host);
+				const service = root === void 0 ? void 0 : (0, _agimon_ai_po_core_backgroundWork.readDoomBackgroundWorkService)(root);
+				return service !== void 0 && require_idleRestart.holdsRestart(service.snapshot());
+			})) return true;
+			return (await Promise.all(hosts.map((host) => host.runtime.readState()))).some((state) => state.isStreaming || state.isCompacting);
+		},
+		restart: () => requestRestart?.(),
+		onError: (error) => notice(`Idle restart check failed: ${error instanceof Error ? error.message : String(error)}`)
+	});
+	const stopIdleRestartPoke = hub.onEvent(() => idleRestart.poke());
+	const stopPersistSessionNames = hub.onEvent((event) => {
+		if (event.kind !== "upsert") return;
+		const record = openSessions.list().find((entry) => entry.sessionId === event.session.id);
+		if (record === void 0 || record.name === event.session.name) return;
+		openSessions.add({
+			...record,
+			name: event.session.name
+		});
+	});
+	let harnessContext;
+	let launchWorkspaceId;
+	let cockpit;
+	let attachToken;
+	let webCompositions;
+	const stopResourceMonitor = require_runtimeResources.monitorRuntimeResources({
+		record: (attributes) => telemetry.recordEvent("po_server.resources", attributes),
+		counts: () => {
+			const budget = executionBudget.getSnapshot();
+			return {
+				sessions: sessionManager.sessions().length,
+				running_jobs: budget.running,
+				queued_jobs: budget.queued,
+				job_limit: budget.limit
+			};
+		},
+		warn: notice
+	});
+	try {
+		await telemetry.runInSpan("po_server.startup", {}, async () => {
+			const token = node_fs.default.readFileSync(options.tokenFile, "utf8").trim();
+			if (!token) throw new Error("The attach token file is empty.");
+			attachToken = token;
+			const resolved = require_sessionArguments.resolveSessionIdentity(options.agentArgs, {
+				sessionId: options.sessionId ?? node_crypto.default.randomUUID(),
+				sessionName: options.sessionName
+			});
+			const globalRoot = (0, _agimon_ai_po_config_config.globalDoomConfigDirectory)(homeDirectory);
+			webCompositions = (0, _agimon_ai_po_core_webCompositions.createWebCompositions)(node_path.default.join(globalRoot, "server"), notice);
+			/** Assigned once every scope can be checked; a sync that exits sooner is picked up then. */
+			let pickUpSync = async () => void 0;
+			const backgroundSync = require_backgroundSync.createBackgroundSync({
+				environment: baseEnvironment,
+				onNotice: notice,
+				onExit: () => pickUpSync()
+			});
+			const syncCheckpoints = require_backgroundSync.createSyncCheckpoints({
+				globalRoot,
+				homeDirectory,
+				environment: baseEnvironment,
+				background: backgroundSync,
+				onNotice: notice
+			});
+			/**
+			* Every composition the root's config can select, one per major mode, resolved live
+			* from the root. A package sync has not prepared yet is left out with a diagnostic, so
+			* the root opens without it; the server never installs or builds.
+			*/
+			const liveCompositions = (root) => require_sessionComposition.rootCompositions({
+				root,
+				homeDirectory,
+				environment: baseEnvironment,
+				tolerateUnsynced: true
+			});
+			/** The root's server facet entries, each with the URL its current package content imports from. */
+			const facetEntries = async (root) => {
+				const entries = [];
+				for (const { declaration, module, owners } of require_index$7.serverFacetCandidates(liveCompositions(root))) entries.push({
+					packageName: declaration.packageName,
+					entry: declaration.entry,
+					module,
+					url: await packageUrls.urlFor(module),
+					scopes: declaration.scopes,
+					owners,
+					required: declaration.required === true
+				});
+				return entries;
+			};
+			/** Every package root the root's config can select, over all its major modes. */
+			const scopePackageRoots = (root) => require_index$2.compositionPackageRoots(liveCompositions(root));
+			/** What the root opened without: packages that do not resolve yet and web plugins with no slot. */
+			const unsyncedOf = (root) => {
+				try {
+					const compositions = liveCompositions(root);
+					const unslotted = webBuild === void 0 ? [] : require_index$2.unslottedWebPackages(webBuild, require_index$2.compositionPackageRoots(compositions));
+					return [.../* @__PURE__ */ new Set([...require_builders_cli_extensionAssembler_index.unsyncedSelectors(compositions), ...unslotted])];
+				} catch (error) {
+					notice(`'${root}' sync state could not be read: ${error instanceof Error ? error.message : String(error)}`);
+					return [];
+				}
+			};
+			const workspaceLabel = (root, name) => `Workspace '${name ?? node_path.default.basename(root)}'`;
+			/** A checkpoint: request a background sync when the root changed since the last one, and warn. */
+			const syncCheckpoint = (root, label, request = true) => syncCheckpoints.check({
+				root,
+				label,
+				unsynced: unsyncedOf(root)
+			}, request);
+			let webBuild;
+			/** Publishes one mount out of the current global build, naming only the plugin slots its root resolves. */
+			const publishWebMount = (mount, root) => webBuild === void 0 ? void 0 : webCompositions?.publish(mount, webBuild, hub.channelTypes(), require_index$2.mountWebPluginSlots(webBuild, scopePackageRoots(root)));
+			let nativeBuild;
+			/** Publishes one mount's native composition out of the current global native build. */
+			const publishNativeMount = (mount, root) => nativeBuild === void 0 ? void 0 : webCompositions?.publishNative(mount, nativeBuild, hub.channelTypes(), require_index$3.mountNativePluginIds(nativeBuild, scopePackageRoots(root)));
+			const pickUpWebBuild = require_backgroundSync.createKeyedPickup((key) => require_index$2.readGlobalWebBuildRecord(globalRoot, key), (build, key) => {
+				notice(`Publishing global web build ${key}.`);
+				webBuild = build;
+				webCompositions?.publishShell(build);
+			});
+			const pickUpNativeBuild = require_backgroundSync.createKeyedPickup((key) => require_index$3.readGlobalNativeBuildRecord(globalRoot, key), (build, key) => {
+				notice(`Publishing global native build ${key}.`);
+				nativeBuild = build;
+			});
+			/** The keys these roots derive the way sync does, each only when its build exists. */
+			const ownBuildKeys = () => {
+				const pluginRoots = require_index$5.globalWebPluginRoots(globalRoot, homeDirectory, baseEnvironment, notice);
+				const web = require_index$2.readGlobalWebBuildStatus({
+					poHome: globalRoot,
+					pluginRoots,
+					environment: baseEnvironment
+				});
+				const native = require_index$3.readGlobalNativeBuildStatus({
+					poHome: globalRoot,
+					pluginRoots
+				});
+				return {
+					...web.status === "current" ? { webKey: web.key } : {},
+					...native.status === "current" ? { nativeKey: native.key } : {}
+				};
+			};
+			const currentBuildKeys = () => {
+				const pointer = require_index$5.readSyncPointer(globalRoot);
+				return require_backgroundSync.syncedBuildKeys({
+					pointer,
+					ownsPointer: syncCheckpoints.ownsPointer(pointer),
+					published: {
+						web: webBuild !== void 0,
+						native: nativeBuild !== void 0
+					},
+					ownKeys: ownBuildKeys,
+					newestWebKey: () => require_index$2.newestGlobalWebBuildKey(globalRoot)
+				});
+			};
+			/**
+			* Read-only: picks up the global web and native builds sync's pointer names, publishing
+			* the shell only when a key changed, then republishes every shared mount. Never builds;
+			* a missing build leaves the previous one serving. Clients pick a new composition up at
+			* their next refreshWebPluginCompositions.
+			*/
+			const refreshWebBuild = () => {
+				const keys = currentBuildKeys();
+				if (pickUpNativeBuild(keys.nativeKey) === "missing") notice(`The global native build ${String(keys.nativeKey)} is missing; run po sync.`);
+				if (pickUpWebBuild(keys.webKey) === "missing") notice(`The global web build ${String(keys.webKey)} is missing; run po sync.`);
+				const mounts = hub.workspaces().filter((workspace) => workspace.available !== false).map((workspace) => ({
+					root: workspace.root,
+					mount: {
+						scope: "workspace",
+						workspaceId: workspace.id
+					}
+				}));
+				for (const publish of [publishNativeMount, publishWebMount]) {
+					publish({ scope: "global" }, globalRoot);
+					for (const { root, mount } of mounts) publish(mount, root);
+				}
+			};
+			const defaultSelection = (root) => {
+				const config = (0, _agimon_ai_po_config_majorModes.loadMajorModesConfig)(root, homeDirectory, baseEnvironment);
+				const majorMode = config.defaultMajorMode;
+				return {
+					root,
+					majorMode,
+					activeLayers: (0, _agimon_ai_po_config_majorModes.resolveLayers)(config, majorMode)
+				};
+			};
+			const loadComposition = async (root, scope, selection) => {
+				const selected = selection ?? defaultSelection(root);
+				return telemetry.runInSpan("po_server.composition_load", { scope }, async () => (0, _agimon_ai_po_core_serverFacet.loadServerFacets)(scope, {
+					entries: await facetEntries(root),
+					majorMode: selected.majorMode,
+					activeLayers: selected.activeLayers,
+					retainCandidates: scope === "session",
+					onNotice: notice,
+					poisoned: poisonedUrls,
+					importer: importLive
+				}));
+			};
+			const scopeKey = (mount) => mount.scope === "global" ? "global" : `workspace:${mount.workspaceId}`;
+			/**
+			* What a global or workspace scope loads: one identity per facet entry in that scope.
+			* The URL changes with package content; `selection` carries ownership and the root's
+			* default mode, so a modes.yaml change that moves a facet in or out remounts too.
+			*/
+			const scopeIdentities = (root, scope, entries) => {
+				const { majorMode, activeLayers } = defaultSelection(root);
+				return entries.filter((entry) => entry.scopes.includes(scope)).map((entry) => ({
+					module: entry.module,
+					url: entry.url,
+					selection: JSON.stringify([
+						entry.owners,
+						entry.required === true,
+						majorMode,
+						activeLayers
+					])
+				}));
+			};
+			const scopeChecks = /* @__PURE__ */ new Map();
+			/**
+			* The reload check for one mounted global or workspace scope: recompute its package
+			* URLs and, only when they changed, load the new set and swap it in with
+			* `replaceFacets`. Unchanged URLs come from the module cache, so only changed packages
+			* import. A scope this server has not mounted yet is left to its admission. Checks of
+			* one scope run one at a time; a failure restores the previous facets (the hub reports a
+			* failed restore) and retries next time.
+			*
+			* ponytail: no fs.watch. A rebuilt local package takes effect at the next session or
+			* admission. Watch the declared entries (see packageUrl's declaredTargets) and call this
+			* when workspace routes must update without opening a session.
+			*/
+			const checkScope = (root, mount) => {
+				const key = scopeKey(mount);
+				const settled = (scopeChecks.get(key) ?? Promise.resolve()).then(async () => {
+					try {
+						refreshWebBuild();
+					} catch (error) {
+						notice(`Web build check failed: ${error instanceof Error ? error.message : String(error)}`);
+					}
+					const change = reloadCheck.diff(key, scopeIdentities(root, mount.scope, await facetEntries(root)));
+					if (change.first || change.changed.length === 0 && change.reselected.length === 0 && change.removed.length === 0) return;
+					const bundle = await loadComposition(root, mount.scope);
+					await hub.replaceFacets(mount, bundle.facets);
+					reloadCheck.commit(key, scopeIdentities(root, mount.scope, bundle.entries));
+					idleRestart.supersede(change.superseded);
+					publishWebMount(mount, root);
+					publishNativeMount(mount, root);
+					notice(`Reloaded ${mount.scope === "global" ? "global" : `workspace '${mount.workspaceId}'`} facets (${String(change.changed.length)} changed, ${String(change.removed.length)} removed).`);
+				}).catch((error) => notice(`Extension check of ${key} failed and retries at the next check: ${error instanceof Error ? error.message : String(error)}`));
+				scopeChecks.set(key, settled);
+				settled.then(() => {
+					if (scopeChecks.get(key) === settled) scopeChecks.delete(key);
+				});
+				return settled;
+			};
+			const loadSessionMcp = async (root, selection) => {
+				return telemetry.runInSpan("po_server.mcp_bundle_load", {}, async () => {
+					const entries = [];
+					const candidates = require_mcpBundle.mcpPluginCandidates(liveCompositions(root));
+					for (const { declaration, module, owners } of candidates) entries.push({
+						packageName: declaration.packageName,
+						...declaration.ui === void 0 ? {} : { widgets: declaration.ui.widgets },
+						entry: declaration.entry,
+						module,
+						url: await packageUrls.urlFor(module),
+						owners
+					});
+					let app;
+					try {
+						app = require_mcpAppBuild.readMcpAppBuild({
+							poHome: globalRoot,
+							candidates
+						});
+					} catch (error) {
+						notice(`The MCP app build could not be read: ${error instanceof Error ? error.message : String(error)}`);
+					}
+					if (app !== void 0 && app.build === void 0) {
+						notice(`MCP app build ${app.key} is not synced yet; this session runs without MCP widgets.`);
+						syncCheckpoints.requestMissing(`mcp-app:${app.key}`, "the MCP app build is missing");
+					}
+					const built = app?.build;
+					return (0, _agimon_ai_po_core_mcpFacet.loadMcpPlugins)({
+						entries,
+						...built === void 0 ? {} : { uiResource: (0, _agimon_ai_po_core_mcpFacet.mcpUiResource)(built.html, built.sha256) },
+						majorMode: selection.majorMode,
+						activeLayers: selection.activeLayers,
+						retainCandidates: true,
+						onNotice: notice,
+						poisoned: poisonedUrls,
+						importer: importLive
+					});
+				});
+			};
+			const sharedApiContext = {
+				homeDirectory,
+				environment: baseEnvironment,
+				hubToken: token,
+				sessionService: hub.sessionService,
+				mediaArbitration,
+				executionBudget,
+				peerAgents,
+				directEvents: hub.directEvents,
+				requestApi: (mount, basePath, request) => hub.requestApi(mount, basePath, request),
+				repositories: () => hub.workspaces().map((workspace) => ({
+					id: workspace.id,
+					path: workspace.root,
+					name: workspace.root.split("/").at(-1) ?? workspace.id,
+					active: hub.snapshot().some((session) => session.workspaceId === workspace.id)
+				})),
+				resolveRepository: (id) => hub.workspaces().find((workspace) => workspace.id === id)?.root,
+				/**
+				* Package readiness and the MCP projection, resolved live from the repository. The
+				* context stays until the next read replaces it: the projection names its staged files.
+				*/
+				readRepositorySync: async (id) => {
+					const root = hub.workspaces().find((workspace) => workspace.id === id)?.root;
+					if (!root) return void 0;
+					const environment = rootEnvironment(root);
+					const config = (0, _agimon_ai_po_config_majorModes.loadMajorModesConfig)(root, homeDirectory, environment);
+					const missing = require_index$4.missingLayerPackageSpecifiers(config, Object.keys(config.layers), require_builders_cli_extensionAssembler_index.createLayerResolvers(root, environment));
+					const context = await require_harnessContext.buildHarnessContext(resolveHarnessOptions({
+						args: ["--cwd", root],
+						cwd: root,
+						environment
+					}));
+					const previous = repositoryContexts.get(root);
+					repositoryContexts.set(root, context);
+					await previous?.cleanup().catch((error) => notice(String(error)));
+					const status = syncCheckpoint(root, workspaceLabel(root, hub.workspaces().find((workspace) => workspace.id === id)?.name), false);
+					return {
+						fresh: missing.length === 0 && status.reasons.length === 0,
+						reasons: [...missing.map((specifier) => `configured package is not installed: ${specifier}`), ...status.reasons],
+						syncing: status.syncing,
+						mcpProjection: context.resources.mcpProjection
+					};
+				},
+				onNotice: notice
+			};
+			node_fs.default.mkdirSync(globalRoot, {
+				recursive: true,
+				mode: 448
+			});
+			const globalBundle = await loadComposition(globalRoot, "global");
+			remoteRuntime = (0, _agimon_ai_po_core_remoteRuntime.createRemoteRuntime)({
+				homeDirectory,
+				registrationToken: token,
+				onDeviceDropped: (id) => computerUse?.revokeDevice?.(id),
+				reservedPorts: () => [options.webPort],
+				bundleTrust: () => webCompositions?.shellTrust(),
+				attestHost: (fields) => webCompositions?.attestHost(fields),
+				onNotice: notice,
+				forward: async (request) => {
+					if (!cockpit || !attachToken) return Response.json({ error: "The headless server is not ready." }, { status: 503 });
+					const from = new URL(request.url);
+					const headers = new Headers(request.headers);
+					headers.set("x-po-token", attachToken);
+					return fetch(new URL(`${from.pathname}${from.search}`, cockpit.url), new Request(request, {
+						headers,
+						redirect: "manual"
+					}));
+				},
+				connectProtocol: (pathname, deviceId) => {
+					if (!cockpit || !attachToken) throw new Error("The headless protocol listener is not ready.");
+					const url = new URL(pathname, cockpit.url);
+					url.protocol = "ws:";
+					return new ws.default(url, { headers: {
+						"x-po-token": attachToken,
+						...deviceId === void 0 ? {} : {
+							"x-po-api-caller-locality": "remote",
+							"x-po-api-caller-device-id": deviceId,
+							"x-po-api-caller-step-up": "not-required"
+						}
+					} });
+				}
+			});
+			await hub.mountFacets(globalBundle.facets, {
+				...sharedApiContext,
+				scope: "global",
+				requestReceipts: requestReceipts.receipts,
+				remoteControl: { fetch: (request) => remoteRuntime.fetchLocal(request) }
+			});
+			reloadCheck.commit("global", scopeIdentities(globalRoot, "global", globalBundle.entries));
+			refreshWebBuild();
+			syncCheckpoint(globalRoot, "The global scope");
+			if (!backgroundSync.syncing) backgroundSync.request("server start");
+			const admissions = /* @__PURE__ */ new Map();
+			const isMemberCheckout = (from, workspace) => node_fs.default.realpathSync(require_index$1.findRepositoryRoot(from)) !== workspace.root;
+			admitWorkspace = async (from, requestedName) => {
+				const checkoutRoot = node_fs.default.realpathSync(require_index$1.findRepositoryRoot(from));
+				const { id, root, moved } = (0, _agimon_ai_po_core_history.identifyWorkspace)({
+					records: workspaces.list(),
+					checkoutRoot,
+					marker: (0, _agimon_ai_po_core_history.readWorkspaceMarker)(checkoutRoot)
+				});
+				const record = workspaces.list().find((workspace) => workspace.id === id);
+				const name = requestedName?.trim() || record?.name;
+				const named = name === void 0 ? {} : { name };
+				const renamed = record !== void 0 && name !== record.name;
+				const existing = hub.workspaces().find((workspace) => workspace.id === id);
+				if (existing !== void 0 && existing.available !== false && existing.root === root) {
+					await checkScope(root, {
+						scope: "workspace",
+						workspaceId: id
+					});
+					syncCheckpoint(root, workspaceLabel(root, name));
+					if (renamed) {
+						workspaces.add({
+							id,
+							root,
+							...named
+						});
+						hub.registerWorkspace({
+							...existing,
+							...named,
+							available: true
+						});
+					}
+					return {
+						...existing,
+						...named,
+						available: true
+					};
+				}
+				const pending = admissions.get(id);
+				if (pending) return pending;
+				const wasRemembered = record !== void 0;
+				if (!wasRemembered || moved || renamed) workspaces.add({
+					id,
+					root,
+					...named
+				});
+				if (moved) notice(`Workspace '${id}' moved to '${root}'.`);
+				hub.registerWorkspace({
+					id,
+					root,
+					...named,
+					available: false
+				});
+				const admission = (async () => {
+					const bundle = await loadComposition(root, "workspace");
+					await hub.mountFacets(bundle.facets, {
+						...sharedApiContext,
+						scope: "workspace",
+						workspaceId: id,
+						workspaceRoot: root,
+						cwd: root,
+						resolveRepository: (requestedId) => requestedId === id ? root : void 0
+					});
+					reloadCheck.commit(`workspace:${id}`, scopeIdentities(root, "workspace", bundle.entries));
+					try {
+						refreshWebBuild();
+						publishWebMount({
+							scope: "workspace",
+							workspaceId: id
+						}, root);
+						publishNativeMount({
+							scope: "workspace",
+							workspaceId: id
+						}, root);
+					} catch (error) {
+						notice(`Workspace '${id}' web build check failed: ${error instanceof Error ? error.message : String(error)}`);
+					}
+					syncCheckpoint(root, workspaceLabel(root, name));
+					try {
+						if ((0, _agimon_ai_po_core_history.readWorkspaceMarker)(root) === void 0) (0, _agimon_ai_po_core_history.writeWorkspaceMarker)(root, id);
+					} catch (error) {
+						notice(`Workspace '${root}' id could not be recorded in its git data: ${error instanceof Error ? error.message : String(error)}`);
+					}
+					return {
+						id,
+						root,
+						...named,
+						available: true
+					};
+				})();
+				admissions.set(id, admission);
+				try {
+					return await admission;
+				} catch (error) {
+					if (!wasRemembered) {
+						await hub.removeWorkspace(id);
+						workspaces.remove(id);
+					}
+					throw error;
+				} finally {
+					admissions.delete(id);
+				}
+			};
+			for (const record of openSessions.list()) {
+				if (workspaces.list().some((workspace) => workspace.id === record.workspaceId)) continue;
+				try {
+					const candidate = record.groupingRoot ?? record.cwd;
+					const root = node_fs.default.realpathSync(require_index$1.findRepositoryRoot(candidate));
+					if ((record.groupingRoot === void 0 || root === candidate) && !workspaces.list().some((workspace) => workspace.root === root)) workspaces.add({
+						id: record.workspaceId,
+						root
+					});
+					else notice(`Session '${record.sessionId}' no longer resolves to its recorded workspace; skipping registration.`);
+				} catch (error) {
+					notice(`Session '${record.sessionId}' workspace could not be registered: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			}
+			for (const workspace of workspaces.list()) {
+				hub.registerWorkspace({
+					...workspace,
+					available: false
+				});
+				try {
+					if (node_fs.default.realpathSync(require_index$1.findRepositoryRoot(workspace.root)) !== workspace.root) {
+						notice(`Workspace '${workspace.root}' no longer resolves to its recorded identity; leaving it unavailable.`);
+						continue;
+					}
+					await admitWorkspace(workspace.root);
+				} catch (error) {
+					notice(`Workspace '${workspace.root}' could not be restored: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			}
+			const sessionDescriptors = /* @__PURE__ */ new WeakMap();
+			const sessionHookModules = (context, sourceRoot) => {
+				let descriptor = sessionDescriptors.get(context);
+				if (descriptor === void 0) {
+					descriptor = context.options.hooks ? liveHookModules(sourceRoot).then((admitted) => require_index$6.checkoutHookDescriptor(admitted, sourceRoot, context.options.repoRoot, context.resources.temporaryDirectory)) : Promise.resolve(void 0);
+					sessionDescriptors.set(context, descriptor);
+				}
+				return descriptor;
+			};
+			const sessionHostOptions = (context, bundle, mcpBundle, identity, workspace, explicit = { pinned: [] }) => {
+				const policyOptions = context.options;
+				const sessionSelection = {
+					root: policyOptions.repoRoot,
+					majorMode: policyOptions.majorMode,
+					activeLayers: context.selectedLayers,
+					domains: policyOptions.domains,
+					profile: context.profile,
+					state: { "minor-mode": [...explicit.minorModes ?? []] }
+				};
+				const sessionEnvironment = context.environment;
+				require_index.updateHarnessState({ compositionFingerprint: require_builders_cli_extensionAssembler_index.resolveExtensionComposition({
+					majorMode: policyOptions.majorMode,
+					layers: [...context.selectedLayers],
+					majorModesConfig: (0, _agimon_ai_po_config_majorModes.loadMajorModesConfig)(policyOptions.repoRoot, homeDirectory, sessionEnvironment),
+					resolvers: require_builders_cli_extensionAssembler_index.createLayerResolvers(policyOptions.repoRoot, sessionEnvironment),
+					tolerateUnsynced: true
+				}).fingerprint }, sessionEnvironment);
+				return {
+					cwd: policyOptions.cwd,
+					repoRoot: policyOptions.repoRoot,
+					sessionId: identity.sessionId,
+					workspaceId: workspace.id,
+					groupingRoot: workspace.root,
+					sessionName: identity.sessionName,
+					...explicit.initialFastMode === void 0 ? {} : { initialFastMode: explicit.initialFastMode },
+					...explicit.initialAgentLocked === void 0 ? {} : { initialAgentLocked: explicit.initialAgentLocked },
+					webComposition: publishWebMount({
+						scope: "session",
+						sessionId: identity.sessionId
+					}, workspace.root),
+					nativeComposition: publishNativeMount({
+						scope: "session",
+						sessionId: identity.sessionId
+					}, workspace.root),
+					...identity.parentSessionId === void 0 ? {} : { parentSessionId: identity.parentSessionId },
+					...identity.sessionProvenance === void 0 ? {} : { sessionProvenance: identity.sessionProvenance },
+					agentArgs: policyOptions.piArgs,
+					environment: Object.freeze({ ...context.environment }),
+					selection: sessionSelection,
+					...explicit.allowedTools === void 0 ? {} : { allowedTools: explicit.allowedTools },
+					selectionOverrides: [
+						"majorMode",
+						"domains",
+						"profile"
+					].filter((axis) => {
+						if (explicit.pinned.includes(axis)) return true;
+						const flag = axis === "majorMode" ? "--major-mode" : `--${axis}`;
+						return identity.sessionId === resolved.identity.sessionId && resolved.agentArgs.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+					}),
+					inheritedSelection: () => {
+						const environment = { ...baseEnvironment };
+						for (const key of [_agimon_ai_po_config_harnessStore.HARNESS_STATE_POINTER, ...Object.values(_agimon_ai_po_config_harnessState.HARNESS_STATE_KEYS)]) delete environment[key];
+						const defaults = resolveHarnessOptions({
+							args: ["--cwd", policyOptions.cwd],
+							cwd: policyOptions.cwd,
+							environment,
+							...policyOptions.configRoot === void 0 ? {} : { configRoot: policyOptions.configRoot }
+						});
+						return {
+							majorMode: defaults.majorMode,
+							domains: defaults.domains,
+							profile: defaults.profile
+						};
+					},
+					candidates: bundle.entries,
+					providerOverrides: () => (0, _agimon_ai_po_core_serverFacet.selectedServerProviderOverrides)(bundle.facets, sessionEnvironment),
+					requiredServerPackages: async () => {
+						const harness = (0, _agimon_ai_po_config_harnessStore.loadHarnessState)(sessionEnvironment).state;
+						if (!harness.hooks) return [];
+						return await require_index$6.validateHookModules({
+							repoRoot: policyOptions.repoRoot,
+							configRoot: policyOptions.configRoot,
+							homeDirectory,
+							hookGroups: harness.hookGroups,
+							descriptor: harness.hookModules,
+							isSubagent: Boolean(sessionEnvironment.PI_SUBAGENT_CHILD)
+						}) ? ["@agimon-ai/po-hook"] : [];
+					},
+					mcpPlugins: mcpBundle.plugins,
+					resolveSelection: (requested) => {
+						const config = (0, _agimon_ai_po_config_majorModes.loadMajorModesConfig)(policyOptions.configRoot ?? policyOptions.repoRoot, policyOptions.homeDirectory, policyOptions.environment ?? baseEnvironment);
+						return {
+							...requested,
+							activeLayers: (0, _agimon_ai_po_config_majorModes.filterHookDisabledLayers)(config, (0, _agimon_ai_po_config_majorModes.resolveLayers)(config, requested.majorMode), policyOptions.hooks)
+						};
+					},
+					telemetry,
+					onNotice: notice
+				};
+			};
+			mountSessionApis = (sessionOptions, host) => (0, _agimon_ai_po_core_packageApiServer.serveSessionApis)({
+				sessionId: sessionOptions.sessionId,
+				cwd: sessionOptions.cwd,
+				environment: sessionOptions.environment,
+				directEvents: hub.directEvents,
+				requestApi: (mount, basePath, request) => hub.requestApi(mount, basePath, request),
+				publishActivity: (activity) => hub.setSessionActivity?.(sessionOptions.sessionId, activity),
+				shareFile: (filePath, label) => remoteRuntime === void 0 ? Promise.reject(new Error(_agimon_ai_po_core_packageApi.DOOM_SHARE_FILE_REMOTE_OFF_MESSAGE)) : remoteRuntime.fileShares.mint({
+					sessionId: sessionOptions.sessionId,
+					cwd: sessionOptions.cwd,
+					path: filePath,
+					label
+				}),
+				...computerUse === void 0 ? {} : { computerUse: {
+					get available() {
+						return computerUse.available;
+					},
+					get enabled() {
+						return computerUse.enabled === true;
+					},
+					authorize: (headers) => computerUse.authorizeSession?.(sessionOptions.sessionId, headers) === true || computerUse.authorize?.(headers) === true,
+					authorizeRecording: (headers) => computerUse.authorizeRecording?.(sessionOptions.sessionId, headers) === true,
+					authorizeActivation: (headers) => computerUse.authorizeActivation?.(headers) === true,
+					claim: (headers) => computerUse.claimSession?.(sessionOptions.sessionId, headers),
+					fetchRecording: (artifactId, range) => computerUse.readRecording?.({
+						sessionId: sessionOptions.sessionId,
+						cwd: sessionOptions.cwd
+					}, artifactId, range) ?? Promise.resolve(Response.json({ error: "Not found." }, { status: 404 })),
+					subscribe: (listener) => computerUse.subscribe?.(listener, sessionOptions.sessionId) ?? (() => void 0)
+				} },
+				hubToken: token,
+				sessionService: hub.sessionService,
+				mediaArbitration,
+				executionBudget,
+				peerAgents,
+				pluginRegistry: hub.pluginRegistry,
+				apis: [],
+				facets: pendingSessions.get(sessionOptions.sessionId)?.bundle.facets ?? [],
+				workspaceId: sessionOptions.workspaceId,
+				workspaceRoot: sessionOptions.repoRoot,
+				...host.sessionContext === void 0 ? {} : { sessionContext: host.sessionContext },
+				homeDirectory,
+				mountChannel: (channel) => {
+					return {
+						mounted: true,
+						dispose: hub.registerChannel(channel, {
+							scope: "session",
+							sessionId: sessionOptions.sessionId
+						})
+					};
+				},
+				prepareFacets: (root) => {
+					sessionServiceRoots.set(host, root);
+					host.prepareFacets(root);
+				},
+				activateFacets: host.activateFacets,
+				canDispatch: host.canDispatch,
+				telemetry,
+				onNotice: notice
+			});
+			requestSessionApi = async (scope, request) => {
+				const session = hub.session(scope.sessionId);
+				const artifacts = sessionArtifacts.get(scope.sessionId);
+				if (session === void 0 || session.cwd !== scope.cwd || artifacts === void 0) return Response.json({ error: "Session not found." }, { status: 404 });
+				if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(request.basePath)) return Response.json({ error: "Invalid session API base path." }, { status: 400 });
+				if (!request.path.startsWith("/") || request.path.startsWith("//") || request.path.includes("#")) return Response.json({ error: "Invalid session API path." }, { status: 400 });
+				const body = request.body === null || request.body === void 0 ? void 0 : request.body;
+				return artifacts.apis.request(new Request(`http://po.local/api/plugins/${request.basePath}${request.path}`, {
+					method: request.method,
+					headers: request.headers,
+					...body === void 0 ? {} : { body },
+					...request.signal === void 0 ? {} : { signal: request.signal }
+				}));
+			};
+			if (!options.noSession) {
+				const initialOptions = resolveHarnessOptions({
+					args: resolved.agentArgs,
+					cwd: baseCwd,
+					environment: baseEnvironment
+				});
+				const initialWorkspace = await admitWorkspace(initialOptions.repoRoot);
+				launchWorkspaceId = initialWorkspace.id;
+				harnessContext = await require_harnessContext.buildHarnessContext(resolveHarnessOptions({
+					args: resolved.agentArgs,
+					cwd: baseCwd,
+					environment: baseEnvironment
+				}), harnessTelemetry);
+				const activeHarnessContext = harnessContext;
+				try {
+					const hookModules = await sessionHookModules(harnessContext, initialWorkspace.root);
+					require_index.updateHarnessState({ hookModules }, harnessContext.environment);
+					if (harnessContext.options.hooks) await require_index$6.validateHookModules({
+						repoRoot: harnessContext.options.repoRoot,
+						configRoot: initialWorkspace.root,
+						homeDirectory,
+						hookGroups: harnessContext.hookGroups,
+						descriptor: hookModules,
+						isSubagent: Boolean(baseEnvironment.PI_SUBAGENT_CHILD)
+					});
+					const initialBundle = await loadComposition(harnessContext.options.repoRoot, "session", {
+						root: harnessContext.options.repoRoot,
+						majorMode: harnessContext.options.majorMode,
+						activeLayers: harnessContext.selectedLayers
+					});
+					const initialMcpBundle = await loadSessionMcp(harnessContext.options.repoRoot, {
+						majorMode: harnessContext.options.majorMode,
+						activeLayers: harnessContext.selectedLayers
+					});
+					pendingSessions.set(resolved.identity.sessionId, {
+						cleanup: () => activeHarnessContext.cleanup(),
+						bundle: initialBundle,
+						mcpBundle: initialMcpBundle
+					});
+					await hub.create(sessionHostOptions(harnessContext, initialBundle, initialMcpBundle, resolved.identity, initialWorkspace));
+				} catch (error) {
+					pendingSessions.delete(resolved.identity.sessionId);
+					await activeHarnessContext.cleanup().catch((cleanupError) => notice(String(cleanupError)));
+					throw error;
+				}
+				await bounded(harnessTelemetry.flush(), "initial composition telemetry flush", notice);
+			}
+			const reservedOpens = /* @__PURE__ */ new Map();
+			openSession = async (request, sessionId, groupingWorkspaceId) => {
+				request.signal?.throwIfAborted();
+				if (request.reservationId !== void 0) {
+					if (!request.parentSessionId || !cockpit) throw new Error("A reserved session requires its owning parent.");
+					const prepared = await cockpit.sessionReservations.prepare(request.reservationId, request.parentSessionId, request.cwd);
+					if (sessionId !== void 0 && sessionId !== prepared.sessionId) throw new Error("Reserved session identity cannot change.");
+					sessionId = prepared.sessionId;
+					const existing = hub.session(sessionId);
+					if (existing) {
+						if (existing.cwd !== prepared.cwd || existing.parentSessionId !== request.parentSessionId) throw new Error("Reserved session target does not match.");
+						return {
+							sessionId,
+							cwd: existing.cwd,
+							workspaceId: existing.workspaceId
+						};
+					}
+					if (openSessions.list().some((record) => record.sessionId === sessionId)) throw new Error("Resume the recorded session instead of recreating it.");
+					const pending = reservedOpens.get(sessionId);
+					if (pending) return pending;
+					request = {
+						...request,
+						cwd: prepared.cwd
+					};
+				}
+				const identity = {
+					sessionId: sessionId ?? node_crypto.default.randomUUID(),
+					sessionName: request.name,
+					parentSessionId: request.parentSessionId,
+					sessionProvenance: request.sessionProvenance
+				};
+				const inheritedWorkspaceId = groupingWorkspaceId ?? (request.parentSessionId ? hub.session(request.parentSessionId)?.workspaceId ?? openSessions.list().find((record) => record.sessionId === request.parentSessionId)?.workspaceId : void 0);
+				const explicit = require_sessionArguments.sessionSelectionArgs(request);
+				const start = (async () => {
+					const parent = request.parentSessionId !== void 0 && (sessionId === void 0 || request.reservationId !== void 0) ? sessionManager.get(request.parentSessionId) : void 0;
+					let initialFastMode;
+					if (parent !== void 0) {
+						const state = await parent.runtime.readState();
+						if (typeof state.fastMode !== "boolean") throw new Error("Parent Fast mode must be a boolean.");
+						initialFastMode = state.fastMode;
+					}
+					const childIdentity = require_sessionArguments.resolveSessionIdentity([], identity);
+					if (sessionId !== void 0 && request.reservationId === void 0) childIdentity.agentArgs.push("--session", node_path.default.join(serverDirectory, "sessions", "durable-v1", `${childIdentity.identity.sessionId}.sqlite`));
+					const childEnvironment = {
+						...baseEnvironment,
+						...request.environment
+					};
+					for (const key of [_agimon_ai_po_config_harnessStore.HARNESS_STATE_POINTER, ...Object.values(_agimon_ai_po_config_harnessState.HARNESS_STATE_KEYS)]) delete childEnvironment[key];
+					const workspace = inheritedWorkspaceId === void 0 ? await admitWorkspace(request.cwd) : hub.workspaces().find((candidate) => candidate.id === inheritedWorkspaceId && candidate.available !== false);
+					if (workspace === void 0) throw new Error("The session workspace is unavailable.");
+					await checkScope(globalRoot, { scope: "global" });
+					syncCheckpoint(globalRoot, "The global scope");
+					if (inheritedWorkspaceId !== void 0) {
+						await checkScope(workspace.root, {
+							scope: "workspace",
+							workspaceId: workspace.id
+						});
+						syncCheckpoint(workspace.root, workspaceLabel(workspace.root, workspace.name));
+					}
+					const member = isMemberCheckout(request.cwd, workspace);
+					const childContext = await require_harnessContext.buildHarnessContext(resolveHarnessOptions({
+						args: [
+							"--cwd",
+							request.cwd,
+							...childIdentity.agentArgs,
+							...explicit.args
+						],
+						cwd: request.cwd,
+						environment: childEnvironment,
+						...member ? { configRoot: workspace.root } : {}
+					}), harnessTelemetry);
+					try {
+						const hookModules = await sessionHookModules(childContext, workspace.root);
+						require_index.updateHarnessState({ hookModules }, childContext.environment);
+						if (childContext.options.hooks) await require_index$6.validateHookModules({
+							repoRoot: childContext.options.repoRoot,
+							configRoot: workspace.root,
+							homeDirectory,
+							hookGroups: childContext.hookGroups,
+							descriptor: hookModules,
+							isSubagent: Boolean(childEnvironment.PI_SUBAGENT_CHILD)
+						});
+						const bundle = await loadComposition(childContext.options.repoRoot, "session", {
+							root: childContext.options.repoRoot,
+							majorMode: childContext.options.majorMode,
+							activeLayers: childContext.selectedLayers
+						});
+						const mcpBundle = await loadSessionMcp(childContext.options.repoRoot, {
+							majorMode: childContext.options.majorMode,
+							activeLayers: childContext.selectedLayers
+						});
+						request.signal?.throwIfAborted();
+						pendingSessions.set(identity.sessionId, {
+							cleanup: () => childContext.cleanup(),
+							bundle,
+							mcpBundle
+						});
+						const created = await hub.create(sessionHostOptions(childContext, bundle, mcpBundle, identity, workspace, {
+							pinned: explicit.pinned,
+							...initialFastMode === void 0 ? {} : { initialFastMode },
+							...request.reservationId === void 0 ? {} : { initialAgentLocked: true },
+							...request.selection?.minorModes === void 0 ? {} : { minorModes: request.selection.minorModes },
+							...request.tools === void 0 ? {} : { allowedTools: request.tools }
+						}));
+						request.signal?.throwIfAborted();
+						if (created.workspaceId !== void 0) {
+							if (openSessions.add({
+								sessionId: created.id,
+								workspaceId: created.workspaceId,
+								cwd: created.cwd,
+								repoRoot: childContext.options.repoRoot,
+								groupingRoot: workspace.root,
+								name: created.name,
+								createdAt: created.createdAt,
+								...created.parentSessionId === void 0 ? {} : { parentSessionId: created.parentSessionId },
+								...created.sessionProvenance === void 0 ? {} : { sessionProvenance: created.sessionProvenance }
+							}) === false) throw new Error("The new session could not be durably recorded.");
+						}
+						return {
+							sessionId: identity.sessionId,
+							cwd: childContext.options.cwd,
+							workspaceId: created.workspaceId
+						};
+					} catch (error) {
+						if (hub.session(identity.sessionId)) await hub.closeSession(identity.sessionId);
+						else {
+							pendingSessions.delete(identity.sessionId);
+							await childContext.cleanup().catch((cleanupError) => notice(String(cleanupError)));
+						}
+						throw error;
+					}
+				})();
+				if (request.reservationId !== void 0) reservedOpens.set(identity.sessionId, start);
+				try {
+					return await start;
+				} finally {
+					if (reservedOpens.get(identity.sessionId) === start) reservedOpens.delete(identity.sessionId);
+				}
+			};
+			const checkAllScopes = async () => {
+				await checkScope(globalRoot, { scope: "global" });
+				for (const workspace of hub.workspaces()) if (workspace.available !== false) await checkScope(workspace.root, {
+					scope: "workspace",
+					workspaceId: workspace.id
+				});
+			};
+			onExtensionCheck?.(checkAllScopes);
+			/**
+			* A finished background sync goes through the same live reload: the read-only refresh
+			* republishes a changed build, and each scope re-imports only packages whose URLs moved.
+			* Session facets and the MCP app switch at the next session. The warnings are re-read
+			* without requesting another sync, so a sync that could not fix a root never loops.
+			*/
+			pickUpSync = async () => {
+				await checkAllScopes();
+				syncCheckpoint(globalRoot, "The global scope", false);
+				for (const workspace of hub.workspaces()) if (workspace.available !== false) syncCheckpoint(workspace.root, workspaceLabel(workspace.root, workspace.name), false);
+			};
+		});
+		const workspaceResumes = /* @__PURE__ */ new Map();
+		const savedHistory = async (workspaceId) => {
+			const root = hub.workspaces().find((workspace) => workspace.id === workspaceId && workspace.available !== false)?.root;
+			if (!root) throw new Error("Workspace not found.");
+			return (0, _agimon_ai_po_core_history.listSavedSessionRecords)(node_path.default.join(serverDirectory, "sessions"), root, new Set(hub.snapshot().map((active) => active.id)), workspaceId);
+		};
+		const validateExecution = (target, workspaceId) => {
+			const root = hub.workspaces().find((workspace) => workspace.id === workspaceId && workspace.available !== false)?.root;
+			if (!root || target.groupingRoot !== root || target.workspaceId && target.workspaceId !== workspaceId) throw new Error("Saved session does not belong to this workspace.");
+			if (node_fs.default.realpathSync(require_index$1.findRepositoryRoot(target.cwd)) !== target.repoRoot) throw new Error("Saved session checkout is unavailable.");
+		};
+		const reviveRecord = async (record) => {
+			const groupingRoot = hub.workspaces().find((workspace) => workspace.id === record.workspaceId && workspace.available !== false)?.root;
+			if (!groupingRoot || record.groupingRoot !== void 0 && groupingRoot !== record.groupingRoot) throw new Error("The session workspace is unavailable.");
+			if (record.repoRoot !== void 0 && node_fs.default.realpathSync(require_index$1.findRepositoryRoot(record.cwd)) !== record.repoRoot) throw new Error("The session checkout has changed.");
+			await openSession({
+				cwd: record.cwd,
+				name: record.name,
+				...record.parentSessionId === void 0 ? {} : { parentSessionId: record.parentSessionId },
+				...record.sessionProvenance === void 0 ? {} : { sessionProvenance: record.sessionProvenance }
+			}, record.sessionId, record.workspaceId);
+		};
+		cockpit = await (0, _agimon_ai_po_core_headlessServer.serveHeadlessServer)({
+			port: options.webPort,
+			headlessHub: hub,
+			token: attachToken,
+			sessionMcpPublicOrigin: () => remoteRuntime?.remote.publicOrigin(),
+			sessionMcpStateDir: serverDirectory,
+			sessionMcpPublicOriginRevision: () => remoteRuntime?.remote.publicOriginRevision() ?? 0,
+			isSessionPersisted: (sessionId, cwd) => openSessions.list().some((record) => record.sessionId === sessionId && record.cwd === cwd),
+			workspaceHistory: async (workspaceId) => (await savedHistory(workspaceId)).map((record) => record.summary),
+			resumeWorkspaceSession: async (workspaceId, targetSessionId) => {
+				const key = `${workspaceId}\0${targetSessionId}`;
+				const pending = workspaceResumes.get(key);
+				if (pending) return pending;
+				const resume = (async () => {
+					const target = (await savedHistory(workspaceId)).find((item) => item.summary.id === targetSessionId);
+					if (!target) throw new Error("Saved Pi 1.0 session not found in this workspace. Earlier sessions cannot be resumed.");
+					validateExecution(target.execution, workspaceId);
+					await openSession({
+						cwd: target.execution.cwd,
+						name: target.summary.name ?? "untitled",
+						...target.execution.parentSessionId ? { parentSessionId: target.execution.parentSessionId } : {},
+						...target.execution.sessionProvenance ? { sessionProvenance: target.execution.sessionProvenance } : {}
+					}, target.summary.id, workspaceId);
+					return target.summary.id;
+				})();
+				workspaceResumes.set(key, resume);
+				try {
+					return await resume;
+				} finally {
+					workspaceResumes.delete(key);
+				}
+			},
+			sessionHistory: (session) => {
+				const workspaceRoot = hub.workspaces().find((workspace) => workspace.id === session.workspaceId)?.root;
+				if (!workspaceRoot) throw new Error("Session workspace not found.");
+				return (0, _agimon_ai_po_core_history.listSavedSessions)(node_path.default.join((0, _agimon_ai_po_core_piSettings.piAgentDirectory)(baseEnvironment), "server", "sessions"), workspaceRoot, new Set(hub.snapshot().map((active) => active.id)), session.workspaceId);
+			},
+			readDormantTranscript: (record, request, context) => {
+				const workspaceRoot = hub.workspaces().find((workspace) => workspace.id === record.workspaceId)?.root;
+				if (!workspaceRoot || record.groupingRoot !== void 0 && record.groupingRoot !== workspaceRoot) throw new Error("Saved transcript unavailable.");
+				const owner = node_fs.default.realpathSync(require_index$1.findRepositoryRoot(record.cwd));
+				if (record.repoRoot !== void 0 && record.repoRoot !== owner) throw new Error("Saved transcript checkout has changed.");
+				return (0, _agimon_ai_po_core_history.readSqliteTranscript)(node_path.default.join((0, _agimon_ai_po_core_piSettings.piAgentDirectory)(baseEnvironment), "server", "sessions", "durable-v1", `${record.sessionId}.sqlite`), request, context, {
+					sessionId: record.sessionId,
+					workspaceRoot: owner,
+					workspaceId: record.workspaceId,
+					groupingRoot: workspaceRoot
+				});
+			},
+			restartSession: async (session) => {
+				const record = openSessions.list().find((entry) => entry.sessionId === session.id);
+				if (!hub.workspaces().find((workspace) => workspace.id === session.workspaceId && workspace.available !== false)?.root) throw new Error("Session workspace not found.");
+				await hub.closeSession(session.id);
+				try {
+					await openSession({
+						cwd: session.cwd,
+						name: session.name,
+						...session.parentSessionId === void 0 ? {} : { parentSessionId: session.parentSessionId },
+						...session.sessionProvenance === void 0 ? {} : { sessionProvenance: session.sessionProvenance }
+					}, session.id, session.workspaceId);
+				} catch (error) {
+					if (record !== void 0) openSessions.add(record);
+					throw error;
+				}
+			},
+			resumeSession: async (session, targetSessionId) => {
+				const workspaceId = session.workspaceId;
+				if (!workspaceId || !hub.workspaces().some((workspace) => workspace.id === workspaceId)) throw new Error("Session workspace not found.");
+				const target = (await savedHistory(workspaceId)).find((item) => item.summary.id === targetSessionId);
+				if (!target) throw new Error("Saved Pi 1.0 session not found in this workspace. Earlier sessions cannot be resumed.");
+				validateExecution(target.execution, workspaceId);
+				const closedRecord = openSessions.list().find((entry) => entry.sessionId === session.id);
+				await hub.closeSession(session.id);
+				try {
+					await openSession({
+						cwd: target.execution.cwd,
+						name: target.summary.name ?? "untitled",
+						...target.execution.parentSessionId ? { parentSessionId: target.execution.parentSessionId } : {},
+						...target.execution.sessionProvenance ? { sessionProvenance: target.execution.sessionProvenance } : {}
+					}, target.summary.id, workspaceId);
+				} catch (error) {
+					if (closedRecord !== void 0) openSessions.add(closedRecord);
+					throw error;
+				}
+				return target.summary.id;
+			},
+			dormantSessions: () => openSessions.list(),
+			removeDormantSession: (record) => openSessions.remove(record.sessionId),
+			reviveSession: reviveRecord,
+			requestAsset: (request) => webCompositions?.request(request) ?? Promise.resolve(void 0),
+			compositions: () => {
+				const workspaces = hub.workspaces();
+				const decision = {
+					cwd: baseCwd,
+					launchWorkspaceId,
+					workspaces,
+					homeDirectory,
+					environment: baseEnvironment,
+					notice
+				};
+				return {
+					global: webCompositions?.get({ scope: "global" }),
+					nativeGlobal: webCompositions?.getNative({ scope: "global" }),
+					publicKey: webCompositions?.publicKey(),
+					shell: webCompositions?.shellTrust(),
+					template: require_webTemplateDecision.resolveWebTemplateDecision(decision),
+					nativeTemplate: require_webTemplateDecision.resolveWebTemplateDecision({
+						...decision,
+						host: "native"
+					}),
+					workspaces: workspaces.map((workspace) => ({
+						...workspace,
+						webComposition: webCompositions?.get({
+							scope: "workspace",
+							workspaceId: workspace.id
+						}),
+						nativeComposition: webCompositions?.getNative({
+							scope: "workspace",
+							workspaceId: workspace.id
+						})
+					}))
+				};
+			},
+			telemetry,
+			onNotice: notice
+		});
+		notice(`protocol on ${cockpit.url}/api/ws`);
+		let resolveShutdown;
+		const shutdown = new Promise((resolve) => {
+			resolveShutdown = resolve;
+		});
+		requestRestart = () => {
+			const ids = openSessions.list().map((record) => record.sessionId).filter((id) => sessionManager.get(id) !== void 0);
+			try {
+				require_idleRestart.writeRecycleFile(serverDirectory, ids);
+			} catch (error) {
+				notice(`Could not write the recycle file: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			notice(`Restarting at idle to release superseded extension versions (${String(ids.length)} sessions reopen).`);
+			resolveShutdown(75);
+		};
+		await require_idleRestart.reopenRecycledSessions(serverDirectory, async (sessionId) => {
+			const record = openSessions.list().find((entry) => entry.sessionId === sessionId);
+			if (record === void 0) throw new Error("its record is gone.");
+			await reviveRecord(record);
+		}, (sessionId, error) => notice(`Session '${sessionId}' did not reopen after the restart: ${error instanceof Error ? error.message : String(error)}`));
+		idleRestart.poke();
+		const stop = () => resolveShutdown(0);
+		signal.addEventListener("abort", stop, { once: true });
+		if (signal.aborted) stop();
+		try {
+			return await shutdown;
+		} finally {
+			signal.removeEventListener("abort", stop);
+		}
+	} finally {
+		shuttingDown = true;
+		idleRestart.dispose();
+		stopIdleRestartPoke();
+		stopResourceMonitor();
+		executionBudget.close();
+		stopPersistSessionNames();
+		clearInterval(eventLoopMonitor);
+		await bounded(telemetry.recordEvent("po_server.shutdown"), "shutdown telemetry", notice);
+		await bounded(require_shutdown.withShutdownDeadline(() => cockpit?.close(), "listener shutdown"), "listener shutdown", notice);
+		await bounded(remoteRuntime?.close() ?? Promise.resolve(), "remote control shutdown", notice);
+		try {
+			await sessionManager.close();
+		} catch (error) {
+			notice(error instanceof Error ? error.message : String(error));
+		}
+		await bounded(require_shutdown.withShutdownDeadline(() => hub.close(), "hub shutdown"), "hub shutdown", notice);
+		await bounded(require_shutdown.withShutdownDeadline(() => requestReceipts.close(), "receipt shutdown"), "receipt shutdown", notice);
+		await bounded(require_shutdown.withShutdownDeadline(() => computerUse?.close?.(), "computer use shutdown"), "computer use shutdown", notice);
+		await bounded(require_shutdown.withShutdownDeadline(() => webCompositions?.close(), "web composition shutdown"), "web composition shutdown", notice);
+		const pendingCleanups = [...pendingSessions.values()].map((setup) => bounded(require_shutdown.withShutdownDeadline(() => setup.cleanup(), "pending session cleanup"), "pending session cleanup", notice));
+		pendingSessions.clear();
+		await Promise.allSettled(pendingCleanups);
+		await Promise.allSettled([...repositoryContexts.values()].map((context) => bounded(context.cleanup(), "repository context cleanup", notice)));
+		repositoryContexts.clear();
+		await bounded(harnessTelemetry.flush(), "harness telemetry flush", notice);
+		await bounded(harnessTelemetry.shutdown(), "harness telemetry shutdown", notice);
+		await bounded(telemetry.flush(), "server telemetry flush", notice);
+		await bounded(telemetry.shutdown(), "server telemetry shutdown", notice);
+	}
+}
+//#endregion
+exports.runServerRuntime = runServerRuntime;
+
+//# sourceMappingURL=runtime.cjs.map