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

package/dist/extensions/server.mjs

@@ -1,23 +1,29 @@
-import { c as getLogTtlMs } from "../runnerConfig-BQBlVAXn.mjs";
-import { r as summarizeLog, t as LogReader } from "../logReader-UfbDbwQl.mjs";
-import { n as createHeadlessRunnersCommand, t as createHeadlessBashTool } from "../headless-BGYfIlNk.mjs";
-import { n as reconcileActiveRunners, r as stopRunnerProcess, t as cleanupLegacyRunnerStore } from "../reconcile-DMeNSxwn.mjs";
-import { t as activeRunnerRecovery } from "../compaction-DCw80VZj.mjs";
-import { t as RmuxBackend } from "../rmuxBackend-DfyQwJrc.mjs";
-import { n as TmuxBackend, r as PtyBackendChain, t as createRunnerDependencies } from "../runnerDependencies-DruByBGS.mjs";
-import { n as resolveRunnerStoreDirectory, r as runnerStateDirFor, t as RunnerPaths } from "../runnerPaths-B_dAAeco.mjs";
-import { a as isRunnerRecord, i as formatRunnerStatus, r as formatRunnerFinished } from "../runnerRegistry-CeOHEjBv.mjs";
+import { c as getLogTtlMs } from "../runnerConfig-XXMq4VQA.mjs";
+import { r as summarizeLog, t as LogReader } from "../logReader-mq9uVurh.mjs";
+import { n as createHeadlessRunnersCommand, t as createHeadlessBashTool } from "../headless-DOlCixyf.mjs";
+import { n as stopRunnerProcess, t as reconcileActiveRunners } from "../reconcile-wNYQJZF-.mjs";
+import { t as SystemClock } from "../clock-Cv2pddgo.mjs";
+import { t as activeRunnerRecovery } from "../compaction-nNlE6e5I.mjs";
+import { t as RmuxBackend } from "../rmuxBackend-rjrVTG6K.mjs";
+import { n as TERM_GRACE_MS } from "../launcher-CCYsFBM9.mjs";
+import { n as TmuxBackend, r as PtyBackendChain, t as createRunnerDependencies } from "../runnerDependencies-7h_cxOva.mjs";
+import { n as resolveRunnerStoreDirectory, r as runnerStateDirFor, t as RunnerPaths } from "../runnerPaths-Dibbvyx_.mjs";
+import { a as formatRunnerStatus, i as formatRunnerFinishedNotice, n as createDefaultProcessRegistry, o as isRunnerRecord, r as formatRunnerFinished } from "../runnerRegistry-BgaR5O86.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import { resolveRootSessionId } from "@agimon-ai/po-core/childProcess";
-import { composeServerProviderOverrides, defineServerPlugin, packageResourcePath, readPackageResource } from "@agimon-ai/po-core/serverFacet";
-import { composeRootHooks, defineChannel, defineHook, defineResource, defineRoot, defineRoute, defineServerCommand, defineServerTool } from "@agimon-ai/po-core/extensionFile";
-import { DOOM_BACKGROUND_WORK_SERVICE, readDoomBackgroundWorkService } from "@agimon-ai/po-core/backgroundWork";
-import { createDoomTelemetry } from "@agimon-ai/po-telemetry";
+import { composeServerProviderOverrides, defineServerPlugin, packageResourcePath, readPackageResource } from "@agimon-ai/po-core/serverPlugin";
+import { composeRootHooks, composeRootInjects, defineChannel, defineHook, defineResource, defineRoot, defineRoute, defineServerCommand, defineServerTool, runCleanups } from "@agimon-ai/po-core/extensionFile";
+import { PO_BACKGROUND_WORK_SERVICE, readPoBackgroundWorkService } from "@agimon-ai/po-core/backgroundWork";
+import { createPoTelemetry } from "@agimon-ai/po-telemetry";
 import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
