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

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

@@ -1,52 +1,49 @@
 import { HARNESS_STATE_KEYS, HARNESS_STATE_POINTER, loadHarnessState, updateHarnessState } from "../../composition/harnessState/index.mjs";
 import { findRepositoryRoot } from "../../composition/repository/index.mjs";
 import { createLayerResolvers, resolveExtensionComposition, unsyncedSelectors } from "../../../builders/cli/extensionAssembler/index.mjs";
-import { createPackageUrls } from "./packageUrl.mjs";
 import { compositionPackageRoots, mountWebPluginSlots, newestGlobalWebBuildKey, readGlobalWebBuildRecord, readGlobalWebBuildStatus, unslottedWebPackages } from "../web/index.mjs";
 import { mountNativePluginIds, readGlobalNativeBuildRecord, readGlobalNativeBuildStatus } from "../native/index.mjs";
 import { missingLayerPackageSpecifiers } from "../../composition/layerPackageInstaller/index.mjs";
-import { rootCompositions } from "../cli/sessionComposition.mjs";
 import { readMcpAppBuild } from "./mcpAppBuild.mjs";
-import { mcpPluginCandidates } from "./mcpBundle.mjs";
-import { globalWebPluginRoots, readSyncPointer } from "../../composition/syncService/index.mjs";
+import { globalWebPluginRoots, readSyncPointer, syncPointerPath } from "../../composition/syncService/index.mjs";
 import { createBackgroundSync, createKeyedPickup, createSyncCheckpoints, syncedBuildKeys } from "./backgroundSync.mjs";
 import { buildHarnessContext } from "../cli/harnessContext.mjs";
 import { checkoutHookDescriptor, validateHookModules, writeLiveHookModules } from "../hooks/index.mjs";
+import { createBundlerService } from "./bundlerService.mjs";
 import { createComputerUseBinding } from "./computerUseBinding.mjs";
 import { createDefaultWorkspaceFolder } from "./defaultWorkspace.mjs";
 import { createIdleRestart, holdsRestart, reopenRecycledSessions, testIdleRestartOverrides, writeRecycleFile } from "./idleRestart.mjs";
-import { serverFacetCandidates } from "./index.mjs";
 import { ensureGlobalLogSink } from "./logSink.mjs";
-import { createLiveModuleCache, createPackageReloadCheck } from "./packageReloadCheck.mjs";
 import { monitorRuntimeResources } from "./runtimeResources.mjs";
 import { publishHeadlessSelectionStatus } from "./selectionStatus.mjs";
 import { resolveSessionIdentity, sessionSelectionArgs } from "./sessionArguments.mjs";
 import { withShutdownDeadline } from "./shutdown.mjs";
+import { createWatcherService, outsideNodeModules } from "./watcherService.mjs";
 import { resolveWebTemplateDecision } from "./webTemplateDecision.mjs";
 import { checkoutWorkspaceId } from "./workspaceCheckout.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { globalDoomConfigDirectory } from "@agimon-ai/po-config/config";
+import { globalPoConfigDirectory } from "@agimon-ai/po-config/config";
 import { filterHookDisabledLayers, loadMajorModesConfig, resolveLayers } from "@agimon-ai/po-config/majorModes";
 import { resolveProfile } from "@agimon-ai/po-config/profiles";
 import { createHarnessTelemetry } from "@agimon-ai/po-core/runtimeLogSinkTelemetry";
 import { piAgentDirectory } from "@agimon-ai/po-core/piSettings";
-import { loadServerFacets, selectedServerProviderOverrides } from "@agimon-ai/po-core/serverFacet";
+import { loadServerPackages, selectedServerProviderOverrides } from "@agimon-ai/po-core/serverPlugin";
 import crypto from "node:crypto";
 import { createOpenSessionRegistry, createRequestReceipts, createWorkspaceRegistry, identifyWorkspace, listSavedSessionRecords, listSavedSessions, readSqliteTranscript, readWorkspaceMarker, writeWorkspaceMarker } from "@agimon-ai/po-core/history";
-import { readDoomBackgroundWorkService } from "@agimon-ai/po-core/backgroundWork";
+import { createNodePlatform } from "@agimon-ai/po-core/nodePlatform";
+import { readPoBackgroundWorkService } from "@agimon-ai/po-core/backgroundWork";
 import { createHeadlessHub } from "@agimon-ai/po-core/headlessHub";
 import { serveHeadlessServer } from "@agimon-ai/po-core/headlessServer";
 import { createHeadlessSessionManager } from "@agimon-ai/po-core/headlessSessionManager";
 import { loadMcpPlugins, mcpUiResource } from "@agimon-ai/po-core/mcpFacet";
