@themoltnet/agent-daemon 0.49.1 → 0.51.0

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { a as cryptoService, defaultPiDaemonAdapter, i as compileExecutionPlan, n as createExecutionPlanSnapshot, r as parseCredentialRequirements, t as runtimeExecutionOffer } from "./pi.js";
 import { assertRuntimeAdapterSupportsProfile } from "./runtime.js";
+import { createRequire } from "node:module";
+import { pino, transport } from "pino";
 import { Type } from "typebox";
 import "multiformats/cid";
 import "multiformats/codecs/json";
@@ -16,7 +18,6 @@ import { constants, createReadStream, createWriteStream, existsSync, lstatSync,
 import { AuthenticationError, MoltNetError, agentKeyKey, assertTrustedConfigApiUrl, createExecutorAttestor, deriveMcpUrl, formatSecretReferenceString, identitySeedKey, parseSecretReferenceString, readConfig, register, requireSecureCredentialApiUrl, resolveAgentKey, resolveEnvSecretReference, resolveIdentitySeed, resolveOAuth2ClientSecret } from "@themoltnet/sdk";
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { once } from "node:events";
-import { pino, transport } from "pino";
 import { metrics } from "@opentelemetry/api";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
@@ -26,19 +27,20 @@ import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { mkdir, open, realpath, stat } from "node:fs/promises";
+import { mkdir, open, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
 import cors from "@fastify/cors";
 import helmet from "@fastify/helmet";
-import { getOAuthProviders } from "@earendil-works/pi-ai/oauth";
-import { AuthStorage } from "@earendil-works/pi-coding-agent";
+import { lock, lockSync } from "proper-lockfile";
+import { ModelRuntime, readStoredCredential } from "@earendil-works/pi-coding-agent";
 import { Transform, Writable } from "node:stream";
 import { writePiConfig } from "@themoltnet/pi-runtime/pi-config";
-import { homedir } from "node:os";
-import { lock } from "proper-lockfile";
+import { homedir, platform } from "node:os";
+import { pathToFileURL } from "node:url";
 import { StringDecoder } from "node:string_decoder";
 import rateLimit from "@fastify/rate-limit";
 import Fastify from "fastify";
+import { isIP } from "node:net";
 import { createGzip } from "node:zlib";
 //#region ../../libs/tasks/src/rubric.ts
 /**
@@ -800,7 +802,7 @@ Object.freeze(ALL_CREDENTIAL_SCOPES.filter((scope) => scope !== CREDENTIAL_SCOPE
 ].filter((scope) => scope !== CREDENTIAL_SCOPES.HumanProfile);
 //#endregion
 //#region ../../libs/models/src/preview-sign.ts
-function schemaRef$1(schema, id) {
+function schemaRef$2(schema, id) {
 	return Type.Unsafe(Type.Ref(id));
 }
 var PreviewSignBase64UrlSchema = Type.String({
@@ -825,8 +827,8 @@ var PreviewSignEs256PublicKeySchema = Type.Object({
 	kty: Type.Literal(2),
 	algorithm: Type.Literal(-7),
 	curve: Type.Literal(1),
-	x: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
-	y: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url")
+	x: schemaRef$2(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
+	y: schemaRef$2(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url")
 }, {
 	$id: "PreviewSignEs256PublicKey",
 	additionalProperties: false
@@ -835,8 +837,8 @@ var PreviewSignEcdhEsHkdf256PublicKeySchema = Type.Object({
 	kty: Type.Literal(2),
 	algorithm: Type.Literal(-25),
 	curve: Type.Literal(1),
-	x: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
-	y: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url")
+	x: schemaRef$2(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
+	y: schemaRef$2(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url")
 }, {
 	$id: "PreviewSignEcdhEsHkdf256PublicKey",
 	additionalProperties: false
@@ -845,8 +847,8 @@ var PreviewSignEsp256PublicKeySchema = Type.Object({
 	kty: Type.Literal(2),
 	algorithm: Type.Literal(-9),
 	curve: Type.Literal(1),
-	x: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
-	y: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url")
+	x: schemaRef$2(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
+	y: schemaRef$2(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url")
 }, {
 	$id: "PreviewSignEsp256PublicKey",
 	additionalProperties: false
@@ -855,18 +857,18 @@ var PreviewSignArkgSeedPublicKeySchema = Type.Object({
 	kty: Type.Literal(-65537),
 	algorithm: Type.Literal(-65700),
 	derivedAlgorithm: Type.Literal(-9),
-	blindingKey: schemaRef$1(PreviewSignEs256PublicKeySchema, "PreviewSignEs256PublicKey"),
-	kemKey: schemaRef$1(PreviewSignEcdhEsHkdf256PublicKeySchema, "PreviewSignEcdhEsHkdf256PublicKey")
+	blindingKey: schemaRef$2(PreviewSignEs256PublicKeySchema, "PreviewSignEs256PublicKey"),
+	kemKey: schemaRef$2(PreviewSignEcdhEsHkdf256PublicKeySchema, "PreviewSignEcdhEsHkdf256PublicKey")
 }, {
 	$id: "PreviewSignArkgSeedPublicKey",
 	additionalProperties: false
 });
 var PreviewSignPublicMaterialSchema = Type.Object({
 	version: Type.Literal(1),
-	outerCredentialId: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
-	outerPublicKey: schemaRef$1(PreviewSignEs256PublicKeySchema, "PreviewSignEs256PublicKey"),
-	previewKeyHandle: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
-	seedPublicKey: schemaRef$1(PreviewSignArkgSeedPublicKeySchema, "PreviewSignArkgSeedPublicKey")
+	outerCredentialId: schemaRef$2(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
+	outerPublicKey: schemaRef$2(PreviewSignEs256PublicKeySchema, "PreviewSignEs256PublicKey"),
+	previewKeyHandle: schemaRef$2(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
+	seedPublicKey: schemaRef$2(PreviewSignArkgSeedPublicKeySchema, "PreviewSignArkgSeedPublicKey")
 }, {
 	$id: "PreviewSignPublicMaterial",
 	additionalProperties: false
@@ -874,19 +876,19 @@ var PreviewSignPublicMaterialSchema = Type.Object({
 var PreviewSignChallengeSchema = Type.Object({
 	verificationMethod: Type.Literal("human-hardware-previewsign"),
 	version: Type.Literal(1),
-	envelope: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
-	digest: schemaRef$1(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
-	additionalArguments: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
-	outerCredentialId: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
-	outerPublicKey: schemaRef$1(PreviewSignEs256PublicKeySchema, "PreviewSignEs256PublicKey"),
-	previewKeyHandle: schemaRef$1(PreviewSignBase64UrlSchema, "PreviewSignBase64Url")
+	envelope: schemaRef$2(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
+	digest: schemaRef$2(PreviewSignSha256Base64UrlSchema, "PreviewSignSha256Base64Url"),
+	additionalArguments: schemaRef$2(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
+	outerCredentialId: schemaRef$2(PreviewSignBase64UrlSchema, "PreviewSignBase64Url"),
+	outerPublicKey: schemaRef$2(PreviewSignEs256PublicKeySchema, "PreviewSignEs256PublicKey"),
+	previewKeyHandle: schemaRef$2(PreviewSignBase64UrlSchema, "PreviewSignBase64Url")
 }, {
 	$id: "PreviewSignChallenge",
 	additionalProperties: false
 });
 var PreviewSignChallengeValueSchema = Type.Object({
 	verificationMethod: Type.Literal("human-hardware-previewsign"),
-	value: schemaRef$1(PreviewSignChallengeSchema, "PreviewSignChallenge")
+	value: schemaRef$2(PreviewSignChallengeSchema, "PreviewSignChallenge")
 }, {
 	$id: "PreviewSignChallengeValue",
 	additionalProperties: false
@@ -894,14 +896,14 @@ var PreviewSignChallengeValueSchema = Type.Object({
 var PreviewSignChallengeOperationSchema = Type.Union([Type.Literal("credential-registration"), Type.Literal("signing-request")], { $id: "PreviewSignChallengeOperation" });
 var PreviewSignReceiptSchema = Type.Object({
 	version: Type.Literal(1),
-	signature: schemaRef$1(PreviewSignP256DerSignatureBase64UrlSchema, "PreviewSignP256DerSignatureBase64Url")
+	signature: schemaRef$2(PreviewSignP256DerSignatureBase64UrlSchema, "PreviewSignP256DerSignatureBase64Url")
 }, {
 	$id: "PreviewSignReceipt",
 	additionalProperties: false
 });
 var PreviewSignReceiptValueSchema = Type.Object({
 	verificationMethod: Type.Literal("human-hardware-previewsign"),
-	value: schemaRef$1(PreviewSignReceiptSchema, "PreviewSignReceipt")
+	value: schemaRef$2(PreviewSignReceiptSchema, "PreviewSignReceipt")
 }, {
 	$id: "PreviewSignReceiptValue",
 	additionalProperties: false
@@ -1595,7 +1597,7 @@ Type.Union([
 ]);
 //#endregion
 //#region ../../libs/models/src/signer-protocol.ts
-function schemaRef(schema) {
+function schemaRef$1(schema) {
 	const id = schemaId(schema);
 	return Type.Ref(id);
 }
@@ -1624,13 +1626,13 @@ var SignerProblemSchema = Type.Object({
 	$id: "SignerProblem",
 	additionalProperties: false
 });
-var SignerCeremonyParamsSchema = Type.Object({ ceremonyId: Type.Unsafe(schemaRef(SignerBase64UrlSchema)) }, {
+var SignerCeremonyParamsSchema = Type.Object({ ceremonyId: Type.Unsafe(schemaRef$1(SignerBase64UrlSchema)) }, {
 	$id: "SignerCeremonyParams",
 	additionalProperties: false
 });
 var SignerSessionSchema = Type.Object({
 	version: Type.Literal(1),
-	token: Type.Unsafe(schemaRef(SignerBase64UrlSchema)),
+	token: Type.Unsafe(schemaRef$1(SignerBase64UrlSchema)),
 	expiresAt: Type.String()
 }, {
 	$id: "SignerSession",
@@ -1643,25 +1645,25 @@ var SignerEnrollmentCeremonyRequestSchema = Type.Object({
 		minLength: 1,
 		maxLength: 255
 	}),
-	teamId: Type.Unsafe(schemaRef(SignerUuidSchema))
+	teamId: Type.Unsafe(schemaRef$1(SignerUuidSchema))
 }, {
 	$id: "SignerEnrollmentCeremonyRequest",
 	additionalProperties: false
 });
 var SignerChallengeCeremonyRequestSchema = Type.Object({
 	version: Type.Literal(1),
-	operation: Type.Unsafe(schemaRef(SignerChallengeOperationSchema)),
-	resourceId: Type.Unsafe(schemaRef(SignerUuidSchema)),
-	challenge: Type.Unsafe(schemaRef(SignerPreviewSignChallengeValueSchema))
+	operation: Type.Unsafe(schemaRef$1(SignerChallengeOperationSchema)),
+	resourceId: Type.Unsafe(schemaRef$1(SignerUuidSchema)),
+	challenge: Type.Unsafe(schemaRef$1(SignerPreviewSignChallengeValueSchema))
 }, {
 	$id: "SignerChallengeCeremonyRequest",
 	additionalProperties: false
 });
-var SignerCeremonyRequestSchema = Type.Union([Type.Unsafe(schemaRef(SignerEnrollmentCeremonyRequestSchema)), Type.Unsafe(schemaRef(SignerChallengeCeremonyRequestSchema))], { $id: "SignerCeremonyRequest" });
+var SignerCeremonyRequestSchema = Type.Union([Type.Unsafe(schemaRef$1(SignerEnrollmentCeremonyRequestSchema)), Type.Unsafe(schemaRef$1(SignerChallengeCeremonyRequestSchema))], { $id: "SignerCeremonyRequest" });
 var SignerCeremonySchema = Type.Object({
 	version: Type.Literal(1),
-	id: Type.Unsafe(schemaRef(SignerBase64UrlSchema)),
-	operation: Type.Unsafe(schemaRef(SignerOperationSchema)),
+	id: Type.Unsafe(schemaRef$1(SignerBase64UrlSchema)),
+	operation: Type.Unsafe(schemaRef$1(SignerOperationSchema)),
 	approvalUrl: Type.String(),
 	expiresAt: Type.String()
 }, {
@@ -1671,7 +1673,7 @@ var SignerCeremonySchema = Type.Object({
 var SignerPendingResultSchema = Type.Object({
 	version: Type.Literal(1),
 	status: Type.Literal("pending"),
-	operation: Type.Unsafe(schemaRef(SignerOperationSchema))
+	operation: Type.Unsafe(schemaRef$1(SignerOperationSchema))
 }, {
 	$id: "SignerPendingResult",
 	additionalProperties: false
@@ -1680,7 +1682,7 @@ var SignerEnrollmentResultSchema = Type.Object({
 	version: Type.Literal(1),
 	status: Type.Literal("completed"),
 	operation: Type.Literal("credential-enrollment"),
-	publicMaterial: Type.Unsafe(schemaRef(SignerPreviewSignPublicMaterialSchema))
+	publicMaterial: Type.Unsafe(schemaRef$1(SignerPreviewSignPublicMaterialSchema))
 }, {
 	$id: "SignerEnrollmentResult",
 	additionalProperties: false
@@ -1689,8 +1691,8 @@ var SignerReceiptSchema = PreviewSignReceiptValueSchema;
 var SignerSignatureResultSchema = Type.Object({
 	version: Type.Literal(1),
 	status: Type.Literal("completed"),
-	operation: Type.Unsafe(schemaRef(SignerChallengeOperationSchema)),
-	receipt: Type.Unsafe(schemaRef(SignerReceiptSchema))
+	operation: Type.Unsafe(schemaRef$1(SignerChallengeOperationSchema)),
+	receipt: Type.Unsafe(schemaRef$1(SignerReceiptSchema))
 }, {
 	$id: "SignerSignatureResult",
 	additionalProperties: false
@@ -1698,7 +1700,7 @@ var SignerSignatureResultSchema = Type.Object({
 var SignerFailedResultSchema = Type.Object({
 	version: Type.Literal(1),
 	status: Type.Literal("failed"),
-	operation: Type.Unsafe(schemaRef(SignerOperationSchema)),
+	operation: Type.Unsafe(schemaRef$1(SignerOperationSchema)),
 	code: Type.String(),
 	message: Type.String()
 }, {
@@ -1706,10 +1708,10 @@ var SignerFailedResultSchema = Type.Object({
 	additionalProperties: false
 });
 var SignerCeremonyResultSchema = Type.Union([
-	Type.Unsafe(schemaRef(SignerPendingResultSchema)),
-	Type.Unsafe(schemaRef(SignerEnrollmentResultSchema)),
-	Type.Unsafe(schemaRef(SignerSignatureResultSchema)),
-	Type.Unsafe(schemaRef(SignerFailedResultSchema))
+	Type.Unsafe(schemaRef$1(SignerPendingResultSchema)),
+	Type.Unsafe(schemaRef$1(SignerEnrollmentResultSchema)),
+	Type.Unsafe(schemaRef$1(SignerSignatureResultSchema)),
+	Type.Unsafe(schemaRef$1(SignerFailedResultSchema))
 ], { $id: "SignerCeremonyResult" });
 ({ ...previewSignSchemaContext }), schemaId(SignerUuidSchema), schemaId(SignerOperationSchema), schemaId(SignerProblemSchema), schemaId(SignerCeremonyParamsSchema), schemaId(SignerSessionSchema), schemaId(SignerEnrollmentCeremonyRequestSchema), schemaId(SignerChallengeCeremonyRequestSchema), schemaId(SignerCeremonyRequestSchema), schemaId(SignerCeremonySchema), schemaId(SignerPendingResultSchema), schemaId(SignerEnrollmentResultSchema), schemaId(SignerSignatureResultSchema), schemaId(SignerFailedResultSchema), schemaId(SignerCeremonyResultSchema);
 //#endregion
@@ -3426,11 +3428,13 @@ Commands:
   once      Claim and execute one specific queued task by id, then exit.
   drain     Poll until the queue has nothing claimable, then exit.
             Useful for batch eval runs and demos.
-  serve     Loopback supervisor for console-managed runs: pairing,
+  server    Loopback supervisor for console-managed runs: pairing,
             agent/provider config store, and start/stop of poll/drain
             child processes. Binds 127.0.0.1 only.
   sync-sessions
             Repair durable runtime-session checkpoints from local slot files.
+  update check
+            Check the stable MoltNet agent release without reading credentials.
 
 Run \`agent-daemon <command> --help\` for command-specific flags.
 
@@ -3561,8 +3565,8 @@ Example:
 function isHelpFlag(args) {
 	return args.includes("--help") || args.includes("-h");
 }
-var SERVE_HELP = `\
-agent-daemon serve — loopback supervisor for console-managed runs.
+var AGENT_SERVER_HELP = `\
+agent-daemon server — loopback supervisor for console-managed runs.
 
 Binds 127.0.0.1 only. A paired Console origin configures agents and
 providers (secret references only) and starts/stops poll/drain runs as
@@ -3570,12 +3574,12 @@ child processes of this supervisor.
 
 Options:
   --port <n>                  Loopback port. Default: 17374.
-                              Env: MOLTNET_SERVE_PORT.
+                              Env: MOLTNET_AGENT_SERVER_PORT.
   --allowed-origins <csv>     Exact Console origins allowed to pair.
                               Default: https://console.themolt.net.
-                              Env: MOLTNET_SERVE_ALLOWED_ORIGINS.
+                              Env: MOLTNET_AGENT_SERVER_ALLOWED_ORIGINS.
   --root <path>               Config root. Default: ~/.config/moltnet
-                              (or MOLTNET_SERVE_ROOT).
+                              (or MOLTNET_AGENT_SERVER_ROOT).
   --api-url <url>             Default MoltNet API for new managed agents.
                               Default: https://api.themolt.net.
 `;
@@ -3658,7 +3662,7 @@ async function validateStartupBinding(options) {
 	const assessment = assessStartupBinding(whoami, options.teamId);
 	if (!assessment.ok) throw new Error(`Daemon startup validation failed: ${assessment.reason}`);
 	const expected = options.expectedIdentity;
-	if (expected && !assessIdentityPin(whoami, expected).ok) throw new Error("Daemon startup validation failed: authenticated identity does not match the serve activation.");
+	if (expected && !assessIdentityPin(whoami, expected).ok) throw new Error("Daemon startup validation failed: authenticated identity does not match the Agent Server activation.");
 	return whoami;
 }
 /**
@@ -3784,20 +3788,26 @@ function readBoolean(name, value) {
 function activatePiCodingAgentDir(path) {
 	process.env["PI_CODING_AGENT_DIR"] = path;
 }
-function loadServeEnvConfig() {
+function loadAgentServerEnvConfig() {
 	return {
-		port: process.env["MOLTNET_SERVE_PORT"] ?? "",
-		allowedOrigins: process.env["MOLTNET_SERVE_ALLOWED_ORIGINS"] ?? "",
-		root: process.env["MOLTNET_SERVE_ROOT"] ?? "",
+		port: process.env["MOLTNET_AGENT_SERVER_PORT"] ?? "",
+		allowedOrigins: process.env["MOLTNET_AGENT_SERVER_ALLOWED_ORIGINS"] ?? "",
+		root: process.env["MOLTNET_AGENT_SERVER_ROOT"] ?? "",
 		xdgConfigHome: process.env["XDG_CONFIG_HOME"] ?? "",
 		apiUrl: process.env["MOLTNET_API_URL"] ?? "",
 		logLevel: process.env["LOG_LEVEL"] ?? ""
 	};
 }
-/** Full process environment for spawned serve run children. */
+/** Full process environment for spawned Agent Server run children. */
 function processEnvSnapshot() {
 	return process.env;
 }
+function loadUpdateEnvConfig() {
+	return {
+		xdgCacheHome: process.env["XDG_CACHE_HOME"] ?? "",
+		localAppData: process.env["LOCALAPPDATA"] ?? ""
+	};
+}
 //#endregion
 //#region src/lib/abort-active-attempt.ts
 /** Best-effort signal cleanup; lease expiry remains the final backstop. */
@@ -4859,7 +4869,7 @@ function executionIntentFromRuntimeProfile(input) {
 * local configuration and logs its value-free decisions. It gates nothing
 * yet — enforcement is a separate, later change.
 */
-var DEFAULT_GOVERNANCE_OBSERVE_TIMEOUT_MS = 2e3;
+var DEFAULT_GOVERNANCE_OBAGENT_SERVER_TIMEOUT_MS = 2e3;
 /**
 * Two distinct provenance sources (#2022 review): requirements come from a
 * profile-side/private input (`MOLTNET_PROFILE_CREDENTIAL_REQUIREMENTS`, a
@@ -4988,7 +4998,7 @@ async function observeGovernancePlan(input) {
 * The observer is intentionally non-gating: failures and deadlines are logged
 * with claim correlation and converted to `null`.
 */
-async function observeGovernancePlanSafely(input, timeoutMs = DEFAULT_GOVERNANCE_OBSERVE_TIMEOUT_MS) {
+async function observeGovernancePlanSafely(input, timeoutMs = DEFAULT_GOVERNANCE_OBAGENT_SERVER_TIMEOUT_MS) {
 	let timeout;
 	try {
 		return await Promise.race([observeGovernancePlan(input), new Promise((_resolve, reject) => {
@@ -7056,6 +7066,8 @@ function requireOriginHeader(headers) {
 //#endregion
 //#region ../../libs/loopback-companion/src/fastify.ts
 var CORS_PREFLIGHT_MAX_AGE_SECONDS = 600;
+var PRIVATE_NETWORK_REQUEST_HEADER = "access-control-request-private-network";
+var PRIVATE_NETWORK_ALLOW_HEADER = "access-control-allow-private-network";
 /**
 * Enforce that the `Host` header identifies loopback. Blocks DNS-rebinding
 * setups where a public hostname resolves to 127.0.0.1: the browser then
@@ -7093,8 +7105,9 @@ function registerLoopbackSecurity(app, options) {
 		requireLoopbackHost(request);
 		done();
 	});
-	app.addHook("onSend", async (_request, reply, payload) => {
+	app.addHook("onSend", async (request, reply, payload) => {
 		reply.header("cache-control", "no-store");
+		if (request.method === "OPTIONS" && request.headers[PRIVATE_NETWORK_REQUEST_HEADER] === "true" && reply.getHeader("access-control-allow-origin") === request.headers.origin) reply.header(PRIVATE_NETWORK_ALLOW_HEADER, "true");
 		return payload;
 	});
 	app.removeContentTypeParser("application/json");
@@ -7170,9 +7183,65 @@ function rejectExplicitCrossSite(headers) {
 	if (headerValue(headers, "sec-fetch-site") === "cross-site") throw new LoopbackViolationError("cross_site_rejected", "Request must not originate cross-site");
 }
 //#endregion
-//#region src/lib/serve/pairing.ts
+//#region src/lib/agent-server/lock.ts
+var AgentServerLockError = class extends Error {
+	name = "AgentServerLockError";
+	constructor(code, message, options) {
+		super(message, options);
+		this.code = code;
+	}
+};
 /**
-* One-click pairing ceremony for the serve supervisor, mirroring the signer's
+* Acquire the per-root singleton lock. `proper-lockfile` uses an atomic lock
+* directory at exactly `<root>/agent-server.lock`, recovers stale owners, and keeps
+* the mtime fresh while the supervisor is alive.
+*/
+async function acquireAgentServerLock(root, options = {}) {
+	const path = join(root, "agent-server.lock");
+	let releaseLock;
+	try {
+		releaseLock = await lock(root, {
+			lockfilePath: path,
+			realpath: false,
+			retries: 0,
+			...options.staleMs === void 0 ? {} : { stale: options.staleMs },
+			...options.updateMs === void 0 ? {} : { update: options.updateMs },
+			onCompromised: (cause) => {
+				const error = new AgentServerLockError("compromised", `Agent Server lock ${path} was compromised: ${cause.message}`, { cause });
+				if (options.onCompromised) {
+					options.onCompromised(error);
+					return;
+				}
+				throw error;
+			}
+		});
+	} catch (cause) {
+		if (cause.code === "ELOCKED") throw new AgentServerLockError("held", `another moltnet-agent server process already owns ${path}`, { cause });
+		throw new AgentServerLockError("failed", `could not acquire Agent Server lock ${path}: ${cause.message}`, { cause });
+	}
+	let released = false;
+	return {
+		path,
+		async release() {
+			if (released) return;
+			released = true;
+			await releaseLock();
+		}
+	};
+}
+/** Always release after normal completion or startup/runtime failure. */
+async function withAgentServerLock(root, work, options) {
+	const held = await acquireAgentServerLock(root, options);
+	try {
+		return await work();
+	} finally {
+		await held.release();
+	}
+}
+//#endregion
+//#region src/lib/agent-server/pairing.ts
+/**
+* One-click pairing ceremony for the agent server, mirroring the signer's
 * session/ceremony pattern (#2062 design):
 *
 *   1. Console (allowed origin) POSTs `/v1/pairings` → pending pairing bound
@@ -7193,8 +7262,8 @@ function rejectExplicitCrossSite(headers) {
 * supervisor process.
 */
 var PENDING_TTL_MS = 600 * 1e3;
-var ServePairingError = class extends Error {
-	name = "ServePairingError";
+var AgentServerPairingError = class extends Error {
+	name = "AgentServerPairingError";
 	constructor(code, message) {
 		super(message);
 		this.code = code;
@@ -7242,7 +7311,7 @@ var PairingService = class {
 	/** Data for the local approval page. */
 	approval(pairingId) {
 		const pairing = this.require(pairingId);
-		if (pairing.approved) throw new ServePairingError("pairing_invalid", "Pairing is already approved");
+		if (pairing.approved) throw new AgentServerPairingError("pairing_invalid", "Pairing is already approved");
 		return {
 			origin: pairing.origin,
 			confirmToken: pairing.confirmToken
@@ -7250,15 +7319,15 @@ var PairingService = class {
 	}
 	confirm(pairingId, confirmToken) {
 		const pairing = this.require(pairingId);
-		if (pairing.approved || !safeEqual(pairing.confirmToken, confirmToken)) throw new ServePairingError("pairing_invalid", "Confirmation token is not valid");
+		if (pairing.approved || !safeEqual(pairing.confirmToken, confirmToken)) throw new AgentServerPairingError("pairing_invalid", "Confirmation token is not valid");
 		pairing.approved = true;
 		pairing.bearerToken = this.token();
 		return { origin: pairing.origin };
 	}
 	claim(pairingId, origin) {
 		const pairing = this.require(pairingId);
-		if (pairing.origin !== origin) throw new ServePairingError("pairing_origin_mismatch", "Pairing belongs to a different origin");
-		if (!pairing.approved || !pairing.bearerToken) throw new ServePairingError("pairing_not_approved", "Pairing has not been approved yet");
+		if (pairing.origin !== origin) throw new AgentServerPairingError("pairing_origin_mismatch", "Pairing belongs to a different origin");
+		if (!pairing.approved || !pairing.bearerToken) throw new AgentServerPairingError("pairing_not_approved", "Pairing has not been approved yet");
 		const token = pairing.bearerToken;
 		this.pending.delete(pairingId);
 		this.paired.set(origin, sha256Hex(token));
@@ -7266,12 +7335,12 @@ var PairingService = class {
 	}
 	verify(origin, token) {
 		const tokenHash = this.paired.get(origin);
-		if (!tokenHash || !safeEqual(tokenHash, sha256Hex(token))) throw new ServePairingError("pairing_token_invalid", "Pairing token is not valid for this origin");
+		if (!tokenHash || !safeEqual(tokenHash, sha256Hex(token))) throw new AgentServerPairingError("pairing_token_invalid", "Pairing token is not valid for this origin");
 	}
 	require(pairingId) {
 		this.sweep();
 		const pairing = this.pending.get(pairingId);
-		if (!pairing) throw new ServePairingError("pairing_not_found", "Pairing was not found or has expired");
+		if (!pairing) throw new AgentServerPairingError("pairing_not_found", "Pairing was not found or has expired");
 		return pairing;
 	}
 };
@@ -7321,24 +7390,25 @@ function renderPairingResultPage(input) {
 `;
 }
 //#endregion
-//#region src/lib/serve/provider-login.ts
+//#region src/lib/agent-server/provider-login.ts
 /**
-* Subscription-provider OAuth brokering for `serve` (#2061 slice 4).
+* Subscription-provider OAuth brokering for Agent Server (#2061 slice 4).
 *
-* The console clicks "Connect"; serve runs the Pi OAuth flow host-side via
-* `AuthStorage.login()` (which owns persistence into the shared
+* The console clicks "Connect"; agent server runs the Pi OAuth flow host-side via
+* `ModelRuntime.login()` (which owns persistence into the shared
 * `pi/auth.json` and token rotation thereafter). The browser only ever sees
 * the provider's authorize URL or device code — never tokens.
 *
-* Provider ids come from pi-ai's own OAuth registry (`getOAuthProviders`),
-* so serve stays in lockstep with what Pi can actually authenticate
-* (anthropic, openai-codex, github-copilot, …) without hardcoding.
+* Provider ids come from Pi's model runtime, so Agent Server stays in lockstep
+* with supported subscription providers. GitHub Copilot is intentionally
+* excluded: MoltNet does not broker editor-seat subscription credentials.
 */
 var LOGIN_TTL_MS = 600 * 1e3;
 /** How long `start()` waits for the flow to surface a URL / device code. */
 var START_INFO_TIMEOUT_MS = 5e3;
-var ServeSubscriptionError = class extends Error {
-	name = "ServeSubscriptionError";
+var EXCLUDED_SUBSCRIPTION_PROVIDERS = new Set(["github-copilot"]);
+var AgentServerSubscriptionError = class extends Error {
+	name = "AgentServerSubscriptionError";
 	constructor(code, message) {
 		super(message);
 		this.code = code;
@@ -7349,37 +7419,49 @@ var silentLogger = {
 	warn: () => void 0,
 	error: () => void 0
 };
-var ProviderLoginService = class {
+var ProviderLoginService = class ProviderLoginService {
 	logins = /* @__PURE__ */ new Map();
-	authStorage;
 	logger;
 	constructor(options) {
 		this.options = options;
-		this.authStorage = options.authStorage ?? AuthStorage.create(this.options.authPath);
 		this.logger = options.logger ?? silentLogger;
 	}
+	static async create(options) {
+		const modelRuntime = await ModelRuntime.create({
+			authPath: options.authPath,
+			refreshOnCreate: false
+		});
+		return new ProviderLoginService({
+			...options,
+			modelRuntime
+		});
+	}
 	now() {
 		return this.options.now?.() ?? Date.now();
 	}
 	providers() {
-		return this.options.listProviders?.() ?? getOAuthProviders().map((provider) => ({
+		return (this.options.listProviders ? this.options.listProviders() : this.runtime().getProviders().filter((provider) => provider.auth.oauth !== void 0).map((provider) => ({
 			id: provider.id,
 			name: provider.name
-		}));
+		}))).filter((provider) => !EXCLUDED_SUBSCRIPTION_PROVIDERS.has(provider.id));
 	}
 	connected(providerId) {
 		if (this.options.isConnected) return this.options.isConnected(providerId);
 		try {
-			return (this.options.authStorage ? this.authStorage : AuthStorage.create(this.options.authPath)).getAuthStatus(providerId).configured;
+			return readStoredCredential(providerId, this.options.authPath) !== void 0;
 		} catch (error) {
 			this.logger.warn({
-				event: "serve.subscription_auth_read_failed",
+				event: "agent-server.subscription_auth_read_failed",
 				providerId,
 				...safeLoginError(error)
 			}, "Could not read subscription authentication state");
 			return false;
 		}
 	}
+	runtime() {
+		if (!this.options.modelRuntime) throw new Error("ProviderLoginService requires a model runtime when production adapters are not overridden");
+		return this.options.modelRuntime;
+	}
 	list() {
 		this.sweep();
 		return this.providers().map((provider) => ({
@@ -7390,40 +7472,42 @@ var ProviderLoginService = class {
 	sweep() {
 		const now = this.now();
 		for (const [id, login] of this.logins) if (login.startedAt + LOGIN_TTL_MS <= now) {
-			this.invalidate(login, "expired");
+			if (login.status === "pending") this.invalidate(login, "expired");
 			this.logins.delete(id);
 		}
 	}
 	restoreCredential(login) {
 		try {
-			if (login.previousCredential) this.authStorage.set(login.providerId, login.previousCredential);
-			else this.authStorage.logout(login.providerId);
+			restoreStoredCredential(this.options.authPath, login.providerId, login.previousCredential);
+			return true;
 		} catch (error) {
 			this.logger.error({
-				event: "serve.subscription_login_cleanup_failed",
+				event: "agent-server.subscription_login_cleanup_failed",
 				operationId: login.operationId,
 				providerId: login.providerId,
 				...safeLoginError(error)
 			}, "Could not restore subscription credentials after an invalidated login");
+			return false;
 		}
 	}
 	invalidate(login, transition) {
-		if (login.invalidated) return;
+		if (login.invalidated) return true;
 		login.invalidated = true;
 		login.abort.abort(/* @__PURE__ */ new Error(`subscription login ${transition}`));
-		this.restoreCredential(login);
+		const restored = this.restoreCredential(login);
 		login.infoArrived();
 		this.logger.info({
-			event: "serve.subscription_login_transition",
+			event: "agent-server.subscription_login_transition",
 			operationId: login.operationId,
 			providerId: login.providerId,
 			transition
 		}, "Subscription login invalidated");
+		return restored;
 	}
 	status(providerId) {
 		this.sweep();
 		const login = this.logins.get(providerId);
-		if (!login) throw new ServeSubscriptionError("login_not_found", `no login in progress for "${providerId}"`);
+		if (!login) throw new AgentServerSubscriptionError("login_not_found", `no login in progress for "${providerId}"`);
 		return snapshot(login);
 	}
 	/**
@@ -7433,7 +7517,7 @@ var ProviderLoginService = class {
 	*/
 	async start(providerId) {
 		this.sweep();
-		if (!this.providers().some((provider) => provider.id === providerId)) throw new ServeSubscriptionError("provider_unknown", `"${providerId}" is not a known subscription provider`);
+		if (!this.providers().some((provider) => provider.id === providerId)) throw new AgentServerSubscriptionError("provider_unknown", `"${providerId}" is not a known subscription provider`);
 		const existing = this.logins.get(providerId);
 		if (existing && existing.status === "pending") return snapshot(existing);
 		let infoArrived = () => void 0;
@@ -7449,17 +7533,17 @@ var ProviderLoginService = class {
 			infoArrived,
 			abort,
 			invalidated: false,
-			previousCredential: this.authStorage.get(providerId)
+			previousCredential: readStoredCredential(providerId, this.options.authPath)
 		};
 		this.logins.set(providerId, login);
 		this.logger.info({
-			event: "serve.subscription_login_transition",
+			event: "agent-server.subscription_login_transition",
 			operationId: login.operationId,
 			providerId,
 			transition: "started"
 		}, "Subscription login started");
 		const callbacks = createLoginCallbacks(login, this.logger);
-		(this.options.runLogin ?? ((id, loginCallbacks) => this.authStorage.login(id, loginCallbacks)))(providerId, callbacks).then(() => {
+		(this.options.runLogin ?? ((id, loginCallbacks) => this.runtime().login(id, "oauth", toAuthInteraction(loginCallbacks)).then(() => void 0)))(providerId, callbacks).then(() => {
 			if (login.invalidated) {
 				this.restoreCredential(login);
 				return;
@@ -7468,7 +7552,7 @@ var ProviderLoginService = class {
 				login.status = "failed";
 				login.error = "Subscription sign-in completed, but credentials were not persisted. Start again to retry.";
 				this.logger.error({
-					event: "serve.subscription_login_transition",
+					event: "agent-server.subscription_login_transition",
 					operationId: login.operationId,
 					providerId,
 					transition: "persistence_failed"
@@ -7476,7 +7560,7 @@ var ProviderLoginService = class {
 			} else {
 				login.status = "completed";
 				this.logger.info({
-					event: "serve.subscription_login_transition",
+					event: "agent-server.subscription_login_transition",
 					operationId: login.operationId,
 					providerId,
 					transition: "completed"
@@ -7491,7 +7575,7 @@ var ProviderLoginService = class {
 			login.status = "failed";
 			login.error = publicLoginError(error);
 			this.logger.warn({
-				event: "serve.subscription_login_transition",
+				event: "agent-server.subscription_login_transition",
 				operationId: login.operationId,
 				providerId,
 				transition: "failed",
@@ -7499,16 +7583,24 @@ var ProviderLoginService = class {
 			}, "Subscription login failed");
 			login.infoArrived();
 		});
-		await Promise.race([infoPromise, new Promise((resolvePromise) => {
-			setTimeout(resolvePromise, START_INFO_TIMEOUT_MS).unref?.();
-		})]);
+		if (!await Promise.race([infoPromise, new Promise((resolvePromise) => {
+			setTimeout(() => resolvePromise(), START_INFO_TIMEOUT_MS).unref?.();
+		})]).then(() => login.authUrl !== void 0 || login.userCode !== void 0 || login.status !== "pending")) {
+			login.waitingForAuthorization = true;
+			this.logger.warn({
+				event: "serve.subscription_login_start_info_timeout",
+				operationId: login.operationId,
+				providerId,
+				timeoutMs: START_INFO_TIMEOUT_MS
+			}, "Subscription login is still waiting for authorization information");
+		}
 		return snapshot(login);
 	}
 	/** Abort an in-flight login and forget it. */
 	cancel(providerId) {
 		const login = this.logins.get(providerId);
-		if (!login) throw new ServeSubscriptionError("login_not_found", `no login in progress for "${providerId}"`);
-		this.invalidate(login, "cancelled");
+		if (!login) throw new AgentServerSubscriptionError("login_not_found", `no login in progress for "${providerId}"`);
+		if (!this.invalidate(login, "cancelled")) throw new AgentServerSubscriptionError("login_cleanup_failed", `could not safely cancel login for "${providerId}"; credential cleanup requires intervention`);
 		this.logins.delete(providerId);
 		return {
 			providerId,
@@ -7517,17 +7609,82 @@ var ProviderLoginService = class {
 	}
 	/** Abort every pending flow during supervisor shutdown. */
 	close() {
-		for (const login of this.logins.values()) this.invalidate(login, "shutdown");
+		for (const login of this.logins.values()) if (login.status === "pending") this.invalidate(login, "shutdown");
 		this.logins.clear();
 	}
 };
+function toAuthInteraction(callbacks) {
+	return {
+		...callbacks.signal ? { signal: callbacks.signal } : {},
+		notify: (event) => {
+			switch (event.type) {
+				case "auth_url":
+					callbacks.onAuth({
+						url: event.url,
+						...event.instructions ? { instructions: event.instructions } : {}
+					});
+					break;
+				case "device_code":
+					callbacks.onDeviceCode({
+						userCode: event.userCode,
+						verificationUri: event.verificationUri
+					});
+					break;
+				case "info":
+				case "progress":
+					callbacks.onProgress?.(event.message);
+					break;
+			}
+		},
+		prompt: async (prompt) => {
+			if (prompt.type !== "select") return callbacks.onPrompt({ message: prompt.message });
+			const selected = await callbacks.onSelect({
+				message: prompt.message,
+				options: prompt.options.map(({ id, label }) => ({
+					id,
+					label
+				}))
+			});
+			if (!selected) throw new AgentServerSubscriptionError("login_unsupported_prompt", "This provider flow did not offer a supported sign-in method");
+			return selected;
+		}
+	};
+}
+function restoreStoredCredential(authPath, providerId, credential) {
+	mkdirSync(dirname(authPath), {
+		recursive: true,
+		mode: 448
+	});
+	try {
+		writeFileSync(authPath, "{}\n", {
+			flag: "wx",
+			mode: 384
+		});
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+	}
+	const release = lockSync(authPath, { realpath: false });
+	const temp = `${authPath}.${randomBytes(6).toString("hex")}.tmp`;
+	try {
+		const parsed = JSON.parse(readFileSync(authPath, "utf8"));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Pi credential store is not an object: ${authPath}`);
+		const credentials = parsed;
+		if (credential) credentials[providerId] = credential;
+		else delete credentials[providerId];
+		writeFileSync(temp, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 384 });
+		renameSync(temp, authPath);
+	} finally {
+		rmSync(temp, { force: true });
+		release();
+	}
+}
 function createLoginCallbacks(login, logger) {
 	return {
 		onAuth: (info) => {
 			login.authUrl = info.url;
 			if (info.instructions) login.instructions = info.instructions;
 			logger.info({
-				event: "serve.subscription_login_transition",
+				event: "agent-server.subscription_login_transition",
 				operationId: login.operationId,
 				providerId: login.providerId,
 				transition: "authorization_ready"
@@ -7538,20 +7695,20 @@ function createLoginCallbacks(login, logger) {
 			login.userCode = info.userCode;
 			login.verificationUri = info.verificationUri;
 			logger.info({
-				event: "serve.subscription_login_transition",
+				event: "agent-server.subscription_login_transition",
 				operationId: login.operationId,
 				providerId: login.providerId,
 				transition: "device_code_ready"
 			}, "Subscription device code ready");
 			login.infoArrived();
 		},
-		onPrompt: () => Promise.reject(new ServeSubscriptionError("login_unsupported_prompt", "This provider flow needs an interactive prompt; run `pi /login` in a terminal instead")),
+		onPrompt: () => Promise.reject(new AgentServerSubscriptionError("login_unsupported_prompt", "This provider flow needs an interactive prompt; run `pi /login` in a terminal instead")),
 		onSelect: (prompt) => Promise.resolve((prompt.options.find((option) => /device/i.test(option.id)) ?? prompt.options[0])?.id),
 		signal: login.abort.signal
 	};
 }
 function publicLoginError(error) {
-	if (error instanceof ServeSubscriptionError) return error.message;
+	if (error instanceof AgentServerSubscriptionError) return error.message;
 	return "Subscription sign-in failed. Start again to retry.";
 }
 function safeLoginError(error) {
@@ -7561,7 +7718,7 @@ function safeLoginError(error) {
 	return result;
 }
 function snapshot(login) {
-	const { providerId, status, authUrl, instructions, userCode, verificationUri, error } = login;
+	const { providerId, status, authUrl, instructions, userCode, verificationUri, error, waitingForAuthorization } = login;
 	return {
 		providerId,
 		status,
@@ -7569,28 +7726,29 @@ function snapshot(login) {
 		...instructions ? { instructions } : {},
 		...userCode ? { userCode } : {},
 		...verificationUri ? { verificationUri } : {},
-		...error ? { error } : {}
+		...error ? { error } : {},
+		...waitingForAuthorization ? { waitingForAuthorization } : {}
 	};
 }
 var NAME_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/i;
 var PROVIDER_ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 function assertStoreName(kind, value) {
-	if (!NAME_RE.test(value)) throw new ServeStoreError("invalid_name", `${kind} must match ${NAME_RE.source}`);
+	if (!NAME_RE.test(value)) throw new AgentServerStoreError("invalid_name", `${kind} must match ${NAME_RE.source}`);
 	return value;
 }
 function assertProviderId(value) {
-	if (!PROVIDER_ID_RE.test(value)) throw new ServeStoreError("invalid_name", `provider id must match ${PROVIDER_ID_RE.source}`);
+	if (!PROVIDER_ID_RE.test(value)) throw new AgentServerStoreError("invalid_name", `provider id must match ${PROVIDER_ID_RE.source}`);
 	return value;
 }
-var ServeStoreError = class extends Error {
-	name = "ServeStoreError";
+var AgentServerStoreError = class extends Error {
+	name = "AgentServerStoreError";
 	constructor(code, message, options) {
 		super(message, options);
 		this.code = code;
 	}
 };
-/** `MOLTNET_SERVE_ROOT` override, else `$XDG_CONFIG_HOME/moltnet`, else `~/.config/moltnet`. */
-function resolveServeRoot(input) {
+/** `MOLTNET_AGENT_SERVER_ROOT` override, else `$XDG_CONFIG_HOME/moltnet`, else `~/.config/moltnet`. */
+function resolveAgentServerRoot(input) {
 	const override = input.root?.trim();
 	if (override) return override;
 	const xdg = input.xdgConfigHome?.trim();
@@ -7601,7 +7759,7 @@ function providerEnvName(providerId) {
 }
 function assertProviderEnvName(providerId, value) {
 	const expected = providerEnvName(providerId);
-	if (value !== expected) throw new ServeStoreError("invalid_state", `provider envName must be ${expected}`);
+	if (value !== expected) throw new AgentServerStoreError("invalid_state", `provider envName must be ${expected}`);
 	return value;
 }
 function readJson(path) {
@@ -7610,12 +7768,12 @@ function readJson(path) {
 		raw = readFileSync(path, "utf8");
 	} catch (cause) {
 		if (cause.code === "ENOENT") return null;
-		throw new ServeStoreError("io_error", `could not read state at ${path}`, { cause });
+		throw new AgentServerStoreError("io_error", `could not read state at ${path}`, { cause });
 	}
 	try {
 		return JSON.parse(raw);
 	} catch (cause) {
-		throw new ServeStoreError("invalid_state", `corrupt JSON at ${path}`, { cause });
+		throw new AgentServerStoreError("invalid_state", `corrupt JSON at ${path}`, { cause });
 	}
 }
 function writeJsonAtomic(path, value) {
@@ -7630,7 +7788,7 @@ function writeJsonAtomic(path, value) {
 		throw cause;
 	}
 }
-var ServeStore = class {
+var AgentServerStore = class {
 	root;
 	agentsDir;
 	runsDir;
@@ -7660,23 +7818,23 @@ var ServeStore = class {
 		});
 		return this;
 	}
-	get servePath() {
-		return join(this.root, "serve.json");
+	get statePath() {
+		return join(this.root, "agent-server.json");
 	}
-	readServeState() {
-		const state = readJson(this.servePath);
+	readAgentServerState() {
+		const state = readJson(this.statePath);
 		if (!state) return {
 			version: 1,
 			pendingRegistrations: {},
 			activations: {}
 		};
-		if (!isRecord$1(state) || state.version !== 1) throw new ServeStoreError("invalid_state", `serve.json version ${String(isRecord$1(state) ? state.version : void 0)} is not supported`);
-		if ("pairedOrigins" in state) throw new ServeStoreError("invalid_state", "serve.json uses the obsolete pairing format; clear the unreleased serve store and reconfigure it");
-		if (!isRecord$1(state.pendingRegistrations) || !isRecord$1(state.activations)) throw new ServeStoreError("invalid_state", "serve.json is missing the version 1 activation map; clear the unreleased serve store and reconfigure it");
+		if (!isRecord$1(state) || state.version !== 1) throw new AgentServerStoreError("invalid_state", `agent-server.json version ${String(isRecord$1(state) ? state.version : void 0)} is not supported`);
+		if ("pairedOrigins" in state) throw new AgentServerStoreError("invalid_state", "agent-server.json uses the obsolete pairing format; clear the unreleased agent server store and reconfigure it");
+		if (!isRecord$1(state.pendingRegistrations) || !isRecord$1(state.activations)) throw new AgentServerStoreError("invalid_state", "agent-server.json is missing the version 1 activation map; clear the unreleased agent server store and reconfigure it");
 		for (const [alias, activation] of Object.entries(state.activations)) validateActivation(alias, activation);
 		for (const [alias, registration] of Object.entries(state.pendingRegistrations)) {
 			assertStoreName("agent name", alias);
-			if (!isRecord$1(registration) || typeof registration.apiUrl !== "string" || registration.apiUrl.length === 0 || typeof registration.createdAt !== "string" || registration.createdAt.length === 0) throw new ServeStoreError("invalid_state", `pending registration "${alias}" is not valid`);
+			if (!isRecord$1(registration) || typeof registration.apiUrl !== "string" || registration.apiUrl.length === 0 || typeof registration.createdAt !== "string" || registration.createdAt.length === 0) throw new AgentServerStoreError("invalid_state", `pending registration "${alias}" is not valid`);
 		}
 		return {
 			version: 1,
@@ -7684,8 +7842,8 @@ var ServeStore = class {
 			activations: state.activations
 		};
 	}
-	writeServeState(state) {
-		writeJsonAtomic(this.servePath, state);
+	writeAgentServerState(state) {
+		writeJsonAtomic(this.statePath, state);
 	}
 	agentPath(name) {
 		return storeChildPath(this.agentsDir, "agent name", name, ".json");
@@ -7700,37 +7858,37 @@ var ServeStore = class {
 		rmSync(this.agentPath(alias), { force: true });
 	}
 	readActivation(alias) {
-		return this.readServeState().activations[assertStoreName("agent name", alias)] ?? null;
+		return this.readAgentServerState().activations[assertStoreName("agent name", alias)] ?? null;
 	}
 	hasPendingRegistration(alias) {
-		return Boolean(this.readServeState().pendingRegistrations[assertStoreName("agent name", alias)]);
+		return Boolean(this.readAgentServerState().pendingRegistrations[assertStoreName("agent name", alias)]);
 	}
 	reserveRegistration(alias, apiUrl) {
 		const name = assertStoreName("agent name", alias);
-		const state = this.readServeState();
-		if (state.activations[name] || state.pendingRegistrations[name]) throw new ServeStoreError("already_exists", `agent "${name}" already exists in the serve store`);
+		const state = this.readAgentServerState();
+		if (state.activations[name] || state.pendingRegistrations[name]) throw new AgentServerStoreError("already_exists", `agent "${name}" already exists in the agent server store`);
 		state.pendingRegistrations[name] = {
 			apiUrl,
 			createdAt: (/* @__PURE__ */ new Date()).toISOString()
 		};
-		this.writeServeState(state);
+		this.writeAgentServerState(state);
 	}
 	clearPendingRegistration(alias) {
 		const name = assertStoreName("agent name", alias);
-		const state = this.readServeState();
+		const state = this.readAgentServerState();
 		delete state.pendingRegistrations[name];
-		this.writeServeState(state);
+		this.writeAgentServerState(state);
 	}
 	writeActivation(activation) {
 		const alias = assertStoreName("agent name", activation.alias);
 		validateActivation(alias, activation);
-		const state = this.readServeState();
+		const state = this.readAgentServerState();
 		state.activations[alias] = activation;
 		if (activation.source === "managed") delete state.pendingRegistrations[alias];
-		this.writeServeState(state);
+		this.writeAgentServerState(state);
 	}
 	listActivations() {
-		return Object.values(this.readServeState().activations).sort((a, b) => a.alias.localeCompare(b.alias));
+		return Object.values(this.readAgentServerState().activations).sort((a, b) => a.alias.localeCompare(b.alias));
 	}
 	get providersPath() {
 		return join(this.root, "providers.json");
@@ -7760,17 +7918,17 @@ var ServeStore = class {
 			root = realpathSync(this.runsDir);
 			runDir = realpathSync(this.runDir(id));
 		} catch (cause) {
-			throw new ServeStoreError("io_error", "could not resolve run directory", { cause });
+			throw new AgentServerStoreError("io_error", "could not resolve run directory", { cause });
 		}
-		if (!isStrictDescendant(root, runDir)) throw new ServeStoreError("invalid_state", "run directory escapes its store");
+		if (!isStrictDescendant(root, runDir)) throw new AgentServerStoreError("invalid_state", "run directory escapes its store");
 		const logPath = join(runDir, "daemon.log");
 		try {
-			if (lstatSync(logPath).isSymbolicLink()) throw new ServeStoreError("invalid_state", "run log must not be a symbolic link");
+			if (lstatSync(logPath).isSymbolicLink()) throw new AgentServerStoreError("invalid_state", "run log must not be a symbolic link");
 			const resolvedLog = realpathSync(logPath);
-			if (!isStrictDescendant(runDir, resolvedLog)) throw new ServeStoreError("invalid_state", "run log escapes its store");
+			if (!isStrictDescendant(runDir, resolvedLog)) throw new AgentServerStoreError("invalid_state", "run log escapes its store");
 		} catch (cause) {
-			if (cause instanceof ServeStoreError) throw cause;
-			if (cause.code !== "ENOENT") throw new ServeStoreError("io_error", "could not resolve run log", { cause });
+			if (cause instanceof AgentServerStoreError) throw cause;
+			if (cause.code !== "ENOENT") throw new AgentServerStoreError("io_error", "could not resolve run log", { cause });
 		}
 		return logPath;
 	}
@@ -7857,7 +8015,7 @@ function storeChildPath(root, kind, value, suffix = "") {
 	const name = assertStoreName(kind, value);
 	const normalizedRoot = resolve(root);
 	const candidate = resolve(normalizedRoot, `${name}${suffix}`);
-	if (!isStrictDescendant(normalizedRoot, candidate)) throw new ServeStoreError("invalid_name", `${kind} escapes its store`);
+	if (!isStrictDescendant(normalizedRoot, candidate)) throw new AgentServerStoreError("invalid_name", `${kind} escapes its store`);
 	return candidate;
 }
 function isStrictDescendant(root, candidate) {
@@ -7866,7 +8024,7 @@ function isStrictDescendant(root, candidate) {
 }
 function validateActivation(alias, value) {
 	const invalid = () => {
-		throw new ServeStoreError("invalid_state", `activation "${alias}" is not a valid version 1 activation`);
+		throw new AgentServerStoreError("invalid_state", `activation "${alias}" is not a valid version 1 activation`);
 	};
 	if (!isRecord$1(value)) invalid();
 	const activation = value;
@@ -7884,20 +8042,20 @@ function validateActivation(alias, value) {
 	if (activation.source !== "external" || typeof activation.configPath !== "string" || activation.configPath.length === 0 || typeof activation.configApiUrl !== "string" || activation.configApiUrl.length === 0 || activation.apiUrl !== void 0 && typeof activation.apiUrl !== "string") invalid();
 }
 //#endregion
-//#region src/lib/serve/identity.ts
+//#region src/lib/agent-server/identity.ts
 /**
-* Serve identity activation (#2061/#1834 boundary).
+* AgentServer identity activation (#2061/#1834 boundary).
 *
 * Managed agent files are canonical `MoltNetConfig` documents. Alias,
 * provenance, pinned identity material, and external config paths live only
-* in the versioned activation map in `serve.json`. Every attach and run loads
+* in the versioned activation map in `agent-server.json`. Every attach and run loads
 * the current config and verifies it with authenticated `whoami` before use.
 */
 var MAX_CONFIG_BYTES = 64 * 1024;
 var IDENTITY_OPERATION_TIMEOUT_MS = 15e3;
 var pendingAliases = /* @__PURE__ */ new WeakMap();
-var ServeIdentityError = class extends Error {
-	name = "ServeIdentityError";
+var AgentServerIdentityError = class extends Error {
+	name = "AgentServerIdentityError";
 	constructor(code, message, options) {
 		super(message, options);
 		this.code = code;
@@ -7909,13 +8067,13 @@ function reserveAlias(store, alias) {
 		pending = /* @__PURE__ */ new Set();
 		pendingAliases.set(store, pending);
 	}
-	if (pending.has(alias) || store.hasPendingRegistration(alias) || store.readActivation(alias) || store.readAgentConfig(alias)) throw new ServeIdentityError("agent_exists", `agent "${alias}" already exists in the serve store`);
+	if (pending.has(alias) || store.hasPendingRegistration(alias) || store.readActivation(alias) || store.readAgentConfig(alias)) throw new AgentServerIdentityError("agent_exists", `agent "${alias}" already exists in the agent server store`);
 	pending.add(alias);
 	return () => pending.delete(alias);
 }
 async function createManagedAgent(store, secrets, input, connectAgent = connect) {
 	const alias = assertStoreName("agent name", input.name);
-	if (!input.enrollmentToken.trim()) throw new ServeIdentityError("enrollment_required", "an enrollment token from the target team is required — a self-registered agent would be stranded in its own personal team");
+	if (!input.enrollmentToken.trim()) throw new AgentServerIdentityError("enrollment_required", "an enrollment token from the target team is required — a self-registered agent would be stranded in its own personal team");
 	const releaseAlias = reserveAlias(store, alias);
 	let registeredIdentityId;
 	try {
@@ -7923,7 +8081,7 @@ async function createManagedAgent(store, secrets, input, connectAgent = connect)
 		try {
 			apiUrl = requireSecureCredentialApiUrl(input.apiUrl);
 		} catch (cause) {
-			throw new ServeIdentityError("registration_failed", "registration API URL must use HTTPS or HTTP loopback", { cause });
+			throw new AgentServerIdentityError("registration_failed", "registration API URL must use HTTPS or HTTP loopback", { cause });
 		}
 		store.reserveRegistration(alias, apiUrl);
 		const result = await register({
@@ -7932,7 +8090,7 @@ async function createManagedAgent(store, secrets, input, connectAgent = connect)
 			enrollmentToken: input.enrollmentToken,
 			signal: boundedIdentitySignal(input.signal)
 		});
-		if (result.credentials.type !== "agent_key") throw new ServeIdentityError("unsupported_credential", `registration returned credential type "${result.credentials.type}"; serve manages agent-key credentials only`);
+		if (result.credentials.type !== "agent_key") throw new AgentServerIdentityError("unsupported_credential", `registration returned credential type "${result.credentials.type}"; agent server manages agent-key credentials only`);
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		const { identityId, fingerprint, publicKey, privateKey } = result.identity;
 		registeredIdentityId = identityId;
@@ -7990,9 +8148,9 @@ async function createManagedAgent(store, secrets, input, connectAgent = connect)
 	} catch (cause) {
 		if (!registeredIdentityId && cause instanceof MoltNetError && cause.statusCode !== void 0 && cause.statusCode >= 400 && cause.statusCode < 500) {
 			store.clearPendingRegistration(alias);
-			throw new ServeIdentityError("registration_failed", `registration for "${alias}" was rejected`, { cause });
+			throw new AgentServerIdentityError("registration_failed", `registration for "${alias}" was rejected`, { cause });
 		}
-		if (store.hasPendingRegistration(alias)) throw new ServeIdentityError("registration_incomplete", registeredIdentityId ? `identity "${registeredIdentityId}" was registered but local activation is incomplete; reconcile or clear its pending serve record before retrying` : `registration for "${alias}" may be incomplete; inspect the remote API before changing its pending serve record`, { cause });
+		if (store.hasPendingRegistration(alias)) throw new AgentServerIdentityError("registration_incomplete", registeredIdentityId ? `identity "${registeredIdentityId}" was registered but local activation is incomplete; reconcile or clear its pending Agent Server record before retrying` : `registration for "${alias}" may be incomplete; inspect the remote API before changing its pending Agent Server record`, { cause });
 		throw cause;
 	} finally {
 		releaseAlias();
@@ -8004,22 +8162,22 @@ async function reconcileManagedRegistration(store, secrets, aliasInput, action,
 	const activation = store.readActivation(alias);
 	if (activation) {
 		const config = store.readAgentConfig(alias);
-		if (!config) throw new ServeIdentityError("registration_incomplete", `managed activation for "${alias}" is missing its canonical config`);
+		if (!config) throw new AgentServerIdentityError("registration_incomplete", `managed activation for "${alias}" is missing its canonical config`);
 		return {
 			activation,
 			config
 		};
 	}
-	if (!store.hasPendingRegistration(alias)) throw new ServeIdentityError("config_not_found", `agent "${alias}" has no pending registration to reconcile`);
+	if (!store.hasPendingRegistration(alias)) throw new AgentServerIdentityError("config_not_found", `agent "${alias}" has no pending registration to reconcile`);
 	const config = store.readAgentConfig(alias);
 	if (action === "abandon") {
 		store.removeAgentConfig(alias);
 		store.clearPendingRegistration(alias);
 		return null;
 	}
-	if (!config?.agent_key_ref || config.agent_key_ref.provider !== FILE_SECRET_PROVIDER || config.keys.private_key_ref?.provider !== FILE_SECRET_PROVIDER) throw new ServeIdentityError("registration_incomplete", `pending registration for "${alias}" does not have complete managed references`);
+	if (!config?.agent_key_ref || config.agent_key_ref.provider !== FILE_SECRET_PROVIDER || config.keys.private_key_ref?.provider !== FILE_SECRET_PROVIDER) throw new AgentServerIdentityError("registration_incomplete", `pending registration for "${alias}" does not have complete managed references`);
 	const [agentKey, privateKeyState] = await Promise.all([secrets.read(config.agent_key_ref.key), secrets.probe(config.keys.private_key_ref.key)]);
-	if (!agentKey || privateKeyState !== "present") throw new ServeIdentityError("registration_incomplete", `pending registration for "${alias}" is missing persisted secret material`);
+	if (!agentKey || privateKeyState !== "present") throw new AgentServerIdentityError("registration_incomplete", `pending registration for "${alias}" is missing persisted secret material`);
 	const identity = identityFromConfig(config);
 	const apiUrl = requireConfigApiUrl(config, store.agentPath(alias));
 	const whoami = await callWhoami(connectAgent, {
@@ -8047,7 +8205,7 @@ async function attachExternalAgent(store, secretProviders, input, connectAgent =
 	const alias = assertStoreName("agent name", input.name);
 	const releaseAlias = reserveAlias(store, alias);
 	try {
-		if (!isAbsolute(input.configDir)) throw new ServeIdentityError("config_not_found", "external configDir must be an absolute path");
+		if (!isAbsolute(input.configDir)) throw new AgentServerIdentityError("config_not_found", "external configDir must be an absolute path");
 		const configPath = join(input.configDir, "moltnet.json");
 		externalAgentLocation(configPath);
 		const config = await readCurrentConfig(configPath);
@@ -8083,7 +8241,7 @@ async function verifyAgentActivation(store, alias, managedSecretProviders, exter
 	const verified = activation.source === "managed" ? await verifyManagedActivation(store, activation, managedSecretProviders, connectAgent, signal) : await verifyExternalActivation(activation, externalSecretProviders, connectAgent, signal);
 	assertIdentityMatches(verified.whoami, activation, "authenticated whoami", `agent "${activation.alias}" pinned activation`);
 	const boundTeamId = boundTeamIdFromWhoami(verified.whoami);
-	if (activation.boundTeamId !== boundTeamId) throw new ServeIdentityError("verification_failed", `authenticated whoami team binding does not match agent "${activation.alias}" pinned activation`);
+	if (activation.boundTeamId !== boundTeamId) throw new AgentServerIdentityError("verification_failed", `authenticated whoami team binding does not match agent "${activation.alias}" pinned activation`);
 	return {
 		activation,
 		config: verified.config,
@@ -8100,7 +8258,7 @@ async function verifyManagedActivation(store, activation, secretProviders, conne
 	} catch (cause) {
 		throw verificationError(`could not resolve the managed agent key for "${activation.alias}"`, cause);
 	}
-	if (!agentKey) throw new ServeIdentityError("verification_failed", `managed config for "${activation.alias}" has no agent_key_ref`);
+	if (!agentKey) throw new AgentServerIdentityError("verification_failed", `managed config for "${activation.alias}" has no agent_key_ref`);
 	return {
 		config,
 		whoami: await callWhoami(connectAgent, {
@@ -8123,16 +8281,16 @@ async function verifyExternalActivation(activation, secretProviders, connectAgen
 /** Never let request or activation metadata redirect persisted credentials. */
 function requireTrustedApiOverride(override, configApiUrl, configPath) {
 	if (!override) return configApiUrl;
-	if (override !== configApiUrl) throw new ServeIdentityError("verification_failed", `API override for ${configPath} does not match its configured endpoint`);
+	if (override !== configApiUrl) throw new AgentServerIdentityError("verification_failed", `API override for ${configPath} does not match its configured endpoint`);
 	return configApiUrl;
 }
 function assertActivatedConfig(config, activation, configPath, currentApiUrl, pinnedApiUrl) {
-	if (currentApiUrl !== pinnedApiUrl) throw new ServeIdentityError("verification_failed", `agent config at ${configPath} API endpoint does not match its pinned activation`);
+	if (currentApiUrl !== pinnedApiUrl) throw new AgentServerIdentityError("verification_failed", `agent config at ${configPath} API endpoint does not match its pinned activation`);
 	assertIdentityMatches(identityFromConfig(config), activation, configPath, `agent "${activation.alias}" pinned activation`);
 }
 function requireConfigApiUrl(config, configPath) {
 	const apiUrl = config?.endpoints?.api?.trim();
-	if (!apiUrl) throw new ServeIdentityError("verification_failed", `agent config at ${configPath} is missing endpoints.api`);
+	if (!apiUrl) throw new AgentServerIdentityError("verification_failed", `agent config at ${configPath} is missing endpoints.api`);
 	return apiUrl;
 }
 function requireTrustedConfigApiUrl(config, configPath) {
@@ -8149,14 +8307,14 @@ async function readCurrentConfig(configPath) {
 	try {
 		file = await open(configPath, "r");
 	} catch (cause) {
-		throw new ServeIdentityError("config_not_found", `agent config is missing at ${configPath}`, { cause });
+		throw new AgentServerIdentityError("config_not_found", `agent config is missing at ${configPath}`, { cause });
 	}
 	let raw;
 	try {
-		if (!(await file.stat()).isFile()) throw new ServeIdentityError("verification_failed", `agent config at ${configPath} must be a regular file no larger than ${MAX_CONFIG_BYTES} bytes`);
+		if (!(await file.stat()).isFile()) throw new AgentServerIdentityError("verification_failed", `agent config at ${configPath} must be a regular file no larger than ${MAX_CONFIG_BYTES} bytes`);
 		const buffer = Buffer.alloc(MAX_CONFIG_BYTES + 1);
 		const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
-		if (bytesRead > MAX_CONFIG_BYTES) throw new ServeIdentityError("verification_failed", `agent config at ${configPath} must be a regular file no larger than ${MAX_CONFIG_BYTES} bytes`);
+		if (bytesRead > MAX_CONFIG_BYTES) throw new AgentServerIdentityError("verification_failed", `agent config at ${configPath} must be a regular file no larger than ${MAX_CONFIG_BYTES} bytes`);
 		raw = buffer.toString("utf8", 0, bytesRead);
 	} finally {
 		await file.close();
@@ -8171,7 +8329,7 @@ async function readCurrentConfig(configPath) {
 function externalAgentLocation(configPath) {
 	const configDir = dirname(configPath);
 	const moltnetDir = dirname(configDir);
-	if (!isAbsolute(configPath) || basename(configPath) !== "moltnet.json" || basename(moltnetDir) !== ".moltnet") throw new ServeIdentityError("config_not_found", `external config must be at an absolute <agent-root>/.moltnet/<agent>/moltnet.json path`);
+	if (!isAbsolute(configPath) || basename(configPath) !== "moltnet.json" || basename(moltnetDir) !== ".moltnet") throw new AgentServerIdentityError("config_not_found", `external config must be at an absolute <agent-root>/.moltnet/<agent>/moltnet.json path`);
 	return {
 		agentName: assertStoreName("external config agent name", basename(configDir)),
 		agentRoot: dirname(moltnetDir)
@@ -8203,7 +8361,7 @@ function identityFromConfig(config) {
 	const identityId = config?.identity_id?.trim();
 	const publicKey = config?.keys?.public_key?.trim();
 	const fingerprint = config?.keys?.fingerprint?.trim();
-	if (!identityId || !publicKey || !fingerprint) throw new ServeIdentityError("verification_failed", "agent config is missing canonical identity_id, keys.public_key, or keys.fingerprint");
+	if (!identityId || !publicKey || !fingerprint) throw new AgentServerIdentityError("verification_failed", "agent config is missing canonical identity_id, keys.public_key, or keys.fingerprint");
 	return {
 		identityId,
 		publicKey,
@@ -8212,10 +8370,10 @@ function identityFromConfig(config) {
 }
 function assertIdentityMatches(current, expected, currentLabel, expectedLabel) {
 	const assessment = assessIdentityPin(current, expected);
-	if (!assessment.ok) throw new ServeIdentityError("verification_failed", `${currentLabel} ${assessment.label} does not match ${expectedLabel}`);
+	if (!assessment.ok) throw new AgentServerIdentityError("verification_failed", `${currentLabel} ${assessment.label} does not match ${expectedLabel}`);
 }
 function verificationError(message, cause) {
-	return new ServeIdentityError("verification_failed", message, { cause });
+	return new AgentServerIdentityError("verification_failed", message, { cause });
 }
 /** Non-secret projection preserving the existing `/v1` response shape. */
 function publicAgentView(store, activation) {
@@ -8249,11 +8407,11 @@ function boundTeamIdFromWhoami(whoami) {
 }
 function requireActivation(store, alias) {
 	const activation = store.readActivation(alias);
-	if (!activation) throw new ServeStoreError("not_found", `agent "${alias}" is not configured`);
+	if (!activation) throw new AgentServerStoreError("not_found", `agent "${alias}" is not configured`);
 	return activation;
 }
 //#endregion
-//#region src/lib/serve/runs.ts
+//#region src/lib/agent-server/runs.ts
 var STOP_GRACE_MS = 1e4;
 var STOP_FORCE_MS = 2e3;
 var DEFAULT_MAX_LOG_BYTES = 10 * 1024 * 1024;
@@ -8292,19 +8450,19 @@ var INHERITED_MOLTNET_ENV_NAMES = new Set([
 	"MOLTNET_SIGNER_URL",
 	"MOLTNET_TRACE_IDLE_POLLING"
 ]);
-var ServeRunError = class extends Error {
-	name = "ServeRunError";
+var AgentServerRunError = class extends Error {
+	name = "AgentServerRunError";
 	constructor(code, message) {
 		super(message);
 		this.code = code;
 	}
 };
 function validateRunSpec(spec) {
-	if (spec.mode !== "poll" && spec.mode !== "drain") throw new ServeRunError("invalid_spec", "mode must be poll or drain");
-	if (!spec.agent) throw new ServeRunError("invalid_spec", "agent is required");
-	if (!spec.teamId) throw new ServeRunError("invalid_spec", "teamId is required");
-	if (!Array.isArray(spec.profiles) || spec.profiles.length === 0) throw new ServeRunError("invalid_spec", "at least one profile is required");
-	if (!Array.isArray(spec.taskTypes) || spec.taskTypes.length === 0) throw new ServeRunError("invalid_spec", "at least one task type is required");
+	if (spec.mode !== "poll" && spec.mode !== "drain") throw new AgentServerRunError("invalid_spec", "mode must be poll or drain");
+	if (!spec.agent) throw new AgentServerRunError("invalid_spec", "agent is required");
+	if (!spec.teamId) throw new AgentServerRunError("invalid_spec", "teamId is required");
+	if (!Array.isArray(spec.profiles) || spec.profiles.length === 0) throw new AgentServerRunError("invalid_spec", "at least one profile is required");
+	if (!Array.isArray(spec.taskTypes) || spec.taskTypes.length === 0) throw new AgentServerRunError("invalid_spec", "at least one task type is required");
 }
 var RunManager = class {
 	active = /* @__PURE__ */ new Map();
@@ -8327,7 +8485,7 @@ var RunManager = class {
 		};
 	}
 	/** Assemble child env + args for a run. Exposed for tests. */
-	async prepare(spec, agent, piDir, providers = this.store.readProviders()) {
+	async prepare(spec, agent, piDir, providers = this.store.readProviders(), runtimeModule) {
 		const { activation, config } = agent;
 		const homeDir = join(dirname(piDir), "home");
 		const env = {
@@ -8351,6 +8509,7 @@ var RunManager = class {
 			};
 		})();
 		const args = [
+			...runtimeModule ? ["--runtime", runtimeModule] : [],
 			spec.mode,
 			"--agent",
 			target.agentName,
@@ -8362,7 +8521,7 @@ var RunManager = class {
 			...target.extraArgs
 		];
 		if (activation.source === "managed") {
-			if (!config.agent_key_ref || !config.keys.private_key_ref) throw new ServeRunError("invalid_spec", `managed config for "${activation.alias}" is missing canonical secret references`);
+			if (!config.agent_key_ref || !config.keys.private_key_ref) throw new AgentServerRunError("invalid_spec", `managed config for "${activation.alias}" is missing canonical secret references`);
 			env["MOLTNET_API_URL"] = activation.apiUrl;
 			env["MOLTNET_AGENT_KEY_REF"] = formatSecretReferenceString(config.agent_key_ref);
 			env["MOLTNET_PRIVATE_KEY_REF"] = formatSecretReferenceString(config.keys.private_key_ref);
@@ -8380,7 +8539,7 @@ var RunManager = class {
 				}
 				if (!agentKey && config.keys.private_key_ref) env["MOLTNET_PRIVATE_KEY"] = await resolveIdentitySeed(config, this.options.externalSecretProviders);
 			} catch {
-				throw new ServeRunError("invalid_spec", `external credentials for "${activation.alias}" could not be projected`);
+				throw new AgentServerRunError("invalid_spec", `external credentials for "${activation.alias}" could not be projected`);
 			}
 		}
 		env["MOLTNET_EXPECTED_IDENTITY_ID"] = activation.identityId;
@@ -8393,7 +8552,7 @@ var RunManager = class {
 			try {
 				value = await this.options.secretProviders.resolve(parseSecretReferenceString(provider.apiKeyRef));
 			} catch {
-				throw new ServeRunError("invalid_spec", `provider "${providerId}" API key could not be resolved`);
+				throw new AgentServerRunError("invalid_spec", `provider "${providerId}" API key could not be resolved`);
 			}
 			env[provider.envName] = value;
 		}
@@ -8416,12 +8575,13 @@ var RunManager = class {
 		this.assertStartOpen(signal);
 		const agent = await (this.options.verifyActivationImpl ?? verifyAgentActivation)(this.store, spec.agent, this.options.secretProviders, this.options.externalSecretProviders, void 0, signal);
 		this.assertStartOpen(signal);
-		if (agent.boundTeamId && agent.boundTeamId !== spec.teamId) throw new ServeRunError("invalid_spec", `agent "${spec.agent}" has a key bound to team ${agent.boundTeamId}; start the run with that team, or create a new agent with an enrollment token from team ${spec.teamId}`);
+		if (agent.boundTeamId && agent.boundTeamId !== spec.teamId) throw new AgentServerRunError("invalid_spec", `agent "${spec.agent}" has a key bound to team ${agent.boundTeamId}; start the run with that team, or create a new agent with an enrollment token from team ${spec.teamId}`);
 		const id = `${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
 		const runDir = this.store.runDir(id);
 		const piDir = join(runDir, "pi");
 		const providers = this.store.readProviders();
-		const { args, env, cwd } = await this.prepare(spec, agent, piDir, providers);
+		const runtimeModule = this.options.resolveRuntimeModule ? await this.options.resolveRuntimeModule(spec, agent, dirname(piDir)) : this.options.runtimeRegistry ? await this.resolveRuntimeModule(spec, agent, dirname(piDir)) : void 0;
+		const { args, env, cwd } = await this.prepare(spec, agent, piDir, providers, runtimeModule);
 		this.assertStartOpen(signal);
 		let child;
 		let logStream;
@@ -8449,20 +8609,20 @@ var RunManager = class {
 			try {
 				(this.options.symlinkImpl ?? symlinkSync)(this.store.piAuthJsonPath, join(piDir, "auth.json"));
 			} catch (cause) {
-				throw new ServeStoreError("io_error", "could not link subscription credentials into the run", { cause });
+				throw new AgentServerStoreError("io_error", "could not link subscription credentials into the run", { cause });
 			}
 			const entry = this.entrypoint();
 			logStream = createWriteStream(logPath, {
 				fd: openSync(logPath, "a", 384),
 				autoClose: true
 			});
-			logLimiter = createByteLimitTransform(this.options.maxLogBytes ?? DEFAULT_MAX_LOG_BYTES, () => this.log("warn", "serve run log output truncated", {
+			logLimiter = createByteLimitTransform(this.options.maxLogBytes ?? DEFAULT_MAX_LOG_BYTES, () => this.log("warn", "agent server run log output truncated", {
 				...runContext(id, spec.agent, child),
 				transition: "log_truncated"
 			}));
 			logLimiter.pipe(logStream);
 			logStream.on("error", (error) => {
-				this.log("error", "serve run log stream failed", {
+				this.log("error", "agent server run log stream failed", {
 					...runContext(id, spec.agent, child),
 					transition: "log_failed",
 					...safeRunError(error)
@@ -8508,7 +8668,7 @@ var RunManager = class {
 				this.active.delete(id);
 				logLimiter?.end();
 				const status = activeRun?.stopRequested ? "stopped" : code === 0 ? "exited" : "failed";
-				this.log(status === "failed" ? "error" : "info", "serve run exited", {
+				this.log(status === "failed" ? "error" : "info", "agent server run exited", {
 					...runContext(id, spec.agent, child),
 					transition: status,
 					exitCode: code,
@@ -8522,7 +8682,7 @@ var RunManager = class {
 			child.once("error", (error) => {
 				this.active.delete(id);
 				logLimiter?.end();
-				this.log("error", "serve run child process failed", {
+				this.log("error", "agent server run child process failed", {
 					...runContext(id, spec.agent, child),
 					transition: "spawn_failed",
 					...safeRunError(error)
@@ -8530,7 +8690,7 @@ var RunManager = class {
 				this.persistRunCompletion(id, spec.agent, { status: "failed" });
 			});
 			this.store.writeRun(record);
-			this.log("info", "serve run started", {
+			this.log("info", "agent server run started", {
 				...runContext(id, spec.agent, child),
 				transition: "running"
 			});
@@ -8544,7 +8704,7 @@ var RunManager = class {
 				recursive: true,
 				force: true
 			});
-			this.log("error", "serve run failed to start", {
+			this.log("error", "agent server run failed to start", {
 				...runContext(id, spec.agent, child),
 				transition: "start_failed",
 				...safeRunError(cause)
@@ -8552,13 +8712,53 @@ var RunManager = class {
 			throw cause;
 		}
 	}
+	async resolveRuntimeModule(spec, activated, cwd) {
+		const profiles = await resolveRuntimeProfiles({
+			agent: await this.connectActivatedAgent(activated),
+			profiles: spec.profiles,
+			teamId: spec.teamId,
+			cwd
+		});
+		const kinds = [...new Set(profiles.map((profile) => profile.runtimeKind))];
+		if (kinds.length !== 1) throw new AgentServerRunError("invalid_spec", "All profiles in a server-managed run must use the same runtime kind.");
+		const kind = kinds[0];
+		let registration;
+		try {
+			registration = this.options.runtimeRegistry?.resolve(kind);
+		} catch (cause) {
+			this.log("warn", "registered runtime unavailable locally", {
+				runtimeKind: kind,
+				...runtimeRegistryFailure(cause)
+			});
+			throw new AgentServerRunError("invalid_spec", `Registered runtime "${kind}" is unavailable locally; re-register it before starting a run.`);
+		}
+		if (registration) return registration.moduleUrl;
+		if (kind === "gondolin_pi") return void 0;
+		throw new AgentServerRunError("invalid_spec", `No local runtime is registered for profile kind "${kind}".`);
+	}
+	async connectActivatedAgent(activated) {
+		const { activation, config } = activated;
+		if (activation.source === "managed") {
+			const agentKey = await resolveAgentKey(config, this.options.secretProviders);
+			if (!agentKey) throw new AgentServerRunError("invalid_spec", `managed agent "${activation.alias}" has no agent key`);
+			return connect({
+				agentKey,
+				apiUrl: activation.apiUrl
+			});
+		}
+		return connect({
+			configDir: dirname(activation.configPath),
+			apiUrl: activation.apiUrl ?? activation.configApiUrl,
+			secretProviders: this.options.externalSecretProviders
+		});
+	}
 	stop(id) {
 		const record = this.store.readRun(id);
-		if (!record) throw new ServeRunError("run_not_found", `run "${id}" was not found`);
+		if (!record) throw new AgentServerRunError("run_not_found", `run "${id}" was not found`);
 		const activeRun = this.active.get(id);
-		if (!activeRun) throw new ServeRunError("run_not_active", `run "${id}" is not running`);
+		if (!activeRun) throw new AgentServerRunError("run_not_active", `run "${id}" is not running`);
 		activeRun.stopRequested = true;
-		this.log("info", "serve run stop requested", {
+		this.log("info", "agent server run stop requested", {
 			...runContext(id, record.agent, activeRun.child),
 			transition: "stopping",
 			signal: "SIGTERM"
@@ -8572,7 +8772,7 @@ var RunManager = class {
 	/** Live status merged over the persisted record. */
 	status(id) {
 		const record = this.store.readRun(id);
-		if (!record) throw new ServeStoreError("not_found", `run "${id}" was not found`);
+		if (!record) throw new AgentServerStoreError("not_found", `run "${id}" was not found`);
 		return record;
 	}
 	list(limit = Number.POSITIVE_INFINITY) {
@@ -8620,7 +8820,7 @@ var RunManager = class {
 		this.closing = true;
 		for (const [id, activeRun] of this.active) {
 			activeRun.stopRequested = true;
-			this.log("warn", "serve run force stop requested", {
+			this.log("warn", "agent server run force stop requested", {
 				...runContext(id, this.store.readRun(id)?.agent ?? "unknown", activeRun.child),
 				transition: "force_stopping",
 				signal: "SIGKILL"
@@ -8638,7 +8838,7 @@ var RunManager = class {
 				exitCode: null,
 				endedAt
 			});
-			this.log("warn", "serve run interrupted by supervisor replacement", {
+			this.log("warn", "agent server run interrupted by supervisor replacement", {
 				runId: record.id,
 				agent: record.agent,
 				pid: record.pid,
@@ -8647,10 +8847,10 @@ var RunManager = class {
 		}
 	}
 	reserveStart(agent) {
-		if (this.closing) throw new ServeRunError("invalid_spec", "serve is shutting down");
+		if (this.closing) throw new AgentServerRunError("invalid_spec", "agent server is shutting down");
 		const agentStarting = this.startingByAgent.get(agent) ?? 0;
 		const agentActive = [...this.active.values()].filter((run) => run.agent === agent).length;
-		if (this.active.size + this.starting >= (this.options.maxActiveRuns ?? DEFAULT_MAX_ACTIVE_RUNS) || agentActive + agentStarting >= (this.options.maxActiveRunsPerAgent ?? DEFAULT_MAX_ACTIVE_RUNS_PER_AGENT)) throw new ServeRunError("invalid_spec", `active run limit reached for agent "${agent}"`);
+		if (this.active.size + this.starting >= (this.options.maxActiveRuns ?? DEFAULT_MAX_ACTIVE_RUNS) || agentActive + agentStarting >= (this.options.maxActiveRunsPerAgent ?? DEFAULT_MAX_ACTIVE_RUNS_PER_AGENT)) throw new AgentServerRunError("invalid_spec", `active run limit reached for agent "${agent}"`);
 		this.starting += 1;
 		this.startingByAgent.set(agent, agentStarting + 1);
 		return () => {
@@ -8661,7 +8861,7 @@ var RunManager = class {
 		};
 	}
 	assertStartOpen(signal) {
-		if (this.closing || signal?.aborted) throw new ServeRunError("invalid_spec", "serve is shutting down");
+		if (this.closing || signal?.aborted) throw new AgentServerRunError("invalid_spec", "agent server is shutting down");
 	}
 	pruneCompletedRuns() {
 		const removed = this.store.pruneCompletedRuns({
@@ -8670,7 +8870,7 @@ var RunManager = class {
 			maxBytes: this.options.maxRunStorageBytes ?? DEFAULT_MAX_RUN_STORAGE_BYTES,
 			now: this.options.now?.() ?? /* @__PURE__ */ new Date()
 		});
-		if (removed.length > 0) this.log("info", "serve run retention removed completed artifacts", {
+		if (removed.length > 0) this.log("info", "agent server run retention removed completed artifacts", {
 			transition: "pruned",
 			removedCount: removed.length
 		});
@@ -8685,7 +8885,7 @@ var RunManager = class {
 			});
 			this.pruneCompletedRuns();
 		} catch (error) {
-			this.log("error", "serve run completion persistence failed", {
+			this.log("error", "agent server run completion persistence failed", {
 				runId: id,
 				agent,
 				transition: "persistence_failed",
@@ -8734,6 +8934,14 @@ function safeRunError(error) {
 		...typeof code === "string" ? { errorCode: code } : {}
 	};
 }
+function runtimeRegistryFailure(error) {
+	const code = error?.code;
+	return {
+		errorType: error instanceof Error ? error.name : typeof error,
+		...typeof code === "string" ? { errorCode: code } : {},
+		...error instanceof Error ? { errorMessage: error.message.slice(0, 512) } : {}
+	};
+}
 function sanitizeChildBaseEnv(baseEnv) {
 	return Object.fromEntries(Object.entries(baseEnv).filter(([name]) => INHERITED_ENV_NAMES.has(name) || INHERITED_MOLTNET_ENV_NAMES.has(name)));
 }
@@ -8750,63 +8958,169 @@ async function terminateChild(child) {
 	});
 }
 //#endregion
-//#region src/lib/serve/serve-lock.ts
-var ServeLockError = class extends Error {
-	name = "ServeLockError";
-	constructor(code, message, options) {
-		super(message, options);
-		this.code = code;
-	}
-};
-/**
-* Acquire the per-root singleton lock. `proper-lockfile` uses an atomic lock
-* directory at exactly `<root>/serve.lock`, recovers stale owners, and keeps
-* the mtime fresh while the supervisor is alive.
-*/
-async function acquireServeLock(root, options = {}) {
-	const path = join(root, "serve.lock");
-	let releaseLock;
-	try {
-		releaseLock = await lock(root, {
-			lockfilePath: path,
-			realpath: false,
-			retries: 0,
-			...options.staleMs === void 0 ? {} : { stale: options.staleMs },
-			...options.updateMs === void 0 ? {} : { update: options.updateMs },
-			onCompromised: (cause) => {
-				const error = new ServeLockError("compromised", `serve lock ${path} was compromised: ${cause.message}`, { cause });
-				if (options.onCompromised) {
-					options.onCompromised(error);
-					return;
-				}
-				throw error;
-			}
-		});
-	} catch (cause) {
-		if (cause.code === "ELOCKED") throw new ServeLockError("held", `another moltnet-agent serve process already owns ${path}`, { cause });
-		throw new ServeLockError("failed", `could not acquire serve lock ${path}: ${cause.message}`, { cause });
+//#region src/runtime-loader.ts
+function extractRuntimeModule(argv) {
+	const remaining = [];
+	let specifier;
+	let parsingOptions = true;
+	for (let index = 0; index < argv.length; index += 1) {
+		const argument = argv[index];
+		if (argument === "--") {
+			parsingOptions = false;
+			remaining.push(argument);
+			continue;
+		}
+		if (!parsingOptions) {
+			remaining.push(argument);
+			continue;
+		}
+		let candidate;
+		if (argument === "--runtime") {
+			candidate = argv[index + 1];
+			if (!candidate) throw new Error("Missing value for --runtime");
+			index += 1;
+		} else if (argument.startsWith("--runtime=")) {
+			candidate = argument.slice(10);
+			if (!candidate) throw new Error("Missing value for --runtime");
+		} else {
+			remaining.push(argument);
+			continue;
+		}
+		if (specifier) throw new Error("--runtime may be specified only once");
+		specifier = candidate;
 	}
-	let released = false;
 	return {
-		path,
-		async release() {
-			if (released) return;
-			released = true;
-			await releaseLock();
-		}
+		argv: remaining,
+		specifier
 	};
 }
-/** Always release after normal completion or startup/runtime failure. */
-async function withServeLock(root, work, options) {
-	const held = await acquireServeLock(root, options);
+function resolveRuntimeModuleUrl(specifier, cwd = process.cwd()) {
+	if (specifier.startsWith("file:")) return new URL(specifier).href;
+	if (isAbsolute(specifier) || specifier.startsWith("./") || specifier.startsWith("../")) return pathToFileURL(resolve(cwd, specifier)).href;
+	return pathToFileURL(createRequire(resolve(cwd, "package.json")).resolve(specifier)).href;
+}
+async function loadDaemonRuntimeAdapter(specifier, options = {}) {
+	let moduleUrl;
 	try {
-		return await work();
-	} finally {
-		await held.release();
+		moduleUrl = resolveRuntimeModuleUrl(specifier, options.cwd);
+	} catch (cause) {
+		throw new Error(`Unable to resolve runtime module "${specifier}" from ${options.cwd ?? process.cwd()}`, { cause });
+	}
+	let namespace;
+	try {
+		namespace = await import(moduleUrl);
+	} catch (cause) {
+		throw new Error(`Unable to load runtime module "${specifier}"`, { cause });
+	}
+	const adapter = namespace.default;
+	if (!isDaemonRuntimeAdapter(adapter)) throw new Error(`Runtime module "${specifier}" must default-export a DaemonRuntimeAdapter`);
+	return adapter;
+}
+function isDaemonRuntimeAdapter(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.runtimeKind === "string" && candidate.runtimeKind.length > 0 && typeof candidate.prepare === "function";
+}
+//#endregion
+//#region src/lib/agent-server/runtime-registry.ts
+var LOCKFILE_NAMES = [
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"yarn.lock",
+	"bun.lockb"
+];
+/** Local, operator-owned allowlist for executable daemon runtime modules. */
+var RuntimeRegistry = class {
+	constructor(root) {
+		this.root = root;
+	}
+	get path() {
+		return join(this.root, "runtime-registry.json");
 	}
+	list() {
+		if (!existsSync(this.path)) return [];
+		const value = JSON.parse(readFileSync(this.path, "utf8"));
+		if (!Array.isArray(value) || !value.every(isRegistration)) throw new AgentServerStoreError("invalid_state", "runtime registry contains an invalid registration");
+		return value;
+	}
+	async register(kind, specifier, cwd = process.cwd()) {
+		kind = assertStoreName("runtime kind", kind);
+		mkdirSync(this.root, {
+			recursive: true,
+			mode: 448
+		});
+		const moduleUrl = resolveRuntimeModuleUrl(specifier, cwd);
+		const adapter = await loadDaemonRuntimeAdapter(specifier, { cwd });
+		if (adapter.runtimeKind !== kind) throw new Error(`Runtime module provides "${adapter.runtimeKind}", not registered kind "${kind}".`);
+		if (!moduleUrl.startsWith("file:")) throw new Error("Runtime registration must resolve to a local file URL.");
+		const entryHash = hashFile(new URL(moduleUrl));
+		const lockfilePath = isPackageSpecifier(specifier) ? findLockfile(cwd) : void 0;
+		if (isPackageSpecifier(specifier) && !lockfilePath) throw new Error("Package runtime registration requires a pnpm, npm, Yarn, or Bun lockfile in the current project or a parent directory.");
+		const entry = {
+			kind,
+			moduleUrl,
+			entryHash,
+			...lockfilePath ? {
+				lockfilePath,
+				lockfileHash: hashPath(lockfilePath)
+			} : {},
+			registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const entries = this.list().filter((candidate) => candidate.kind !== kind);
+		entries.push(entry);
+		writeRegistry(this.path, entries);
+		return entry;
+	}
+	unregister(kind) {
+		kind = assertStoreName("runtime kind", kind);
+		const entries = this.list();
+		const next = entries.filter((entry) => entry.kind !== kind);
+		if (next.length === entries.length) return false;
+		writeRegistry(this.path, next);
+		return true;
+	}
+	resolve(kind) {
+		kind = assertStoreName("runtime kind", kind);
+		const entry = this.list().find((candidate) => candidate.kind === kind);
+		if (!entry) return void 0;
+		if (hashFile(new URL(entry.moduleUrl)) !== entry.entryHash) throw new Error(`Registered runtime "${kind}" has changed; re-register it before starting a run.`);
+		if (entry.lockfilePath && (!existsSync(entry.lockfilePath) || hashPath(entry.lockfilePath) !== entry.lockfileHash)) throw new Error(`Registered runtime "${kind}" lockfile has changed; re-register it before starting a run.`);
+		return entry;
+	}
+};
+function hashFile(url) {
+	return createHash("sha256").update(readFileSync(url)).digest("hex");
 }
-var ServeModelDiscoveryError = class extends Error {
-	name = "ServeModelDiscoveryError";
+function hashPath(path) {
+	return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+function isPackageSpecifier(specifier) {
+	return !specifier.startsWith("file:") && !specifier.startsWith(".") && !specifier.startsWith("/");
+}
+function findLockfile(cwd) {
+	let current = resolve(cwd);
+	for (;;) {
+		for (const name of LOCKFILE_NAMES) {
+			const candidate = join(current, name);
+			if (existsSync(candidate)) return candidate;
+		}
+		const parent = dirname(current);
+		if (parent === current) return void 0;
+		current = parent;
+	}
+}
+function isRegistration(value) {
+	if (!value || typeof value !== "object") return false;
+	const entry = value;
+	return typeof entry.kind === "string" && typeof entry.moduleUrl === "string" && entry.moduleUrl.startsWith("file:") && typeof entry.entryHash === "string" && typeof entry.registeredAt === "string" && (entry.lockfilePath === void 0 || typeof entry.lockfilePath === "string") && (entry.lockfileHash === void 0 || typeof entry.lockfileHash === "string") && entry.lockfilePath === void 0 === (entry.lockfileHash === void 0);
+}
+function writeRegistry(path, entries) {
+	const temp = `${path}.${process.pid}.tmp`;
+	writeFileSync(temp, `${JSON.stringify(entries, null, 2)}\n`, { mode: 384 });
+	renameSync(temp, path);
+}
+var AgentServerModelDiscoveryError = class extends Error {
+	name = "AgentServerModelDiscoveryError";
 	constructor(code, message, statusCode, options) {
 		super(message, options);
 		this.code = code;
@@ -8847,32 +9161,352 @@ function parseProviderBaseUrl(value, providerId) {
 	try {
 		parsed = new URL(value);
 	} catch (cause) {
-		throw new ServeModelDiscoveryError("invalid_provider", `provider "${providerId}" has an invalid base URL`, 400, { cause });
+		throw new AgentServerModelDiscoveryError("invalid_provider", `provider "${providerId}" has an invalid base URL`, 400, { cause });
 	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.search || parsed.hash) throw new ServeModelDiscoveryError("invalid_provider", `provider "${providerId}" base URL must be HTTP(S) without credentials, query, or fragment`, 400);
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.search || parsed.hash) throw new AgentServerModelDiscoveryError("invalid_provider", `provider "${providerId}" base URL must be HTTP(S) without credentials, query, or fragment`, 400);
+	if (isNonLoopbackPrivateAddress(parsed.hostname)) throw new AgentServerModelDiscoveryError("invalid_provider", `provider "${providerId}" base URL must not target a private network address`, 400);
 	return parsed;
 }
+function isNonLoopbackPrivateAddress(hostname) {
+	if (isIP(hostname) !== 4) return false;
+	const [first, second] = hostname.split(".").map(Number);
+	if (first === 127) return false;
+	return first === 10 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168 || first === 169 && second === 254;
+}
 function discoveryFailure(providerId, failures) {
-	if (failures.some((failure) => failure.kind === "http" && (failure.status === 401 || failure.status === 403))) return new ServeModelDiscoveryError("discovery_unauthorized", `provider "${providerId}" rejected model discovery; check its API key`, 502);
-	if (failures.some((failure) => failure.kind === "network")) return new ServeModelDiscoveryError("discovery_unavailable", `provider "${providerId}" could not be reached for model discovery`, 502);
-	if (failures.some((failure) => failure.kind === "invalid_response")) return new ServeModelDiscoveryError("discovery_invalid_response", `provider "${providerId}" returned an invalid model response`, 502);
-	return new ServeModelDiscoveryError("discovery_failed", `no models discovered for provider "${providerId}"`, 502);
+	if (failures.some((failure) => failure.kind === "http" && (failure.status === 401 || failure.status === 403))) return new AgentServerModelDiscoveryError("discovery_unauthorized", `provider "${providerId}" rejected model discovery; check its API key`, 502);
+	if (failures.some((failure) => failure.kind === "network")) return new AgentServerModelDiscoveryError("discovery_unavailable", `provider "${providerId}" could not be reached for model discovery`, 502);
+	if (failures.some((failure) => failure.kind === "invalid_response")) return new AgentServerModelDiscoveryError("discovery_invalid_response", `provider "${providerId}" returned an invalid model response`, 502);
+	return new AgentServerModelDiscoveryError("discovery_failed", `no models discovered for provider "${providerId}"`, 502);
 }
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
-//#region src/lib/serve/server.ts
+//#region src/lib/agent-server/protocol.ts
+var DateTime = Type.String({ format: "date-time" });
+var StringList = Type.Array(Type.String());
+function schemaRef(schema) {
+	const id = schema.$id;
+	if (typeof id !== "string" || id.length === 0) throw new Error("Agent Server protocol schemas must have an identifier");
+	return Type.Ref(id);
+}
+var AgentServerHealthSchema = Type.Object({ status: Type.Literal("ok") }, { $id: "AgentServerHealth" });
+var AgentServerProblemSchema = Type.Object({
+	code: Type.String(),
+	message: Type.String()
+}, { $id: "AgentServerProblem" });
+var AgentServerAgentSchema = Type.Object({
+	kind: Type.Union([Type.Literal("managed"), Type.Literal("external")]),
+	agentName: Type.String(),
+	identityId: Type.Optional(Type.String()),
+	fingerprint: Type.Optional(Type.String()),
+	apiUrl: Type.Optional(Type.String()),
+	teamId: Type.Optional(Type.String()),
+	configDir: Type.Optional(Type.String()),
+	createdAt: DateTime,
+	hasAgentKey: Type.Optional(Type.Boolean()),
+	hasPrivateKey: Type.Optional(Type.Boolean())
+}, { $id: "AgentServerAgent" });
+var AgentServerProviderSchema = Type.Object({
+	api: Type.String(),
+	baseUrl: Type.String({ format: "uri" }),
+	envName: Type.String(),
+	models: StringList,
+	hasApiKey: Type.Boolean()
+}, { $id: "AgentServerProvider" });
+var AgentServerRunRecordSchema = Type.Object({
+	id: Type.String(),
+	agent: Type.String(),
+	teamId: Type.String(),
+	profiles: StringList,
+	taskTypes: StringList,
+	mode: Type.Union([Type.Literal("poll"), Type.Literal("drain")]),
+	status: Type.Union([
+		Type.Literal("running"),
+		Type.Literal("exited"),
+		Type.Literal("stopped"),
+		Type.Literal("failed")
+	]),
+	pid: Type.Optional(Type.Number()),
+	exitCode: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+	startedAt: DateTime,
+	endedAt: Type.Optional(DateTime)
+}, { $id: "AgentServerRunRecord" });
+var AgentServerRunSchema = Type.Intersect([schemaRef(AgentServerRunRecordSchema), Type.Object({ active: Type.Boolean() })], { $id: "AgentServerRun" });
+var AgentServerSubscriptionSchema = Type.Object({
+	id: Type.String(),
+	name: Type.String(),
+	connected: Type.Boolean()
+}, { $id: "AgentServerSubscription" });
+var AgentServerSubscriptionLoginSchema = Type.Object({
+	providerId: Type.String(),
+	status: Type.Union([
+		Type.Literal("pending"),
+		Type.Literal("completed"),
+		Type.Literal("failed")
+	]),
+	authUrl: Type.Optional(Type.String({ format: "uri" })),
+	instructions: Type.Optional(Type.String()),
+	userCode: Type.Optional(Type.String()),
+	verificationUri: Type.Optional(Type.String({ format: "uri" })),
+	error: Type.Optional(Type.String())
+}, { $id: "AgentServerSubscriptionLogin" });
+var AgentServerStatusSchema = Type.Object({
+	version: Type.String(),
+	platform: Type.String(),
+	subscriptions: Type.Array(schemaRef(AgentServerSubscriptionSchema)),
+	agents: Type.Array(schemaRef(AgentServerAgentSchema)),
+	providers: Type.Record(Type.String(), schemaRef(AgentServerProviderSchema)),
+	runs: Type.Array(schemaRef(AgentServerRunSchema))
+}, { $id: "AgentServerStatus" });
+var PairingStartedSchema = Type.Object({
+	pairingId: Type.String(),
+	approvalPath: Type.String()
+}, { $id: "PairingStarted" });
+var PairingClaimedSchema = Type.Object({ token: Type.String() }, { $id: "PairingClaimed" });
+var PairingParamsSchema = Type.Object({ pairingId: Type.String() });
+var ProviderParamsSchema = Type.Object({ providerId: Type.String() });
+var AgentParamsSchema = Type.Object({ agentName: Type.String() });
+var RunParamsSchema = Type.Object({ runId: Type.String() });
+var CreateAgentSchema = Type.Object({
+	kind: Type.Union([Type.Literal("managed"), Type.Literal("external")]),
+	name: Type.String()
+}, { anyOf: [Type.Object({
+	kind: Type.Literal("managed"),
+	enrollmentToken: Type.String()
+}), Type.Object({
+	kind: Type.Literal("external"),
+	configDir: Type.String(),
+	apiUrl: Type.Optional(Type.String({ format: "uri" }))
+})] });
+var ReconcileAgentSchema = Type.Object({ action: Type.Union([Type.Literal("resume"), Type.Literal("abandon")]) });
+var ReconcileAgentResultSchema = Type.Union([schemaRef(AgentServerAgentSchema), Type.Object({ abandoned: Type.Literal(true) })], { $id: "ReconcileAgentResult" });
+var PutProviderSchema = Type.Object({
+	api: Type.String(),
+	baseUrl: Type.String({ format: "uri" }),
+	envName: Type.String(),
+	models: StringList,
+	apiKey: Type.Optional(Type.String())
+});
+var DiscoverModelsSchema = Type.Object({ models: StringList }, { $id: "DiscoveredModels" });
+var StartRunSchema = Type.Object({
+	agent: Type.String(),
+	teamId: Type.String(),
+	profiles: StringList,
+	taskTypes: StringList,
+	mode: Type.Union([Type.Literal("poll"), Type.Literal("drain")])
+});
+var CancelledSubscriptionSchema = Type.Object({
+	providerId: Type.String(),
+	status: Type.Literal("cancelled")
+}, { $id: "CancelledSubscription" });
+var LogStreamSchema = Type.String({
+	$id: "AgentServerLogStream",
+	contentMediaType: "text/event-stream"
+});
+var AGENT_SERVER_SCHEMAS = [
+	AgentServerHealthSchema,
+	AgentServerProblemSchema,
+	AgentServerAgentSchema,
+	AgentServerProviderSchema,
+	AgentServerRunRecordSchema,
+	AgentServerRunSchema,
+	AgentServerSubscriptionSchema,
+	AgentServerSubscriptionLoginSchema,
+	AgentServerStatusSchema,
+	PairingStartedSchema,
+	PairingClaimedSchema,
+	ReconcileAgentResultSchema,
+	DiscoverModelsSchema,
+	CancelledSubscriptionSchema,
+	LogStreamSchema
+];
+var pairedSecurity = [{ agentServerToken: [] }];
+var problemResponse = { default: schemaRef(AgentServerProblemSchema) };
+var AgentServerRouteSchemas = {
+	health: {
+		operationId: "getAgentServerHealth",
+		tags: ["system"],
+		response: { 200: schemaRef(AgentServerHealthSchema) }
+	},
+	startPairing: {
+		operationId: "startAgentServerPairing",
+		tags: ["pairing"],
+		response: {
+			201: schemaRef(PairingStartedSchema),
+			...problemResponse
+		}
+	},
+	claimPairing: {
+		operationId: "claimAgentServerPairing",
+		tags: ["pairing"],
+		params: PairingParamsSchema,
+		response: {
+			200: schemaRef(PairingClaimedSchema),
+			...problemResponse
+		}
+	},
+	status: {
+		operationId: "getAgentServerStatus",
+		tags: ["system"],
+		security: pairedSecurity,
+		response: {
+			200: schemaRef(AgentServerStatusSchema),
+			...problemResponse
+		}
+	},
+	listAgents: {
+		operationId: "listAgentServerAgents",
+		tags: ["agents"],
+		security: pairedSecurity,
+		response: {
+			200: Type.Array(schemaRef(AgentServerAgentSchema)),
+			...problemResponse
+		}
+	},
+	createAgent: {
+		operationId: "createAgentServerAgent",
+		tags: ["agents"],
+		security: pairedSecurity,
+		body: CreateAgentSchema,
+		response: {
+			201: schemaRef(AgentServerAgentSchema),
+			...problemResponse
+		}
+	},
+	reconcileAgent: {
+		operationId: "reconcileAgentServerAgent",
+		tags: ["agents"],
+		security: pairedSecurity,
+		params: AgentParamsSchema,
+		body: ReconcileAgentSchema,
+		response: {
+			200: schemaRef(ReconcileAgentResultSchema),
+			...problemResponse
+		}
+	},
+	listProviders: {
+		operationId: "listAgentServerProviders",
+		tags: ["providers"],
+		security: pairedSecurity,
+		response: {
+			200: Type.Record(Type.String(), schemaRef(AgentServerProviderSchema)),
+			...problemResponse
+		}
+	},
+	discoverModels: {
+		operationId: "discoverAgentServerProviderModels",
+		tags: ["providers"],
+		security: pairedSecurity,
+		params: ProviderParamsSchema,
+		response: {
+			200: schemaRef(DiscoverModelsSchema),
+			...problemResponse
+		}
+	},
+	putProvider: {
+		operationId: "putAgentServerProvider",
+		tags: ["providers"],
+		security: pairedSecurity,
+		params: ProviderParamsSchema,
+		body: PutProviderSchema,
+		response: {
+			200: schemaRef(AgentServerProviderSchema),
+			...problemResponse
+		}
+	},
+	listSubscriptions: {
+		operationId: "listAgentServerSubscriptions",
+		tags: ["subscriptions"],
+		security: pairedSecurity,
+		response: {
+			200: Type.Array(schemaRef(AgentServerSubscriptionSchema)),
+			...problemResponse
+		}
+	},
+	startSubscriptionLogin: {
+		operationId: "startAgentServerSubscriptionLogin",
+		tags: ["subscriptions"],
+		security: pairedSecurity,
+		params: ProviderParamsSchema,
+		response: {
+			201: schemaRef(AgentServerSubscriptionLoginSchema),
+			...problemResponse
+		}
+	},
+	getSubscriptionLogin: {
+		operationId: "getAgentServerSubscriptionLogin",
+		tags: ["subscriptions"],
+		security: pairedSecurity,
+		params: ProviderParamsSchema,
+		response: {
+			200: schemaRef(AgentServerSubscriptionLoginSchema),
+			...problemResponse
+		}
+	},
+	cancelSubscriptionLogin: {
+		operationId: "cancelAgentServerSubscriptionLogin",
+		tags: ["subscriptions"],
+		security: pairedSecurity,
+		params: ProviderParamsSchema,
+		response: {
+			200: schemaRef(CancelledSubscriptionSchema),
+			...problemResponse
+		}
+	},
+	listRuns: {
+		operationId: "listAgentServerRuns",
+		tags: ["runs"],
+		security: pairedSecurity,
+		response: {
+			200: Type.Array(schemaRef(AgentServerRunSchema)),
+			...problemResponse
+		}
+	},
+	startRun: {
+		operationId: "startAgentServerRun",
+		tags: ["runs"],
+		security: pairedSecurity,
+		body: StartRunSchema,
+		response: {
+			201: schemaRef(AgentServerRunSchema),
+			...problemResponse
+		}
+	},
+	stopRun: {
+		operationId: "stopAgentServerRun",
+		tags: ["runs"],
+		security: pairedSecurity,
+		params: RunParamsSchema,
+		response: {
+			200: schemaRef(AgentServerRunRecordSchema),
+			...problemResponse
+		}
+	},
+	streamRunLogs: {
+		operationId: "streamAgentServerRunLogs",
+		tags: ["runs"],
+		security: pairedSecurity,
+		params: RunParamsSchema,
+		response: {
+			200: schemaRef(LogStreamSchema),
+			...problemResponse
+		}
+	}
+};
+//#endregion
+//#region src/lib/agent-server/server.ts
 /**
-* HTTP surface of `moltnet-agent serve` (#2061), built on the shared
+* HTTP surface of `moltnet-agent server` (#2061), built on the shared
 * loopback-companion security profile (#2066): loopback Host enforcement,
 * exact-origin CORS, Fetch-Metadata guards, strict JSON parsing.
 *
 * Everything under `/v1` except the pairing bootstrap requires a paired
-* origin: the `x-moltnet-serve-token` header must verify against the
+* origin: the `x-moltnet-agent-server-token` header must verify against the
 * origin-bound token issued by the one-click pairing ceremony.
 */
-var SERVE_TOKEN_HEADER = "x-moltnet-serve-token";
+var AGENT_SERVER_TOKEN_HEADER = "x-moltnet-agent-server-token";
 var BODY_LIMIT = 64 * 1024;
 var LOG_POLL_INTERVAL_MS = 500;
 var LOG_STREAM_MAX_DURATION_MS = 3600 * 1e3;
@@ -8881,7 +9515,7 @@ var LOG_READ_LIMIT_BYTES = 256 * 1024;
 var RUN_HISTORY_LIMIT = 100;
 var RATE_LIMIT_MAX = 120;
 var RATE_LIMIT_WINDOW_MS = 6e4;
-async function readServeLogDelta(handle, state, limit = LOG_READ_LIMIT_BYTES) {
+async function readAgentServerLogDelta(handle, state, limit = LOG_READ_LIMIT_BYTES) {
 	const info = await handle.stat();
 	if (!info.isFile() || info.size <= state.offset) return {
 		lines: [],
@@ -8929,8 +9563,8 @@ async function readServeLogDelta(handle, state, limit = LOG_READ_LIMIT_BYTES) {
 		omitted
 	};
 }
-var ServeHttpError = class extends Error {
-	name = "ServeHttpError";
+var AgentServerHttpError = class extends Error {
+	name = "AgentServerHttpError";
 	constructor(statusCode, code, message) {
 		super(message);
 		this.statusCode = statusCode;
@@ -8939,23 +9573,23 @@ var ServeHttpError = class extends Error {
 };
 function requireBody(request) {
 	const body = request.body;
-	if (typeof body !== "object" || body === null || Array.isArray(body)) throw new ServeHttpError(400, "invalid_body", "JSON object body required");
+	if (typeof body !== "object" || body === null || Array.isArray(body)) throw new AgentServerHttpError(400, "invalid_body", "JSON object body required");
 	return body;
 }
 function requireString(body, field) {
 	const value = body[field];
-	if (typeof value !== "string" || value.trim().length === 0) throw new ServeHttpError(400, "invalid_body", `"${field}" must be a non-empty string`);
+	if (typeof value !== "string" || value.trim().length === 0) throw new AgentServerHttpError(400, "invalid_body", `"${field}" must be a non-empty string`);
 	return value.trim();
 }
 function optionalString(body, field) {
 	const value = body[field];
 	if (value === void 0 || value === null) return void 0;
-	if (typeof value !== "string" || value.trim().length === 0) throw new ServeHttpError(400, "invalid_body", `"${field}" must be a non-empty string when present`);
+	if (typeof value !== "string" || value.trim().length === 0) throw new AgentServerHttpError(400, "invalid_body", `"${field}" must be a non-empty string when present`);
 	return value.trim();
 }
 function stringArray(body, field, options = {}) {
 	const value = body[field];
-	if (!Array.isArray(value) || !options.allowEmpty && value.length === 0 || value.some((item) => typeof item !== "string" || item.length === 0)) throw new ServeHttpError(400, "invalid_body", `"${field}" must be ${options.allowEmpty ? "a" : "a non-empty"} string array`);
+	if (!Array.isArray(value) || !options.allowEmpty && value.length === 0 || value.some((item) => typeof item !== "string" || item.length === 0)) throw new AgentServerHttpError(400, "invalid_body", `"${field}" must be ${options.allowEmpty ? "a" : "a non-empty"} string array`);
 	return value;
 }
 function requestOperationSignal(request, shutdownSignal) {
@@ -8964,16 +9598,18 @@ function requestOperationSignal(request, shutdownSignal) {
 	else request.raw.once("aborted", () => disconnected.abort());
 	return shutdownSignal ? AbortSignal.any([disconnected.signal, shutdownSignal]) : disconnected.signal;
 }
-function buildServeServer(options) {
+function buildAgentServer(options) {
 	const { pairing } = options;
 	const app = options.logger ? Fastify({
 		bodyLimit: BODY_LIMIT,
 		loggerInstance: options.logger
 	}) : Fastify({ bodyLimit: BODY_LIMIT });
+	options.registerOpenApi?.(app);
+	for (const schema of AGENT_SERVER_SCHEMAS) app.addSchema(schema);
 	registerLoopbackSecurity(app, {
 		allowedOrigins: options.allowedOrigins,
 		...options.selfOrigin ? { selfOrigins: [options.selfOrigin] } : {},
-		allowedHeaders: [SERVE_TOKEN_HEADER],
+		allowedHeaders: [AGENT_SERVER_TOKEN_HEADER],
 		methods: [
 			"GET",
 			"POST",
@@ -8986,35 +9622,37 @@ function buildServeServer(options) {
 		global: false,
 		max: options.rateLimitMax ?? RATE_LIMIT_MAX,
 		timeWindow: RATE_LIMIT_WINDOW_MS,
-		errorResponseBuilder: () => new ServeHttpError(429, "rate_limited", "Too many requests"),
+		errorResponseBuilder: () => new AgentServerHttpError(429, "rate_limited", "Too many requests"),
 		keyGenerator: (request) => {
 			const origin = request.headers.origin;
 			return isConfiguredOrigin(origin, options) ? `origin:${origin}` : `ip:${request.ip}`;
 		}
 	});
-	app.after(() => app.addHook("onRequest", app.rateLimit()));
 	app.addContentTypeParser("application/x-www-form-urlencoded", { parseAs: "buffer" }, (_request, body, done) => {
 		try {
 			const form = new TextDecoder("utf-8", { fatal: true }).decode(typeof body === "string" ? Buffer.from(body) : body);
 			done(null, new URLSearchParams(form));
 		} catch {
-			done(new ServeHttpError(400, "invalid_body", "Form body is invalid"), void 0);
+			done(new AgentServerHttpError(400, "invalid_body", "Form body is invalid"), void 0);
 		}
 	});
 	const requirePairedOrigin = (request) => {
 		const origin = requireOriginHeader(request.headers);
-		const token = request.headers[SERVE_TOKEN_HEADER];
-		if (typeof token !== "string" || token.length === 0) throw new ServeHttpError(401, "pairing_required", "Pairing token is required");
+		const token = request.headers[AGENT_SERVER_TOKEN_HEADER];
+		if (typeof token !== "string" || token.length === 0) throw new AgentServerHttpError(401, "pairing_required", "Pairing token is required");
 		pairing.verify(origin, token);
 		return origin;
 	};
-	app.get("/health", async () => ({ status: "ok" }));
-	registerPairingRoutes(app, pairing);
-	registerStatusRoute(app, options, requirePairedOrigin);
-	registerAgentRoutes(app, options, requirePairedOrigin);
-	registerProviderRoutes(app, options, requirePairedOrigin);
-	registerSubscriptionRoutes(app, options, requirePairedOrigin);
-	registerRunRoutes(app, options, requirePairedOrigin);
+	app.after(() => {
+		app.addHook("onRequest", app.rateLimit());
+		app.get("/health", { schema: AgentServerRouteSchemas.health }, async () => ({ status: "ok" }));
+		registerPairingRoutes(app, pairing);
+		registerStatusRoute(app, options, requirePairedOrigin);
+		registerAgentRoutes(app, options, requirePairedOrigin);
+		registerProviderRoutes(app, options, requirePairedOrigin);
+		registerSubscriptionRoutes(app, options, requirePairedOrigin);
+		registerRunRoutes(app, options, requirePairedOrigin);
+	});
 	app.addHook("onClose", () => {
 		options.subscriptions.close();
 	});
@@ -9023,13 +9661,13 @@ function buildServeServer(options) {
 		message: "Route is not available"
 	}));
 	app.setErrorHandler(async (error, request, reply) => {
-		const { statusCode, code, message } = normalizeServeError(error);
+		const { statusCode, code, message } = normalizeAgentServerError(error);
 		if (statusCode === 500) request.log.error({
 			...safeErrorContext(error),
-			code: "serve_request_failed",
+			code: "agent_server_request_failed",
 			method: request.method,
 			route: request.routeOptions.url
-		}, "Serve request failed");
+		}, "AgentServer request failed");
 		return reply.code(statusCode).send({
 			code,
 			message
@@ -9038,11 +9676,11 @@ function buildServeServer(options) {
 	return app;
 }
 function registerPairingRoutes(app, pairing) {
-	app.post("/v1/pairings", async (request, reply) => {
+	app.post("/v1/pairings", { schema: AgentServerRouteSchemas.startPairing }, async (request, reply) => {
 		const origin = requireOriginHeader(request.headers);
 		return reply.code(201).send(pairing.start(origin));
 	});
-	app.get("/pairings/:pairingId", async (request, reply) => {
+	app.get("/pairings/:pairingId", { schema: { hide: true } }, async (request, reply) => {
 		assertNavigationRequest(request.headers);
 		const { pairingId } = request.params;
 		const approval = pairing.approval(pairingId);
@@ -9052,17 +9690,17 @@ function registerPairingRoutes(app, pairing) {
 			confirmToken: approval.confirmToken
 		}));
 	});
-	app.post("/pairings/:pairingId/confirm", async (request, reply) => {
+	app.post("/pairings/:pairingId/confirm", { schema: { hide: true } }, async (request, reply) => {
 		rejectExplicitCrossSite(request.headers);
 		const { pairingId } = request.params;
-		if (!(request.body instanceof URLSearchParams)) throw new ServeHttpError(400, "invalid_body", "Confirmation form is invalid");
+		if (!(request.body instanceof URLSearchParams)) throw new AgentServerHttpError(400, "invalid_body", "Confirmation form is invalid");
 		const { origin } = pairing.confirm(pairingId, request.body.get("confirmToken") ?? "");
 		return reply.type("text/html; charset=utf-8").send(renderPairingResultPage({
 			title: "Connection approved",
 			message: `${origin} can now manage local MoltNet agents on this machine.`
 		}));
 	});
-	app.post("/v1/pairings/:pairingId/claim", async (request) => {
+	app.post("/v1/pairings/:pairingId/claim", { schema: AgentServerRouteSchemas.claimPairing }, async (request) => {
 		const origin = requireOriginHeader(request.headers);
 		const { pairingId } = request.params;
 		return pairing.claim(pairingId, origin);
@@ -9070,7 +9708,7 @@ function registerPairingRoutes(app, pairing) {
 }
 function registerStatusRoute(app, options, requirePairedOrigin) {
 	const { store, runs } = options;
-	app.get("/v1/status", async (request) => {
+	app.get("/v1/status", { schema: AgentServerRouteSchemas.status }, async (request) => {
 		requirePairedOrigin(request);
 		return {
 			version: options.version,
@@ -9084,17 +9722,20 @@ function registerStatusRoute(app, options, requirePairedOrigin) {
 }
 function registerAgentRoutes(app, options, requirePairedOrigin) {
 	const { store } = options;
-	app.get("/v1/agents", async (request) => {
+	app.get("/v1/agents", { schema: AgentServerRouteSchemas.listAgents }, async (request) => {
 		requirePairedOrigin(request);
 		return store.listActivations().map((activation) => publicAgentView(store, activation));
 	});
-	app.post("/v1/agents", async (request, reply) => {
+	app.post("/v1/agents", {
+		schema: AgentServerRouteSchemas.createAgent,
+		attachValidation: true
+	}, async (request, reply) => {
 		requirePairedOrigin(request);
 		const body = requireBody(request);
 		const signal = requestOperationSignal(request, options.shutdownSignal);
 		const kind = requireString(body, "kind");
 		if (kind === "managed") {
-			if (body["apiUrl"] !== void 0) throw new ServeHttpError(400, "invalid_body", "managed agent registration uses the configured MoltNet API URL; apiUrl cannot be overridden");
+			if (body["apiUrl"] !== void 0) throw new AgentServerHttpError(400, "invalid_body", "managed agent registration uses the configured MoltNet API URL; apiUrl cannot be overridden");
 			const entry = await createManagedAgent(store, options.secrets, {
 				name: requireString(body, "name"),
 				apiUrl: options.defaultApiUrl,
@@ -9113,13 +9754,16 @@ function registerAgentRoutes(app, options, requirePairedOrigin) {
 			});
 			return reply.code(201).send(publicAgentView(store, entry.activation));
 		}
-		throw new ServeHttpError(400, "invalid_body", "\"kind\" must be \"managed\" or \"external\"");
+		throw new AgentServerHttpError(400, "invalid_body", "\"kind\" must be \"managed\" or \"external\"");
 	});
-	app.post("/v1/agents/:agentName/reconcile", async (request) => {
+	app.post("/v1/agents/:agentName/reconcile", {
+		schema: AgentServerRouteSchemas.reconcileAgent,
+		attachValidation: true
+	}, async (request) => {
 		requirePairedOrigin(request);
 		const { agentName } = request.params;
 		const action = requireString(requireBody(request), "action");
-		if (action !== "resume" && action !== "abandon") throw new ServeHttpError(400, "invalid_body", "\"action\" must be \"resume\" or \"abandon\"");
+		if (action !== "resume" && action !== "abandon") throw new AgentServerHttpError(400, "invalid_body", "\"action\" must be \"resume\" or \"abandon\"");
 		const reconciled = await reconcileManagedRegistration(store, options.secrets, agentName, action, void 0, requestOperationSignal(request, options.shutdownSignal));
 		return reconciled ? publicAgentView(store, reconciled.activation) : { abandoned: true };
 	});
@@ -9132,16 +9776,16 @@ function registerProviderRoutes(app, options, requirePairedOrigin) {
 		mutationQueue = result.then(() => void 0, () => void 0);
 		return result;
 	};
-	app.get("/v1/providers", async (request) => {
+	app.get("/v1/providers", { schema: AgentServerRouteSchemas.listProviders }, async (request) => {
 		requirePairedOrigin(request);
 		return Object.fromEntries(Object.entries(store.readProviders()).map(([id, provider]) => [id, providerView(provider)]));
 	});
-	app.post("/v1/providers/:providerId/discover-models", async (request) => {
+	app.post("/v1/providers/:providerId/discover-models", { schema: AgentServerRouteSchemas.discoverModels }, async (request) => {
 		requirePairedOrigin(request);
 		const { providerId: rawProviderId } = request.params;
 		const providerId = assertProviderId(rawProviderId);
 		const provider = store.readProviders()[providerId];
-		if (!provider) throw new ServeHttpError(404, "provider_not_found", `provider "${providerId}" was not found`);
+		if (!provider) throw new AgentServerHttpError(404, "provider_not_found", `provider "${providerId}" was not found`);
 		const parsed = parseProviderBaseUrl(provider.baseUrl, providerId);
 		const baseUrl = parsed.href.replace(/\/$/u, "");
 		let apiKey;
@@ -9150,10 +9794,10 @@ function registerProviderRoutes(app, options, requirePairedOrigin) {
 		} catch (error) {
 			request.log.warn({
 				...safeErrorContext(error),
-				code: "serve_provider_secret_unavailable",
+				code: "agent_server_provider_secret_unavailable",
 				providerId
 			}, "Provider API key could not be resolved for model discovery");
-			throw new ServeHttpError(400, "provider_secret_unavailable", `provider "${providerId}" API key could not be resolved`);
+			throw new AgentServerHttpError(400, "provider_secret_unavailable", `provider "${providerId}" API key could not be resolved`);
 		}
 		const headers = apiKey ? { authorization: `Bearer ${apiKey}` } : {};
 		const fetchImpl = options.discoverFetch ?? fetch;
@@ -9174,7 +9818,7 @@ function registerProviderRoutes(app, options, requirePairedOrigin) {
 					errorType
 				});
 				request.log.warn({
-					code: "serve_provider_discovery_request_failed",
+					code: "agent_server_provider_discovery_request_failed",
 					endpoint,
 					errorType,
 					providerId
@@ -9187,7 +9831,7 @@ function registerProviderRoutes(app, options, requirePairedOrigin) {
 					status: response.status
 				});
 				const context = {
-					code: "serve_provider_discovery_upstream_error",
+					code: "agent_server_provider_discovery_upstream_error",
 					endpoint,
 					providerId,
 					statusCode: response.status
@@ -9201,7 +9845,7 @@ function registerProviderRoutes(app, options, requirePairedOrigin) {
 			} catch {
 				failures.push({ kind: "invalid_response" });
 				request.log.warn({
-					code: "serve_provider_discovery_invalid_json",
+					code: "agent_server_provider_discovery_invalid_json",
 					endpoint,
 					providerId
 				}, "Provider model discovery returned invalid JSON");
@@ -9212,19 +9856,22 @@ function registerProviderRoutes(app, options, requirePairedOrigin) {
 		if (collector.size === 0) collector.addOllamaResponse(await tryJson("ollama_tags", `${parsed.origin}/api/tags`));
 		const result = collector.result(providerId, failures);
 		if (result.discoveredCount > result.models.length) request.log.warn({
-			code: "serve_provider_discovery_truncated",
+			code: "agent_server_provider_discovery_truncated",
 			discoveredCount: result.discoveredCount,
 			providerId,
 			returnedCount: 500
 		}, "Provider model discovery result was truncated");
 		request.log.info({
-			code: "serve_provider_discovery_completed",
+			code: "agent_server_provider_discovery_completed",
 			modelCount: result.models.length,
 			providerId
 		}, "Provider model discovery completed");
 		return { models: result.models };
 	});
-	app.put("/v1/providers/:providerId", async (request, reply) => {
+	app.put("/v1/providers/:providerId", {
+		schema: AgentServerRouteSchemas.putProvider,
+		attachValidation: true
+	}, async (request, reply) => {
 		requirePairedOrigin(request);
 		const { providerId: rawProviderId } = request.params;
 		const providerId = assertProviderId(rawProviderId);
@@ -9261,22 +9908,22 @@ function runViews(runs) {
 	}));
 }
 function registerSubscriptionRoutes(app, options, requirePairedOrigin) {
-	app.get("/v1/subscriptions", async (request) => {
+	app.get("/v1/subscriptions", { schema: AgentServerRouteSchemas.listSubscriptions }, async (request) => {
 		requirePairedOrigin(request);
 		return options.subscriptions.list();
 	});
-	app.post("/v1/subscriptions/:providerId/login", async (request, reply) => {
+	app.post("/v1/subscriptions/:providerId/login", { schema: AgentServerRouteSchemas.startSubscriptionLogin }, async (request, reply) => {
 		requirePairedOrigin(request);
 		const { providerId } = request.params;
 		const login = await options.subscriptions.start(providerId);
 		return reply.code(201).send(login);
 	});
-	app.get("/v1/subscriptions/:providerId/login", async (request) => {
+	app.get("/v1/subscriptions/:providerId/login", { schema: AgentServerRouteSchemas.getSubscriptionLogin }, async (request) => {
 		requirePairedOrigin(request);
 		const { providerId } = request.params;
 		return options.subscriptions.status(providerId);
 	});
-	app.delete("/v1/subscriptions/:providerId/login", async (request) => {
+	app.delete("/v1/subscriptions/:providerId/login", { schema: AgentServerRouteSchemas.cancelSubscriptionLogin }, async (request) => {
 		requirePairedOrigin(request);
 		const { providerId } = request.params;
 		return options.subscriptions.cancel(providerId);
@@ -9284,11 +9931,14 @@ function registerSubscriptionRoutes(app, options, requirePairedOrigin) {
 }
 function registerRunRoutes(app, options, requirePairedOrigin) {
 	const { runs } = options;
-	app.get("/v1/runs", async (request) => {
+	app.get("/v1/runs", { schema: AgentServerRouteSchemas.listRuns }, async (request) => {
 		requirePairedOrigin(request);
 		return runViews(runs);
 	});
-	app.post("/v1/runs", async (request, reply) => {
+	app.post("/v1/runs", {
+		schema: AgentServerRouteSchemas.startRun,
+		attachValidation: true
+	}, async (request, reply) => {
 		requirePairedOrigin(request);
 		const body = requireBody(request);
 		const record = await runs.start({
@@ -9298,9 +9948,12 @@ function registerRunRoutes(app, options, requirePairedOrigin) {
 			taskTypes: stringArray(body, "taskTypes"),
 			mode: requireString(body, "mode")
 		}, requestOperationSignal(request, options.shutdownSignal));
-		return reply.code(201).send(record);
+		return reply.code(201).send({
+			...record,
+			active: runs.isActive(record.id)
+		});
 	});
-	app.delete("/v1/runs/:runId", async (request) => {
+	app.delete("/v1/runs/:runId", { schema: AgentServerRouteSchemas.stopRun }, async (request) => {
 		requirePairedOrigin(request);
 		const { runId } = request.params;
 		return runs.stop(runId);
@@ -9310,13 +9963,14 @@ function registerRunRoutes(app, options, requirePairedOrigin) {
 function registerRunLogRoute(app, options, requirePairedOrigin) {
 	const { runs, store } = options;
 	let openStreams = 0;
-	app.get("/v1/runs/:runId/logs", async (request, reply) => {
+	app.get("/v1/runs/:runId/logs", { schema: AgentServerRouteSchemas.streamRunLogs }, async (request, reply) => {
 		requirePairedOrigin(request);
 		const { runId } = request.params;
 		const record = runs.status(runId);
 		store.resolveRunLogPath(record.id);
-		if (openStreams >= MAX_LOG_STREAMS) throw new ServeHttpError(429, "rate_limited", "Too many concurrent log streams");
+		if (openStreams >= MAX_LOG_STREAMS) throw new AgentServerHttpError(429, "rate_limited", "Too many concurrent log streams");
 		openStreams += 1;
+		reply.hijack();
 		reply.raw.writeHead(200, {
 			"content-type": "text/event-stream",
 			"cache-control": "no-store",
@@ -9355,7 +10009,7 @@ function registerRunLogRoute(app, options, requirePairedOrigin) {
 		const push = async () => {
 			const handle = await open(store.resolveRunLogPath(record.id), constants.O_RDONLY | constants.O_NOFOLLOW);
 			try {
-				const { lines, omitted } = await readServeLogDelta(handle, readState);
+				const { lines, omitted } = await readAgentServerLogDelta(handle, readState);
 				if (omitted) await writeData("[older log output omitted]");
 				for (const line of lines) await writeData(line);
 			} finally {
@@ -9366,9 +10020,9 @@ function registerRunLogRoute(app, options, requirePairedOrigin) {
 			if (closed) return;
 			request.log.warn({
 				...safeErrorContext(error),
-				code: "serve_log_tail_failed",
+				code: "agent_server_log_tail_failed",
 				runId
-			}, "serve log tail failed");
+			}, "Agent Server log tail failed");
 			finish(true);
 		};
 		const schedule = () => {
@@ -9381,7 +10035,7 @@ function registerRunLogRoute(app, options, requirePairedOrigin) {
 			}, LOG_POLL_INTERVAL_MS);
 			pollTimer.unref();
 		};
-		request.raw.on("close", () => finish());
+		reply.raw.on("close", () => finish());
 		try {
 			await push();
 			if (runs.isActive(record.id)) schedule();
@@ -9426,8 +10080,8 @@ function corsHeadersFor(request, options) {
 function isConfiguredOrigin(origin, options) {
 	return typeof origin === "string" && (options.allowedOrigins.includes(origin) || origin === options.selfOrigin);
 }
-function normalizeServeError(error) {
-	if (error instanceof ServeHttpError) return {
+function normalizeAgentServerError(error) {
+	if (error instanceof AgentServerHttpError) return {
 		statusCode: error.statusCode,
 		code: error.code,
 		message: error.message
@@ -9437,32 +10091,32 @@ function normalizeServeError(error) {
 		code: error.kind,
 		message: error.message
 	};
-	if (error instanceof ServePairingError) return {
+	if (error instanceof AgentServerPairingError) return {
 		statusCode: error.code === "pairing_not_found" ? 404 : error.code === "pairing_token_invalid" || error.code === "pairing_not_approved" ? 401 : 403,
 		code: error.code,
 		message: error.message
 	};
-	if (error instanceof ServeStoreError) return {
+	if (error instanceof AgentServerStoreError) return {
 		statusCode: error.code === "not_found" ? 404 : error.code === "io_error" ? 500 : 400,
 		code: error.code,
 		message: error.message
 	};
-	if (error instanceof ServeRunError) return {
+	if (error instanceof AgentServerRunError) return {
 		statusCode: error.code === "run_not_found" ? 404 : 400,
 		code: error.code,
 		message: error.message
 	};
-	if (error instanceof ServeSubscriptionError) return {
+	if (error instanceof AgentServerSubscriptionError) return {
 		statusCode: error.code === "login_not_found" ? 404 : error.code === "provider_unknown" ? 404 : 400,
 		code: error.code,
 		message: error.message
 	};
-	if (error instanceof ServeModelDiscoveryError) return {
+	if (error instanceof AgentServerModelDiscoveryError) return {
 		statusCode: error.statusCode,
 		code: error.code,
 		message: error.message
 	};
-	if (error instanceof ServeIdentityError) return {
+	if (error instanceof AgentServerIdentityError) return {
 		statusCode: error.code === "agent_exists" ? 409 : 400,
 		code: error.code,
 		message: error.message
@@ -9474,9 +10128,9 @@ function normalizeServeError(error) {
 	};
 }
 //#endregion
-//#region src/cli/serve.ts
+//#region src/cli/server.ts
 /**
-* `moltnet-agent serve` — per-user loopback supervisor (#2061).
+* `moltnet-agent server` — per-user loopback supervisor (#2061).
 *
 * Starts nothing on its own: it binds 127.0.0.1 and waits for a paired
 * Console origin to configure agents/providers and start/stop runs.
@@ -9485,12 +10139,12 @@ var DEFAULT_PORT = 17374;
 var DEFAULT_ALLOWED_ORIGINS = "https://console.themolt.net";
 var DEFAULT_API_URL = "https://api.themolt.net";
 var SHUTDOWN_TIMEOUT_MS = 15e3;
-async function runServe(argv) {
+async function runAgentServer(argv) {
 	if (isHelpFlag(argv)) {
-		console.log(SERVE_HELP);
+		console.log(AGENT_SERVER_HELP);
 		return 0;
 	}
-	const envConfig = loadServeEnvConfig();
+	const envConfig = loadAgentServerEnvConfig();
 	const { values } = parseArgs({
 		args: argv,
 		options: {
@@ -9506,19 +10160,19 @@ async function runServe(argv) {
 		return 1;
 	}
 	const allowedOrigins = parseAllowedOrigins(values["allowed-origins"] ?? (envConfig.allowedOrigins || DEFAULT_ALLOWED_ORIGINS));
-	const root = values.root ?? resolveServeRoot({
+	const root = values.root ?? resolveAgentServerRoot({
 		root: envConfig.root,
 		xdgConfigHome: envConfig.xdgConfigHome
 	});
 	const defaultApiUrl = values["api-url"] ?? (envConfig.apiUrl || DEFAULT_API_URL);
-	const store = new ServeStore(root).ensure();
+	const store = new AgentServerStore(root).ensure();
 	const { logger, shutdown: shutdownLogger } = createRootLogger({
-		name: "agent-daemon.serve",
+		name: "agent-daemon.server",
 		level: envConfig.logLevel || "info"
 	});
 	try {
 		try {
-			return await withServeLock(root, async () => {
+			return await withAgentServerLock(root, async () => {
 				const secrets = new FileSecretProvider({
 					root: store.secretsDir,
 					writable: true
@@ -9527,7 +10181,7 @@ async function runServe(argv) {
 				const externalSecretProviders = createNodeSecretProviderRegistry();
 				const pairing = new PairingService();
 				const shutdownController = new AbortController();
-				const subscriptions = new ProviderLoginService({
+				const subscriptions = await ProviderLoginService.create({
 					authPath: store.piAuthJsonPath,
 					logger
 				});
@@ -9536,9 +10190,10 @@ async function runServe(argv) {
 					secretProviders,
 					externalSecretProviders,
 					baseEnv: processEnvSnapshot(),
-					logger
+					logger,
+					runtimeRegistry: new RuntimeRegistry(store.root)
 				});
-				const app = buildServeServer({
+				const app = buildAgentServer({
 					store,
 					secrets,
 					secretProviders,
@@ -9558,11 +10213,11 @@ async function runServe(argv) {
 						host: "127.0.0.1",
 						port
 					});
-					console.error(`moltnet-agent serve listening on ${address}`);
+					console.error(`moltnet-agent server listening on ${address}`);
 					console.error(`config root: ${root}`);
 					console.error(`allowed origins: ${allowedOrigins.join(", ")}`);
 					console.error("Pair from the Console \"Local runtime\" page; approve the one-click prompt this server opens.");
-					return await waitForServeShutdown(runs, app, shutdownController);
+					return await waitForAgentServerShutdown(runs, app, shutdownController);
 				} catch (cause) {
 					await app.close().catch(() => void 0);
 					throw cause;
@@ -9573,7 +10228,7 @@ async function runServe(argv) {
 				process.kill(process.pid, "SIGTERM");
 			} });
 		} catch (cause) {
-			if (cause instanceof ServeLockError) {
+			if (cause instanceof AgentServerLockError) {
 				console.error(cause.message);
 				return 1;
 			}
@@ -9583,7 +10238,7 @@ async function runServe(argv) {
 		await shutdownLogger();
 	}
 }
-function waitForServeShutdown(runs, app, shutdownController) {
+function waitForAgentServerShutdown(runs, app, shutdownController) {
 	return new Promise((resolvePromise) => {
 		let shuttingDown = false;
 		const shutdown = () => {
@@ -9801,15 +10456,128 @@ function parseLimit(raw) {
 	return value;
 }
 //#endregion
+//#region src/lib/update.ts
+var UPDATE_MANIFEST_URL = "https://themolt.net/download/manifest.json";
+var UPDATE_CACHE_TTL_MS = 1440 * 60 * 1e3;
+var UPDATE_ERROR_CACHE_TTL_MS = 300 * 1e3;
+function detectDaemonInstallMethod(executable = process.argv[1] ?? "") {
+	const path = executable.replaceAll("\\", "/");
+	if (path.includes("/node_modules/@themoltnet/agent-daemon/")) return "npm";
+	if (path.includes("/.local/share/moltnet/") || path.includes("/opt/moltnet/")) return "bundle";
+	return "direct";
+}
+function daemonUpdateCommand(method) {
+	if (method === "npm") return "npm install -g @themoltnet/agent-daemon@latest";
+	return "curl -fsSL https://themolt.net/install/agent | sh";
+}
+async function checkDaemonUpdate(input) {
+	const installMethod = detectDaemonInstallMethod(input.executable ?? process.argv[1] ?? "moltnet-agent");
+	const result = {
+		currentVersion: normalizeVersion(input.currentVersion),
+		updateAvailable: false,
+		installMethod,
+		releaseUrl: "https://themolt.net/download",
+		command: daemonUpdateCommand(installMethod)
+	};
+	const now = input.now ?? /* @__PURE__ */ new Date();
+	if (!input.force) {
+		const cached = await readCache();
+		const ttl = cached?.latest ? UPDATE_CACHE_TTL_MS : UPDATE_ERROR_CACHE_TTL_MS;
+		if (cached && now.getTime() - Date.parse(cached.checkedAt) < ttl) {
+			result.latestVersion = cached.latest;
+			result.updateAvailable = compareVersions(cached.latest, result.currentVersion) > 0;
+			return result;
+		}
+	}
+	try {
+		const response = await (input.fetchFn ?? fetch)(UPDATE_MANIFEST_URL, { signal: AbortSignal.timeout(5e3) });
+		if (!response.ok) throw new Error(`manifest returned HTTP ${response.status}`);
+		const latest = manifestVersion(await response.json());
+		if (!latest) throw new Error("manifest has no valid agent version");
+		await writeCache({
+			checkedAt: now.toISOString(),
+			latest
+		}).catch(() => void 0);
+		result.latestVersion = latest;
+		result.updateAvailable = compareVersions(latest, result.currentVersion) > 0;
+		return result;
+	} catch (error) {
+		await writeCache({
+			checkedAt: now.toISOString(),
+			error: error instanceof Error ? error.message : String(error)
+		}).catch(() => void 0);
+		throw new Error(`could not check for MoltNet agent updates: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function manifestVersion(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const agent = value.agent;
+	if (!agent || typeof agent !== "object") return void 0;
+	const version = agent.version;
+	return typeof version === "string" && validVersion(version) ? normalizeVersion(version) : void 0;
+}
+function normalizeVersion(value) {
+	return value.trim().replace(/^v/, "");
+}
+function validVersion(value) {
+	return /^v?\d+\.\d+\.\d+$/.test(value);
+}
+function compareVersions(a, b) {
+	if (!a || !validVersion(a) || !validVersion(b)) return 0;
+	const left = normalizeVersion(a).split(".").map(Number);
+	const right = normalizeVersion(b).split(".").map(Number);
+	for (let i = 0; i < 3; i += 1) {
+		const leftPart = left[i] ?? 0;
+		const rightPart = right[i] ?? 0;
+		if (leftPart > rightPart) return 1;
+		if (leftPart < rightPart) return -1;
+	}
+	return 0;
+}
+function cachePath() {
+	const env = loadUpdateEnvConfig();
+	return join(env.xdgCacheHome || (platform() === "win32" ? env.localAppData || join(homedir(), "AppData", "Local") : join(homedir(), ".cache")), "moltnet", "updates", "agent.json");
+}
+async function readCache() {
+	try {
+		return JSON.parse(await readFile(cachePath(), "utf8"));
+	} catch {
+		return;
+	}
+}
+async function writeCache(cache) {
+	const path = cachePath();
+	await mkdir(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(path, JSON.stringify(cache), { mode: 384 });
+}
+//#endregion
+//#region src/version.ts
+var DAEMON_VERSION = "0.51.0";
+//#endregion
 //#region src/cli.ts
 async function runAgentDaemonCli(options) {
 	const [subcommand, ...rest] = options.argv ?? process.argv.slice(2);
+	if ([
+		"poll",
+		"drain",
+		"serve"
+	].includes(subcommand ?? "") && !isWorkspaceInvocation()) checkDaemonUpdate({ currentVersion: DAEMON_VERSION }).then((update) => {
+		if (update.updateAvailable) pino({ name: "moltnet.agent-daemon" }).info({
+			event: "agent-daemon.update_available",
+			update
+		}, "A MoltNet agent update is available");
+	}).catch(() => void 0);
 	switch (subcommand) {
 		case "poll": return runPoll(rest, options.runtime);
 		case "once": return runOnce(rest, options.runtime);
 		case "drain": return runDrain(rest, options.runtime);
-		case "serve": return runServe(rest);
+		case "server": return runAgentServer(rest);
 		case "sync-sessions": return runSyncSessions(rest);
+		case "update": return runUpdate(rest);
+		case "runtime": return runRuntime(rest);
 		case "-h":
 		case "--help":
 			console.log(ROOT_USAGE);
@@ -9822,5 +10590,49 @@ async function runAgentDaemonCli(options) {
 			return 1;
 	}
 }
+function isWorkspaceInvocation() {
+	return (process.argv[1] ?? "").replaceAll("\\", "/").includes("/apps/agent-daemon/src/");
+}
+async function runUpdate(argv) {
+	if (argv[0] !== "check" || argv.slice(1).some((arg) => arg !== "--json")) {
+		console.error("Usage: moltnet-agent update check [--json]");
+		return 1;
+	}
+	try {
+		const update = await checkDaemonUpdate({
+			currentVersion: DAEMON_VERSION,
+			force: true
+		});
+		if (argv.includes("--json")) console.log(JSON.stringify(update));
+		else if (update.updateAvailable) console.log(`MoltNet agent ${update.latestVersion} is available (you have ${update.currentVersion}). Run: ${update.command}`);
+		else console.log(`MoltNet agent ${update.currentVersion} is up to date.`);
+		return 0;
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
+async function runRuntime(argv) {
+	const config = loadAgentServerEnvConfig();
+	const registry = new RuntimeRegistry(resolveAgentServerRoot({
+		root: config.root,
+		xdgConfigHome: config.xdgConfigHome
+	}));
+	const [command, ...rest] = argv;
+	if (command === "list") {
+		console.log(JSON.stringify(registry.list(), null, 2));
+		return 0;
+	}
+	if (command === "unregister" && rest.length === 1) {
+		if (!registry.unregister(rest[0])) throw new Error(`No runtime registered for "${rest[0]}".`);
+		return 0;
+	}
+	if (command === "register" && rest.length === 2) {
+		console.log(JSON.stringify(await registry.register(rest[0], rest[1]), null, 2));
+		return 0;
+	}
+	console.error("Usage: moltnet-agent runtime <list|register <kind> <module>|unregister <kind>>");
+	return 1;
+}
 //#endregion
-export { runAgentDaemonCli };
+export { loadDaemonRuntimeAdapter as n, runAgentDaemonCli, extractRuntimeModule as t };