-import { DOOM_HELP_WHEN } from "@agimon-ai/po-core/help";
+import { PO_HELP_WHEN } from "@agimon-ai/po-core/help";
+const RUNNER_STATUS_KEY = "po-runner-runners";
+const BACKGROUND_WORK_PROVIDER = "po-runner";
+const HISTORY_SWEEP_INTERVAL_MS = 6e5;
+//#endregion
 //#region src/constants/runnerSettings.ts
 const RUNNER_SETTINGS_FILE = "po-runner.json";
 const RATIO_KEYS = ["headRatio", "errorBudgetRatio"];
@@ -25,10 +31,110 @@ const MAX_RESULT_BYTES_CEILING = 262144;
 const MAX_RESULT_LINES_CEILING = 5e3;
 const MAX_RESULT_TOKENS_CEILING = 1e5;
 //#endregion
-//#region src/constants/runnerRuntime.ts
-const RUNNER_STATUS_KEY = "doom-runner-runners";
-const BACKGROUND_WORK_PROVIDER = "doom-runner";
-const HISTORY_SWEEP_INTERVAL_MS = 6e5;
+//#region src/services/runnerHost/index.ts
+const describe = (error) => error instanceof Error ? error.message : String(error);
+/** Runs `pass` again `ms` after the previous pass finished, so two passes never overlap. */
+function repeat(clock, ms, pass) {
+	let stopped = false;
+	let cancel;
+	let running;
+	const arm = () => {
+		cancel = clock.after(ms, () => {
+			cancel = void 0;
+			running = pass().finally(() => {
+				running = void 0;
+				if (!stopped) arm();
+			});
+		});
+	};
+	arm();
+	return { async stop() {
+		stopped = true;
+		cancel?.();
+		await running;
+	} };
+}
+/**
+* The housekeeping every session running one po-runner build in one hub shares.
+*
+* A session used to open its own registry connection and arm its own status poll and history
+* sweep, and each sweep walked the whole runner store. Here one loop refreshes the attached sessions
+* one at a time, one sweep per store spares every attached session at once, and runners a crashed
+* server left behind are reclaimed once rather than at every session start.
+*/
+function createRunnerHost(options) {
+	const sessions = /* @__PURE__ */ new Set();
+	let closed = false;
+	let reclaiming;
+	let sweeping;
+	const refreshAll = async () => {
+		for (const session of sessions) {
+			if (closed) return;
+			try {
+				await session.refresh();
+			} catch (error) {
+				options.onWarning(`Could not refresh po-runner session ${session.sessionId}: ${describe(error)}`);
+			}
+		}
+	};
+	const sweepAll = () => {
+		sweeping ??= (async () => {
+			try {
+				const byStore = /* @__PURE__ */ new Map();
+				for (const session of sessions) {
+					const store = session.paths.storeDirectory();
+					byStore.set(store, [...byStore.get(store) ?? [], session]);
+				}
+				for (const group of byStore.values()) {
+					const [first] = group;
+					if (closed || first === void 0) return;
+					const live = new Set(group.map((session) => session.sessionId));
+					const now = options.clock.now();
+					const result = first.paths.sweepHistoryAsync ? await first.paths.sweepHistoryAsync(first.historyTtlMs, now, live) : first.paths.sweepHistory(first.historyTtlMs, now, live);
+					for (const error of result.errors) options.onWarning(error);
+				}
+			} catch (error) {
+				options.onWarning(`Could not sweep po-runner history: ${describe(error)}`);
+			}
+		})().finally(() => {
+			sweeping = void 0;
+		});
+		return sweeping;
+	};
+	const polling = repeat(options.clock, options.statusPollMs, refreshAll);
+	const sweeper = repeat(options.clock, options.historySweepMs, sweepAll);
+	return {
+		processRegistry: {
+			registerProcess: (...args) => options.processRegistry.registerProcess(...args),
+			releaseProcess: (...args) => options.processRegistry.releaseProcess(...args),
+			listProcesses: (...args) => options.processRegistry.listProcesses(...args),
+			close: () => void 0
+		},
+		attach(session) {
+			if (closed) throw new Error("The po-runner host is disposed.");
+			sessions.add(session);
+			if (reclaiming === void 0) {
+				reclaiming = session.reclaimOrphans().catch((error) => options.onWarning(`Could not reclaim orphaned runners: ${describe(error)}`));
+				sweepAll();
+			}
+			return () => {
+				sessions.delete(session);
+			};
+		},
+		async dispose() {
+			if (closed) return;
+			closed = true;
+			sessions.clear();
+			await Promise.all([
+				polling.stop(),
+				sweeper.stop(),
+				reclaiming,
+				sweeping
+			]);
+			options.processRegistry.close();
+		}
+	};
+}
 //#endregion
 //#region src/constants/webRunners.ts
 const RUNNER_RUNS_TYPE = "runner_runs";