-import { DOOM_SHARE_FILE_REMOTE_OFF_MESSAGE, createServerExecutionBudget } from "@agimon-ai/po-core/packageApi";
+import { PO_SHARE_FILE_REMOTE_OFF_MESSAGE, createServerExecutionBudget } from "@agimon-ai/po-core/packageApi";
 import { serveSessionApis } from "@agimon-ai/po-core/packageApiServer";
 import { createRemoteRuntime } from "@agimon-ai/po-core/remoteRuntime";
 import { createServerTelemetry } from "@agimon-ai/po-core/serverTelemetry";
 import { createWebCompositions } from "@agimon-ai/po-core/webCompositions";
 import { readMinorModeCatalog } from "@agimon-ai/po-minor-mode";
-import WebSocket from "ws";
 //#region src/builders/server/runtime.ts
 async function bounded(operation, label, notice) {
 	try {
@@ -56,7 +53,7 @@ async function bounded(operation, label, notice) {
 	}
 }
 async function runServerRuntime(options, runtime) {
-	const { cwd: baseCwd, environment: incomingEnvironment, notice, resolveHarnessOptions, signal, onExtensionCheck } = runtime;
+	const { cwd: baseCwd, environment: incomingEnvironment, notice: rawNotice, resolveHarnessOptions, signal, onExtensionCheck } = runtime;
 	const baseEnvironment = {
 		...incomingEnvironment,
 		LOG_SINK_INSTANCE: "global"
@@ -65,31 +62,58 @@ async function runServerRuntime(options, runtime) {
 	await ensureGlobalLogSink({
 		cwd: baseCwd,
 		env: baseEnvironment,
-		notice
-	}).catch((error) => notice(`Global log sink unavailable: ${error instanceof Error ? error.message : String(error)}`));
+		notice: rawNotice
+	}).catch((error) => rawNotice(`Global log sink unavailable: ${error instanceof Error ? error.message : String(error)}`));
 	const telemetry = createServerTelemetry({
 		cwd: baseCwd,
 		env: baseEnvironment,
-		warn: notice
+		warn: rawNotice
 	});
+	const notice = (message) => {
+		rawNotice(message);
+		telemetry.recordEvent("po_server.notice", { message }).catch((error) => rawNotice(`notice telemetry failed: ${String(error)}`));
+	};
 	const homeDirectory = baseEnvironment.HOME ?? os.homedir();
-	/** Content-addressed import URLs for every Po package entry this server loads. */
-	const packageUrls = 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 = createLiveModuleCache();
-	/** The package identities each mounted global and workspace scope last loaded. */
-	const reloadCheck = createPackageReloadCheck();
+	const serverDirectory = path.join(piAgentDirectory(baseEnvironment), "server");
+	const platform = createNodePlatform({
+		homeDirectory,
+		sessionsRoot: path.join(serverDirectory, "sessions")
+	});
+	/** Called on a watched change; assigned once every scope can be checked. */
+	let pickUpChange = () => void 0;
+	const watcher = createWatcherService({
+		onChange: () => pickUpChange(),
+		onNotice: notice
+	});
+	const isConfig = (file) => /\.ya?ml$/u.test(file);
+	watcher.add({
+		path: globalPoConfigDirectory(homeDirectory),
+		include: isConfig
+	});
+	/** Compiles and loads packages once per content; every scope and session selects from it. */
+	const bundler = createBundlerService({
+		homeDirectory,
+		environment: baseEnvironment,
+		onCompositions: (root, compositions) => {
+			watcher.add({
+				path: path.join(root, ".po"),
+				include: isConfig
+			});
+			for (const packageRoot of compositionPackageRoots(compositions)) if (!packageRoot.includes(`${path.sep}node_modules${path.sep}`)) watcher.add({
+				path: packageRoot,
+				recursive: true,
+				include: outsideNodeModules
+			});
+		}
+	});
 	/** The hook module descriptor from the root's live registry; sources load in place or from snapshots. */
 	const liveHookModules = (repoRoot) => writeLiveHookModules({
 		repoRoot,
 		homeDirectory,
-		directory: path.join(globalDoomConfigDirectory(homeDirectory), "server", "hook-modules"),
-		artifactFor: (source) => packageUrls.pathFor(source),
+		directory: path.join(globalPoConfigDirectory(homeDirectory), "server", "hook-modules"),
+		artifactFor: (source) => bundler.packageUrls.pathFor(source),
 		onNotice: notice
 	});
-	const serverDirectory = path.join(piAgentDirectory(baseEnvironment), "server");
 	const requestReceipts = createRequestReceipts({ directory: path.join(serverDirectory, "request-receipts-v1") });
 	const activeMedia = /* @__PURE__ */ new Set();
 	const mediaArbitration = {
@@ -173,7 +197,7 @@ async function runServerRuntime(options, runtime) {
 	/** 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. */
+	/** Each host's session package root, where its session services (background work included) live. */
 	const sessionServiceRoots = /* @__PURE__ */ new WeakMap();
 	let mountSessionApis;
 	/**
@@ -260,8 +284,11 @@ async function runServerRuntime(options, runtime) {
 		stepUpRequired: () => remoteRuntime?.remote.stepUpRequired("computer-use.activate") === true
 	});
 	let hub;
+	/** Assigned once the global builds can be read; no session opens before then. */
+	let publishSessionCompositions = () => ({});
 	hub = createHeadlessHub({
 		manager: sessionManager,
+		platform,
 		resolveProfileIdentity: (root, profile) => {
 			const identity = resolveProfile(root, profile, homeDirectory).identity;
 			return identity === void 0 ? void 0 : {
@@ -269,10 +296,11 @@ async function runServerRuntime(options, runtime) {
 				icon: identity.icon
 			};
 		},
+		publishSessionCompositions: (sessionId, root, majorMode) => publishSessionCompositions(sessionId, root, majorMode),
 		admitWorkspace: async ({ root, name }) => admitWorkspace(root === void 0 || root.trim() === "" ? await createDefaultWorkspaceFolder(name ?? "", homeDirectory) : root, name),
 		onWorkspaceRemoved: (workspaceId) => {
 			workspaces.remove(workspaceId);
-			reloadCheck.forget(`workspace:${workspaceId}`);
+			bundler.forgetScope(`workspace:${workspaceId}`);
 			webCompositions?.remove({
 				scope: "workspace",
 				workspaceId
@@ -314,7 +342,7 @@ async function runServerRuntime(options, runtime) {
 			const hosts = sessionManager.sessions();
 			if (hosts.some((host) => {
 				const root = sessionServiceRoots.get(host);
-				const service = root === void 0 ? void 0 : readDoomBackgroundWorkService(root);
+				const service = root === void 0 ? void 0 : readPoBackgroundWorkService(root);
 				return service !== void 0 && holdsRestart(service.snapshot());
 			})) return true;
 			return (await Promise.all(hosts.map((host) => host.runtime.readState()))).some((state) => state.isStreaming || state.isCompacting);
@@ -326,10 +354,13 @@ async function runServerRuntime(options, runtime) {
 	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;
+		const groups = event.session.groups ?? [];
+		const sameGroups = groups.length === (record?.groups ?? []).length && groups.every((group, index) => record?.groups?.[index] === group);
+		if (record === void 0 || record.name === event.session.name && sameGroups) return;
 		openSessions.add({
 			...record,
-			name: event.session.name
+			name: event.session.name,
+			groups
 		});
 	});
 	let harnessContext;
@@ -359,7 +390,7 @@ async function runServerRuntime(options, runtime) {
 				sessionId: options.sessionId ?? crypto.randomUUID(),
 				sessionName: options.sessionName
 			});
-			const globalRoot = globalDoomConfigDirectory(homeDirectory);
+			const globalRoot = globalPoConfigDirectory(homeDirectory);
 			webCompositions = createWebCompositions(path.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;
@@ -375,37 +406,14 @@ async function runServerRuntime(options, runtime) {
 				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) => rootCompositions({
-				root,
-				homeDirectory,
-				environment: baseEnvironment,
-				tolerateUnsynced: true
+			watcher.add({
+				path: path.dirname(syncPointerPath(globalRoot)),
+				include: (file) => file === path.basename(syncPointerPath(globalRoot))
 			});
-			/** 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 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) => 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 compositions = bundler.compositions(root);
 					const unslotted = webBuild === void 0 ? [] : unslottedWebPackages(webBuild, compositionPackageRoots(compositions));
 					return [.../* @__PURE__ */ new Set([...unsyncedSelectors(compositions), ...unslotted])];
 				} catch (error) {
@@ -421,11 +429,24 @@ async function runServerRuntime(options, runtime) {
 				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(), mountWebPluginSlots(webBuild, scopePackageRoots(root)));
+			/**
+			* Publishes one mount out of the current global build, naming only the plugin slots its root
+			* resolves. A session mount passes its major mode, so it names only that mode's slots.
+			*/
+			const publishWebMount = (mount, root, majorMode) => webBuild === void 0 ? void 0 : webCompositions?.publish(mount, webBuild, hub.channelTypes(), mountWebPluginSlots(webBuild, bundler.packageRoots(root, majorMode)));
 			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(), mountNativePluginIds(nativeBuild, scopePackageRoots(root)));
+			const publishNativeMount = (mount, root, majorMode) => nativeBuild === void 0 ? void 0 : webCompositions?.publishNative(mount, nativeBuild, hub.channelTypes(), mountNativePluginIds(nativeBuild, bundler.packageRoots(root, majorMode)));
+			publishSessionCompositions = (sessionId, root, majorMode) => ({
+				webComposition: publishWebMount({
+					scope: "session",
+					sessionId
+				}, root, majorMode),
+				nativeComposition: publishNativeMount({
+					scope: "session",
+					sessionId
+				}, root, majorMode)
+			});
 			const pickUpWebBuild = createKeyedPickup((key) => readGlobalWebBuildRecord(globalRoot, key), (build, key) => {
 				notice(`Publishing global web build ${key}.`);
 				webBuild = build;
@@ -487,58 +508,28 @@ async function runServerRuntime(options, runtime) {
 					for (const { root, mount } of mounts) publish(mount, root);
 				}
 			};
-			const defaultSelection = (root) => {
-				const config = loadMajorModesConfig(root, homeDirectory, baseEnvironment);
-				const majorMode = config.defaultMajorMode;
-				return {
-					root,
-					majorMode,
-					activeLayers: resolveLayers(config, majorMode)
-				};
-			};
 			const loadComposition = async (root, scope, selection) => {
-				const selected = selection ?? defaultSelection(root);
-				return telemetry.runInSpan("po_server.composition_load", { scope }, async () => loadServerFacets(scope, {
-					entries: await facetEntries(root),
+				const selected = selection ?? bundler.defaultSelection(root);
+				return telemetry.runInSpan("po_server.composition_load", { scope }, async () => loadServerPackages(scope, {
+					entries: await bundler.packageEntries(root),
 					majorMode: selected.majorMode,
 					activeLayers: selected.activeLayers,
 					retainCandidates: scope === "session",
 					onNotice: notice,
-					poisoned: poisonedUrls,
-					importer: importLive
+					poisoned: bundler.poisoned,
+					importer: bundler.importer
 				}));
 			};
 			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.
+			* The reload check for one served global or workspace scope: recompute its package URLs
+			* and, only when they changed, load the new set and install it. Unchanged URLs come from
+			* the module cache and the scope skips them, so only changed packages import and restart;
+			* a package no longer selected stays installed. A scope this server has not served yet is
+			* left to its admission. Checks of one scope run one at a time; a changed package whose
+			* new build fails gets its previous build back, and the check retries next time. Runs on a
+			* watched change, a finished sync and an upm change, never on the session path.
 			*/
 			const checkScope = (root, mount) => {
 				const key = scopeKey(mount);
@@ -548,15 +539,15 @@ async function runServerRuntime(options, runtime) {
 					} 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)));
+					const change = await bundler.diffScope(key, root, mount.scope);
 					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));
+					await hub.installPackages(mount, bundle.packages);
+					bundler.commitScope(key, 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).`);
+					notice(`Reloaded ${mount.scope === "global" ? "global" : `workspace '${mount.workspaceId}'`} packages (${String(change.changed.length)} changed, ${String(change.removed.length)} no longer selected).`);
 				}).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(() => {
@@ -566,16 +557,7 @@ async function runServerRuntime(options, runtime) {
 			};
 			const loadSessionMcp = async (root, selection) => {
 				return telemetry.runInSpan("po_server.mcp_bundle_load", {}, async () => {
-					const entries = [];
-					const candidates = 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
-					});
+					const { candidates, entries } = await bundler.mcpEntries(root);
 					let app;
 					try {
 						app = readMcpAppBuild({
@@ -597,8 +579,8 @@ async function runServerRuntime(options, runtime) {
 						activeLayers: selection.activeLayers,
 						retainCandidates: true,
 						onNotice: notice,
-						poisoned: poisonedUrls,
-						importer: importLive
+						poisoned: bundler.poisoned,
+						importer: bundler.importer
 					});
 				});
 			};
@@ -670,27 +652,22 @@ async function runServerRuntime(options, runtime) {
 						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 WebSocket(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"
-						}
-					} });
+				acceptProtocol: (pathname, link, deviceId) => {
+					if (!cockpit) throw new Error("The headless protocol listener is not ready.");
+					return cockpit.acceptProtocol(pathname, link, {
+						"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, {
+			await hub.serveScope({
 				...sharedApiContext,
 				scope: "global",
 				requestReceipts: requestReceipts.receipts,
 				remoteControl: { fetch: (request) => remoteRuntime.fetchLocal(request) }
-			});
-			reloadCheck.commit("global", scopeIdentities(globalRoot, "global", globalBundle.entries));
+			}, globalBundle.packages);
+			bundler.commitScope("global", globalRoot, "global", globalBundle.entries);
 			refreshWebBuild();
 			syncCheckpoint(globalRoot, "The global scope");
 			if (!backgroundSync.syncing) backgroundSync.request("server start");
@@ -709,10 +686,6 @@ async function runServerRuntime(options, runtime) {
 				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({
@@ -749,15 +722,15 @@ async function runServerRuntime(options, runtime) {
 				});
 				const admission = (async () => {
 					const bundle = await loadComposition(root, "workspace");
-					await hub.mountFacets(bundle.facets, {
+					await hub.serveScope({
 						...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));
+					}, bundle.packages);
+					bundler.commitScope(`workspace:${id}`, root, "workspace", bundle.entries);
 					try {
 						refreshWebBuild();
 						publishWebMount({
@@ -856,20 +829,14 @@ async function runServerRuntime(options, runtime) {
 				return {
 					cwd: policyOptions.cwd,
 					repoRoot: policyOptions.repoRoot,
+					platform,
 					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),
+					...explicit.resume ? { resume: true } : {},
 					...identity.parentSessionId === void 0 ? {} : { parentSessionId: identity.parentSessionId },
 					...identity.sessionProvenance === void 0 ? {} : { sessionProvenance: identity.sessionProvenance },
 					agentArgs: policyOptions.piArgs,
@@ -901,7 +868,7 @@ async function runServerRuntime(options, runtime) {
 						};
 					},
 					candidates: bundle.entries,
-					providerOverrides: () => selectedServerProviderOverrides(bundle.facets, sessionEnvironment),
+					providerOverrides: () => selectedServerProviderOverrides(bundle.packages, sessionEnvironment),
 					requiredServerPackages: async () => {
 						const harness = loadHarnessState(sessionEnvironment).state;
 						if (!harness.hooks) return [];
@@ -926,14 +893,16 @@ async function runServerRuntime(options, runtime) {
 					onNotice: notice
 				};
 			};
-			mountSessionApis = (sessionOptions, host) => serveSessionApis({
+			mountSessionApis = async (sessionOptions, host) => serveSessionApis({
+				parentScope: await hub.sessionParentScope(sessionOptions.workspaceId),
 				sessionId: sessionOptions.sessionId,
+				platform,
 				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(DOOM_SHARE_FILE_REMOTE_OFF_MESSAGE)) : remoteRuntime.fileShares.mint({
+				shareFile: (filePath, label) => remoteRuntime === void 0 ? Promise.reject(new Error(PO_SHARE_FILE_REMOTE_OFF_MESSAGE)) : remoteRuntime.fileShares.mint({
 					sessionId: sessionOptions.sessionId,
 					cwd: sessionOptions.cwd,
 					path: filePath,
@@ -960,10 +929,11 @@ async function runServerRuntime(options, runtime) {
 				sessionService: hub.sessionService,
 				mediaArbitration,
 				executionBudget,
+				editPresence: hub.editPresence,
 				peerAgents,
 				pluginRegistry: hub.pluginRegistry,
 				apis: [],
-				facets: pendingSessions.get(sessionOptions.sessionId)?.bundle.facets ?? [],
+				packages: pendingSessions.get(sessionOptions.sessionId)?.bundle.packages ?? [],
 				workspaceId: sessionOptions.workspaceId,
 				workspaceRoot: sessionOptions.repoRoot,
 				...host.sessionContext === void 0 ? {} : { sessionContext: host.sessionContext },
@@ -977,11 +947,11 @@ async function runServerRuntime(options, runtime) {
 						})
 					};
 				},
-				prepareFacets: (root) => {
+				preparePackages: (root) => {
 					sessionServiceRoots.set(host, root);
-					host.prepareFacets(root);
+					host.preparePackages(root);
 				},
-				activateFacets: host.activateFacets,
+				activatePackages: host.activatePackages,
 				canDispatch: host.canDispatch,
 				telemetry,
 				onNotice: notice
@@ -1080,6 +1050,7 @@ async function runServerRuntime(options, runtime) {
 				};
 				const inheritedWorkspaceId = groupingWorkspaceId ?? (request.parentSessionId ? hub.session(request.parentSessionId)?.workspaceId ?? openSessions.list().find((record) => record.sessionId === request.parentSessionId)?.workspaceId : void 0);
 				const explicit = sessionSelectionArgs(request);
+				const openStartedAt = Date.now();
 				const start = (async () => {
 					const parent = request.parentSessionId !== void 0 && (sessionId === void 0 || request.reservationId !== void 0) ? sessionManager.get(request.parentSessionId) : void 0;
 					let initialFastMode;
@@ -1089,7 +1060,6 @@ async function runServerRuntime(options, runtime) {
 						initialFastMode = state.fastMode;
 					}
 					const childIdentity = resolveSessionIdentity([], identity);
-					if (sessionId !== void 0 && request.reservationId === void 0) childIdentity.agentArgs.push("--session", path.join(serverDirectory, "sessions", "durable-v1", `${childIdentity.identity.sessionId}.sqlite`));
 					const childEnvironment = {
 						...baseEnvironment,
 						...request.environment
@@ -1097,15 +1067,8 @@ async function runServerRuntime(options, runtime) {
 					for (const key of [HARNESS_STATE_POINTER, ...Object.values(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));
-					}
+					if (inheritedWorkspaceId !== void 0) syncCheckpoint(workspace.root, workspaceLabel(workspace.root, workspace.name));
 					const member = isMemberCheckout(request.cwd, workspace);
 					const childContext = await buildHarnessContext(resolveHarnessOptions({
 						args: [
@@ -1148,6 +1111,7 @@ async function runServerRuntime(options, runtime) {
 							pinned: explicit.pinned,
 							...initialFastMode === void 0 ? {} : { initialFastMode },
 							...request.reservationId === void 0 ? {} : { initialAgentLocked: true },
+							...sessionId !== void 0 && request.reservationId === void 0 ? { resume: true } : {},
 							...request.selection?.minorModes === void 0 ? {} : { minorModes: request.selection.minorModes },
 							...request.tools === void 0 ? {} : { allowedTools: request.tools }
 						}));
@@ -1162,7 +1126,8 @@ async function runServerRuntime(options, runtime) {
 								name: created.name,
 								createdAt: created.createdAt,
 								...created.parentSessionId === void 0 ? {} : { parentSessionId: created.parentSessionId },
-								...created.sessionProvenance === void 0 ? {} : { sessionProvenance: created.sessionProvenance }
+								...created.sessionProvenance === void 0 ? {} : { sessionProvenance: created.sessionProvenance },
+								...created.groups === void 0 || created.groups.length === 0 ? {} : { groups: [...created.groups] }
 							}) === false) throw new Error("The new session could not be durably recorded.");
 						}
 						return {
@@ -1179,6 +1144,10 @@ async function runServerRuntime(options, runtime) {
 						throw error;
 					}
 				})();
+				start.then(() => "success", () => "failure").then((outcome) => telemetry.recordEvent("po_server.session_open", {
+					duration_ms: Date.now() - openStartedAt,
+					outcome
+				})).catch((error) => rawNotice(`session open telemetry failed: ${String(error)}`));
 				if (request.reservationId !== void 0) reservedOpens.set(identity.sessionId, start);
 				try {
 					return await start;
@@ -1187,6 +1156,8 @@ async function runServerRuntime(options, runtime) {
 				}
 			};
 			const checkAllScopes = async () => {
+				bundler.invalidate();
+				syncCheckpoints.invalidate();
 				await checkScope(globalRoot, { scope: "global" });
 				for (const workspace of hub.workspaces()) if (workspace.available !== false) await checkScope(workspace.root, {
 					scope: "workspace",
@@ -1197,7 +1168,7 @@ async function runServerRuntime(options, runtime) {
 			/**
 			* 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
+			* Session packages 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 () => {
@@ -1205,12 +1176,21 @@ async function runServerRuntime(options, runtime) {
 				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);
 			};
+			pickUpChange = () => {
+				pickUpSync().catch((error) => notice(`Extension reload failed: ${String(error)}`));
+			};
 		});
 		const workspaceResumes = /* @__PURE__ */ new Map();
+		const reportedUnreadable = /* @__PURE__ */ new Set();
+		const unreadableHistory = (sessionId, error) => {
+			if (reportedUnreadable.has(sessionId)) return;
+			reportedUnreadable.add(sessionId);
+			notice(`Saved session ${sessionId} is hidden from History: ${error instanceof Error ? error.message : String(error)}`);
+		};
 		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 listSavedSessionRecords(path.join(serverDirectory, "sessions"), root, new Set(hub.snapshot().map((active) => active.id)), workspaceId);
+			return listSavedSessionRecords(platform.sessions, root, new Set(hub.snapshot().map((active) => active.id)), workspaceId, unreadableHistory);
 		};
 		const validateExecution = (target, workspaceId) => {
 			const root = hub.workspaces().find((workspace) => workspace.id === workspaceId && workspace.available !== false)?.root;
@@ -1227,6 +1207,9 @@ async function runServerRuntime(options, runtime) {
 				...record.parentSessionId === void 0 ? {} : { parentSessionId: record.parentSessionId },
 				...record.sessionProvenance === void 0 ? {} : { sessionProvenance: record.sessionProvenance }
 			}, record.sessionId, record.workspaceId);
+			const groups = record.groups ?? [];
+			const opened = hub.session(record.sessionId)?.groups ?? [];
+			if (groups.length !== opened.length || groups.some((group, index) => opened[index] !== group)) await hub.runtime(record.sessionId)?.setGroups(groups);
 		};
 		cockpit = await serveHeadlessServer({
 			port: options.webPort,
@@ -1263,14 +1246,14 @@ async function runServerRuntime(options, runtime) {
 			sessionHistory: (session) => {
 				const workspaceRoot = hub.workspaces().find((workspace) => workspace.id === session.workspaceId)?.root;
 				if (!workspaceRoot) throw new Error("Session workspace not found.");
-				return listSavedSessions(path.join(piAgentDirectory(baseEnvironment), "server", "sessions"), workspaceRoot, new Set(hub.snapshot().map((active) => active.id)), session.workspaceId);
+				return listSavedSessions(platform.sessions, workspaceRoot, new Set(hub.snapshot().map((active) => active.id)), session.workspaceId, unreadableHistory);
 			},
 			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 = fs.realpathSync(findRepositoryRoot(record.cwd));
 				if (record.repoRoot !== void 0 && record.repoRoot !== owner) throw new Error("Saved transcript checkout has changed.");
-				return readSqliteTranscript(path.join(piAgentDirectory(baseEnvironment), "server", "sessions", "durable-v1", `${record.sessionId}.sqlite`), request, context, {
+				return readSqliteTranscript(platform.sessions, record.sessionId, request, context, {
 					sessionId: record.sessionId,
 					workspaceRoot: owner,
 					workspaceId: record.workspaceId,
@@ -1316,6 +1299,12 @@ async function runServerRuntime(options, runtime) {
 			},
 			dormantSessions: () => openSessions.list(),
 			removeDormantSession: (record) => openSessions.remove(record.sessionId),
+			setDormantGroups: (record, groups) => {
+				if (!openSessions.add({
+					...record,
+					groups: [...groups]
+				})) throw new Error("The session groups could not be durably recorded.");
+			},
 			reviveSession: reviveRecord,
 			requestAsset: (request) => webCompositions?.request(request) ?? Promise.resolve(void 0),
 			compositions: () => {
@@ -1389,6 +1378,7 @@ async function runServerRuntime(options, runtime) {
 		stopIdleRestartPoke();
 		stopResourceMonitor();
 		executionBudget.close();
+		watcher.close();
 		stopPersistSessionNames();
 		clearInterval(eventLoopMonitor);
 		await bounded(telemetry.recordEvent("po_server.shutdown"), "shutdown telemetry", notice);