@@ -84,9 +190,9 @@ function presentRunnerRuns(records, now) {
 //#endregion
 //#region src/services/runnerServerRuntime/index.ts
 const COMPLETION_RETRY_MS = 1e3;
-function createRunnerServerRuntime(container, directEvents, wakeAgent, execution) {
-	const telemetry = execution ? createDoomTelemetry({
-		serviceName: "doom-runner",
+function createRunnerServerRuntime(container, host, directEvents, wakeAgent, execution) {
+	const telemetry = execution ? createPoTelemetry({
+		serviceName: "po-runner",
 		packageName: "@agimon-ai/po-runner",
 		cwd: execution.cwd,
 		env: execution.environment,
@@ -105,41 +211,31 @@ function createRunnerServerRuntime(container, directEvents, wakeAgent, execution
 	let wakes = Promise.resolve();
 	let closing = false;
 	let retryTimer;
-	let statusTimer;
-	let historyTimer;
-	let historySweep;
-	const sweepHistory = () => {
-		if (closing) return Promise.resolve();
-		historySweep ??= (async () => {
-			const ttl = getLogTtlMs(container.environment);
-			const result = container.paths.sweepHistoryAsync ? await container.paths.sweepHistoryAsync(ttl) : container.paths.sweepHistory(ttl);
-			for (const error of result.errors) process.emitWarning(error);
-		})().catch((error) => process.emitWarning(`Could not sweep doom-runner history: ${String(error)}`)).finally(() => {
-			historySweep = void 0;
+	/** Stops the shared loop refreshing this session and sweeping around it. */
+	let detach;
+	/** Every runner of every session the registry knows, reclaimed when its owning process is gone. */
+	const reclaimOrphans = async () => {
+		const reclaimed = await reconcileActiveRunners({
+			registry: container.runnerRegistry,
+			launcher: container.launcher,
+			rmuxBackend: container.rmuxBackend,
+			processControl: container.processControl,
+			currentHostPid: process.pid,
+			startup: false
 		});
-		return historySweep;
+		for (const error of reclaimed.errors) process.emitWarning(error);
 	};
 	const ensureSession = (requestedSessionId) => {
 		if (closing) return Promise.reject(/* @__PURE__ */ new Error("Runner runtime is closing."));
 		if (sessionId !== void 0 && sessionId !== requestedSessionId) throw new Error(`Runner runtime belongs to session ${sessionId}.`);
 		sessionId ??= requestedSessionId;
 		supervision ??= (async () => {
-			await telemetry?.recordEvent("doom_runner.session_started", { outcome: "started" });
+			telemetry?.recordEvent("po_runner.session_started", { outcome: "started" }).catch((error) => process.emitWarning(`Could not record runner session telemetry: ${String(error)}`));
 			if (closing) return;
 			container.paths.setSessionId(requestedSessionId);
 			if (await container.lifeline.arm(requestedSessionId) === void 0) throw new Error("Could not arm runner supervision lifeline.");
 			if (closing) return;
 			const promotedIds = (await container.runnerRegistry.listAll(requestedSessionId)).filter((record) => record.state === "running" && record.promoted).map((record) => record.id);
-			const legacy = await cleanupLegacyRunnerStore({
-				registry: container.runnerRegistry,
-				launcher: container.launcher,
-				rmuxBackend: container.rmuxBackend,
-				processControl: container.processControl,
-				currentHostPid: process.pid,
-				paths: container.paths
-			});
-			for (const error of legacy.errors) process.emitWarning(error);
-			if (closing) return;
 			const reconciled = await reconcileActiveRunners({
 				registry: container.runnerRegistry,
 				launcher: container.launcher,
@@ -147,28 +243,26 @@ function createRunnerServerRuntime(container, directEvents, wakeAgent, execution
 				processControl: container.processControl,
 				currentHostPid: process.pid,
 				startup: true,
-				startupSessionId: requestedSessionId
+				startupSessionId: requestedSessionId,
+				active: await container.runnerRegistry.listBySession(requestedSessionId)
 			});
 			for (const error of reconciled.errors) process.emitWarning(error);
-			await telemetry?.recordEvent("doom_runner.reconciled", {
-				"runner.reclaimed_count": legacy.reclaimed.length + reconciled.reclaimed.length,
-				"runner.error_count": legacy.errors.length + reconciled.errors.length,
-				outcome: legacy.errors.length + reconciled.errors.length === 0 ? "completed" : "degraded"
-			});
+			telemetry?.recordEvent("po_runner.reconciled", {
+				"runner.reclaimed_count": reconciled.reclaimed.length,
+				"runner.error_count": reconciled.errors.length,
+				outcome: reconciled.errors.length === 0 ? "completed" : "degraded"
+			}).catch((error) => process.emitWarning(`Could not record runner reconcile telemetry: ${String(error)}`));
 			if (!closing) {
 				unsubscribeRunnerUpdates ??= container.runnerRegistry.subscribe(() => requestPublish(requestedSessionId), requestedSessionId);
 				for (const id of promotedIds) watchRunner(id);
 				requestPublish(requestedSessionId);
-				await sweepHistory();
-				if (closing) return;
-				statusTimer ??= setInterval(() => {
-					refreshSession(requestedSessionId);
-				}, 500);
-				statusTimer.unref?.();
-				historyTimer ??= setInterval(() => {
-					sweepHistory();
-				}, HISTORY_SWEEP_INTERVAL_MS);
-				historyTimer.unref?.();
+				detach ??= host.attach({
+					sessionId: requestedSessionId,
+					paths: container.paths,
+					historyTtlMs: getLogTtlMs(container.environment),
+					refresh: () => refreshSession(requestedSessionId),
+					reclaimOrphans
+				});
 			}
 		})().catch((error) => {
 			supervision = void 0;
@@ -181,36 +275,36 @@ function createRunnerServerRuntime(container, directEvents, wakeAgent, execution
 			await supervision?.catch((error) => process.emitWarning(`Could not initialize headless runner supervision: ${String(error)}`));
 			const ownedSessionId = sessionId;
 			if (ownedSessionId === void 0) return;
-			const records = await container.runnerRegistry.listBySession(ownedSessionId).catch(() => []);
-			await Promise.all(records.map(async (record) => {
-				try {
-					if (!await stopRunnerProcess(record, container.launcher, container.rmuxBackend, {
-						registry: container.runnerRegistry,
-						intent: {
+			await runCleanups([
+				async () => {
+					const records = await container.runnerRegistry.listBySession(ownedSessionId);
+					const errors = (await Promise.allSettled(records.map(async (record) => {
+						await stopRunnerProcess(record, container.launcher, container.rmuxBackend, {
+							registry: container.runnerRegistry,
+							intent: {
+								reason: "stopped",
+								terminationReason: "parent_session_cleanup",
+								stopReason: "session ended"
+							}
+						});
+						const deadline = container.clock.now() + TERM_GRACE_MS;
+						while (container.processControl.isAlive(record.pid)) {
+							if (container.clock.now() >= deadline) throw new Error(`Could not stop runner ${record.id} during session shutdown`);
+							await new Promise((resolve) => container.clock.after(100, resolve));
+						}
+						await container.runnerRegistry.complete(record.id, {
 							reason: "stopped",
-							terminationReason: "parent_session_cleanup",
+							code: null,
+							signal: null,
 							stopReason: "session ended"
-						}
-					}) && container.processControl.isAlive(record.pid)) {
-						process.emitWarning(`Could not stop runner ${record.id} during session shutdown`);
-						return;
-					}
-					await container.runnerRegistry.complete(record.id, {
-						reason: "stopped",
-						code: null,
-						signal: null,
-						stopReason: "session ended"
-					}, ownedSessionId);
-				} catch (error) {
-					process.emitWarning(`Could not clean up runner ${record.id}: ${String(error)}`);
-				}
-			}));
-			try {
-				await container.ptyHost.disposeAll();
-			} finally {
-				container.lifeline.dispose();
-				container.runnerRegistry.close();
-			}
+						}, ownedSessionId);
+					}))).filter((result) => result.status === "rejected").map((result) => result.reason);
+					if (errors.length) throw new AggregateError(errors, "Runner process cleanup failed.");
+				},
+				() => container.ptyHost.disposeAll(),
+				() => container.lifeline.dispose(),
+				() => container.runnerRegistry.close()
+			], "Runner runtime cleanup failed.");
 		})();
 		return runtimeDisposal;
 	};
@@ -240,7 +334,7 @@ function createRunnerServerRuntime(container, directEvents, wakeAgent, execution
 				wakeForFinished(ownedSessionId);
 			}
 		} catch (error) {
-			process.emitWarning(`Could not refresh doom-runner: ${String(error)}`);
+			process.emitWarning(`Could not refresh po-runner: ${String(error)}`);
 		}
 	};
 	const publishRuns = async (ownedSessionId) => {
@@ -299,8 +393,8 @@ function createRunnerServerRuntime(container, directEvents, wakeAgent, execution
 					const record = await container.runnerRegistry.get(id, ownedSessionId);
 					if (closing) return;
 					if (record?.state === "running") continue;
-					if (record) await wakeAgent?.(formatRunnerFinished(record), `runner-finished:${JSON.stringify([ownedSessionId, id])}`);
-					if (record) await telemetry?.recordEvent("doom_runner.process_finished", {
+					if (record) await wakeAgent?.(formatRunnerFinished(record), `runner-finished:${JSON.stringify([ownedSessionId, id])}`, formatRunnerFinishedNotice(record));
+					if (record) await telemetry?.recordEvent("po_runner.process_finished", {
 						outcome: "completed",
 						"runner.exit_code": record.exit?.code ?? 0,
 						"runner.backend": record.backend
@@ -342,7 +436,7 @@ function createRunnerServerRuntime(container, directEvents, wakeAgent, execution
 		activity: {
 			name: "runner",
 			start: async (executionContext) => {
-				await ensureSession(executionContext.sessionId);
+				ensureSession(executionContext.sessionId).catch((error) => process.emitWarning(`Could not initialize headless runner supervision: ${String(error)}`));
 				requestPublish(executionContext.sessionId);
 				return () => {};
 			}
@@ -365,7 +459,7 @@ function createRunnerServerRuntime(container, directEvents, wakeAgent, execution
 			const text = activeRunnerRecovery(active);
 			if (!text) return;
 			await execution.session.appendMessage?.({
-				type: "doom-runner-compaction",
+				type: "po-runner-compaction",
 				text,
 				display: false,
 				details: {
@@ -376,8 +470,8 @@ function createRunnerServerRuntime(container, directEvents, wakeAgent, execution
 			if (!closing) recoveredCompactionId = event.entryId;
 		},
 		backgroundWorkPlugin: (context) => {
-			context.inject([DOOM_BACKGROUND_WORK_SERVICE], (serviceContext) => {
-				const service = readDoomBackgroundWorkService(serviceContext);
+			context.inject([PO_BACKGROUND_WORK_SERVICE], (serviceContext) => {
+				const service = readPoBackgroundWorkService(serviceContext);
 				if (!service) return void 0;
 				const registration = service.register({
 					provider: BACKGROUND_WORK_PROVIDER,
@@ -395,8 +489,8 @@ function createRunnerServerRuntime(container, directEvents, wakeAgent, execution
 			closing = true;
 			disposal = (async () => {
 				closing = true;
-				clearInterval(statusTimer);
-				clearInterval(historyTimer);
+				detach?.();
+				detach = void 0;
 				clearTimeout(retryTimer);
 				retryTimer = void 0;
 				watched.clear();
@@ -406,16 +500,17 @@ function createRunnerServerRuntime(container, directEvents, wakeAgent, execution
 				unsubscribeRunnerUpdates = void 0;
 				await wakes;
 				await publishInFlight;
-				await historySweep;
 				await refreshInFlight;
 				try {
 					execution?.client.setStatus(RUNNER_STATUS_KEY, void 0);
 				} catch (error) {
 					process.emitWarning(`Could not clear runner status: ${String(error)}`);
 				}
-				await disposeRuntime();
-				await telemetry?.recordEvent("doom_runner.session_finished", { outcome: "stopped" });
-				await telemetry?.shutdown();
+				await runCleanups([
+					disposeRuntime,
+					() => telemetry?.recordEvent("po_runner.session_finished", { outcome: "stopped" }),
+					() => telemetry?.shutdown()
+				], "Runner shutdown failed.");
 			})();
 			return disposal;
 		}
@@ -531,27 +626,41 @@ function validate(parsed) {
 }
 //#endregion
 //#region src/extensions/workspaces/sessions/(backend)/_lib/serverRoot.ts
-const RUNNER_SERVER_SCOPE_SERVICE = "doom/runner-server-scope";
-const createRunnerServerRoot = ({ host, agent, signal }) => {
-	if (!host.context.directEvents) throw new Error("Runner headless facet requires the session direct event bus.");
-	if (!host.context.cwd || !host.context.environment) throw new Error("Runner headless facet requires session cwd and environment.");
+const RUNNER_SERVER_SCOPE_SERVICE = "po/runner-server-scope";
+const createRunnerServerRoot = async ({ host, agent, signal, resources }) => {
+	if (!host.context.directEvents) throw new Error("Runner server plugin requires the session direct event bus.");
+	if (!host.context.cwd || !host.context.environment) throw new Error("Runner server plugin requires session cwd and environment.");
 	const loaded = new RunnerSettingsLoader().load(host.context.cwd, true);
 	const settings = Object.freeze({
 		...loaded.settings,
 		...loaded.settings.errorPatterns ? { errorPatterns: Object.freeze([...loaded.settings.errorPatterns]) } : {}
 	});
 	for (const issue of loaded.issues) process.emitWarning(`${RUNNER_SETTINGS_FILE}: ${issue}`);
+	const environment = host.context.environment;
+	const runnerHost = await resources.acquire(["runner-host", environment["PROCESS_REGISTRY_PATH"] ?? null], () => createRunnerHost({
+		processRegistry: createDefaultProcessRegistry(environment),
+		clock: new SystemClock(),
+		statusPollMs: 500,
+		historySweepMs: HISTORY_SWEEP_INTERVAL_MS,
+		onWarning: (message) => process.emitWarning(message)
+	}), (shared) => shared.dispose());
 	const dependencies = createRunnerDependencies({
 		settings,
 		cwd: host.context.cwd,
-		environment: host.context.environment,
+		environment,
+		processRegistry: runnerHost.processRegistry,
 		...host.context.executionBudget === void 0 ? {} : { executionBudget: host.context.executionBudget }
 	});
 	const execution = agent?.context;
-	const wakeAgent = execution && (async (content, requestId) => {
+	const wakeAgent = execution && (async (content, requestId, notice) => {
 		try {
-			if (!execution.session.admitPrompt) throw new Error("The session cannot admit a runner notification.");
-			await execution.session.admitPrompt(content, "steer", void 0, requestId);
+			if (!execution.session.admitMessage) throw new Error("The session cannot admit a runner notification.");
+			await execution.session.admitMessage({
+				type: "po-runner-finished",
+				text: content,
+				display: true,
+				details: { notice }
+			}, "steer", requestId);
 		} catch (error) {
 			await Promise.resolve().then(() => execution.client.notify({
 				body: String(error),
@@ -560,7 +669,7 @@ const createRunnerServerRoot = ({ host, agent, signal }) => {
 			throw error;
 		}
 	});
-	const runtime = createRunnerServerRuntime(dependencies, host.context.directEvents, wakeAgent, execution);
+	const runtime = createRunnerServerRuntime(dependencies, runnerHost, host.context.directEvents, wakeAgent, execution);
 	const bash = (wakeOnExit) => createHeadlessBashTool({ run: async (request) => {
 		await runtime.ensureSession(request.sessionId);
 		const result = await dependencies.bashRunService.run({
@@ -582,7 +691,9 @@ const createRunnerServerRoot = ({ host, agent, signal }) => {
 			context.plugin((providerContext) => providerContext.provide(RUNNER_SERVER_SCOPE_SERVICE, value));
 		}],
 		activities: [runtime.activity],
-		onStart: execution ? () => runtime.ensureSession(execution.sessionId) : void 0,
+		onStart: execution ? () => {
+			runtime.ensureSession(execution.sessionId).catch((error) => process.emitWarning(`Could not initialize headless runner supervision: ${String(error)}`));
+		} : void 0,
 		onStop: runtime.dispose
 	};
 };
@@ -1164,8 +1275,8 @@ var session_compact_server_default = defineHook(({ root }) => ({
 //#region src/extensions/workspaces/sessions/(backend)/resource/po-use-runner.server.ts
 var po_use_runner_server_default = defineResource({
 	name: "po-use-runner",
-	description: "Use Doom Pi Runner to supervise shell commands, inspect durable logs, provide interactive input, and stop background runs.",
-	when: DOOM_HELP_WHEN,
+	description: "Use Po Pi Runner to supervise shell commands, inspect durable logs, provide interactive input, and stop background runs.",
+	when: PO_HELP_WHEN,
 	kind: "skill",
 	path: packageResourcePath(import.meta.url, "src/prompts/po-use-runner/SKILL.md"),
 	read: () => readPackageResource(import.meta.url, "src/prompts/po-use-runner/SKILL.md")
@@ -1176,21 +1287,24 @@ var bash_server_default = defineServerTool((context) => context.root.tool);
 //#endregion
 //#region generated/server.ts
 const at = (value, context) => typeof value === "function" ? value(context) : value;
+/* v8 ignore next -- generated normalization branch */
+const defined = (values) => values.filter((value) => value !== void 0);
 const via = (identity, value) => value === void 0 ? void 0 : {
 	...identity,
 	...value
 };
-const facet = defineServerPlugin({
+const serverPlugin = defineServerPlugin({
 	name: "@agimon-ai/po-runner",
 	providerOverrides: composeServerProviderOverrides(root_server_default),
+	injects: composeRootInjects({ session: [root_server_default] }),
 	global: () => ({ get channels() {
 		return [() => via({ frameType: "runner_runs" }, runnerRuns_server_default())];
 	} }),
-	workspace: () => ({ get channels() {
-		return [() => via({ frameType: "runner_runs" }, runnerRuns_server_default())];
+	workspace: (context) => ({ get channels() {
+		return defined([context.hosted("global") ? void 0 : () => via({ frameType: "runner_runs" }, runnerRuns_server_default())]);
 	} }),
 	session: async (context) => {
-		const scopeSession = await root_server_default(context);
+		const scopeSession = await context.scopeRoot("session", root_server_default, context);
 		const contextSession = {
 			...context,
 			root: scopeSession.value
@@ -1201,7 +1315,7 @@ const facet = defineServerPlugin({
 				return [at(route_server_default, contextSession)];
 			},
 			get channels() {
-				return [() => via({ frameType: "runner_runs" }, runnerRuns_server_default())];
+				return defined([context.hosted("global") ? void 0 : () => via({ frameType: "runner_runs" }, runnerRuns_server_default())]);
 			},
 			get commands() {
 				return [via({ name: "runners" }, at(runners_server_default, contextSession))];
@@ -1223,6 +1337,6 @@ const facet = defineServerPlugin({
 	}
 });
 //#endregion
-export { facet as default, facet };
+export { serverPlugin as default, serverPlugin };
 
 //# sourceMappingURL=server.mjs.map