@themoltnet/agent-daemon 0.50.0 → 0.52.0

package/README.md

@@ -100,7 +100,7 @@ environment only — never store it in `moltnet.json`. The daemon reconciles a
 team-bound key against `--team` at startup; an identity-scoped key may select
 any team where the agent is authorized. It fails fast if the key is rejected,
 is not an agent, or a team binding mismatches. See
-[Run the daemon with an agent key](../../docs/operate/running-agents.md#run-the-daemon-with-an-agent-key).
+[Run the daemon with an agent key](../../docs/operate/agent-keys.md#run-the-daemon-with-an-agent-key).
 
 Daemon authentication and the guest boundary are two separate concerns. How the
 daemon authenticates (an agent key, or OAuth2 resolved from
@@ -196,7 +196,7 @@ host-exec command is safe to run without a dialog.
 ### Remote runtime profiles
 
 The canonical user-facing guide lives in the public docs:
-[Running Agents § Runtime Profiles](https://docs.themolt.net/operate/running-agents#runtime-profiles).
+[Running Agents § Runtime Profiles](https://docs.themolt.net/operate/runtime-profiles).
 
 ## Correlation anchors
 

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE;IAC/C,OAAO,EAAE,oBAAoB,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBlB"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAGzD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE;IAC/C,OAAO,EAAE,oBAAoB,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB,GAAG,OAAO,CAAC,MAAM,CAAC,CA2ClB"}

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";
@@ -14,9 +16,8 @@ import { FILE_SECRET_PROVIDER, FileSecretProvider, connect, createNodeSecretProv
 import { execFile, execFileSync, spawn } from "node:child_process";
 import { constants, createReadStream, createWriteStream, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 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 { X509Certificate, createHash, createPrivateKey, createPublicKey, randomBytes, randomUUID, timingSafeEqual, webcrypto } 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,23 @@ 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 { createInterface } from "node:readline/promises";
 import cors from "@fastify/cors";
 import helmet from "@fastify/helmet";
 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 { 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 "reflect-metadata";
+import { BasicConstraintsExtension, ExtendedKeyUsage, ExtendedKeyUsageExtension, IP, KeyUsageFlags, KeyUsagesExtension, SubjectAlternativeNameExtension, X509CertificateGenerator } from "@peculiar/x509";
 import { createGzip } from "node:zlib";
 //#region ../../libs/tasks/src/rubric.ts
 /**
@@ -3429,8 +3434,12 @@ Commands:
   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.
+  server trust
+            Install the per-user macOS local-HTTPS CA after explicit consent.
   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.
 
@@ -3578,6 +3587,10 @@ Options:
                               (or MOLTNET_AGENT_SERVER_ROOT).
   --api-url <url>             Default MoltNet API for new managed agents.
                               Default: https://api.themolt.net.
+
+On macOS, the first interactive run asks to trust a per-user local CA in the
+login keychain and serves HTTPS. Run \`agent-daemon server trust --remove\` to
+remove that exact CA. Linux continues to use the Chromium PNA HTTP path.
 `;
 //#endregion
 //#region src/lib/identity-pin.ts
@@ -3798,6 +3811,12 @@ function loadAgentServerEnvConfig() {
 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. */
@@ -3835,7 +3854,7 @@ async function resolveDaemonAgentIdentity(input) {
 }
 //#endregion
 //#region src/lib/correlation.ts
-var execFileAsync = promisify(execFile);
+var execFileAsync$1 = promisify(execFile);
 var CORRELATION_TRAILER_KEY = "Moltnet-Correlation-Id";
 var CORRELATION_MARKER_RE = /<!--\s*moltnet-correlation:\s*([\w-]+)\s*-->/i;
 new RegExp(`^${CORRELATION_TRAILER_KEY}:\\s*(\\S+)\\s*$`, "m");
@@ -3882,7 +3901,7 @@ function makePrBodyAnchorWriter(deps) {
 function createGhCliClient() {
 	return {
 		async get({ owner, repo, number }) {
-			const { stdout } = await execFileAsync("gh", [
+			const { stdout } = await execFileAsync$1("gh", [
 				"api",
 				`repos/${owner}/${repo}/pulls/${number}`,
 				"--jq",
@@ -3891,7 +3910,7 @@ function createGhCliClient() {
 			return JSON.parse(stdout);
 		},
 		async patch({ owner, repo, number }, body) {
-			await execFileAsync("gh", [
+			await execFileAsync$1("gh", [
 				"api",
 				"-X",
 				"PATCH",
@@ -7356,6 +7375,12 @@ function renderPairingApprovalPage(input) {
 </style>
 </head>
 <body>
+<script>
+  // The Console must remain this popup's opener until it finishes navigating
+  // from about:blank. Safari rejects that cross-origin navigation otherwise.
+  // Once this trusted local approval document has loaded, it needs no opener.
+  window.opener = null;
+<\/script>
 <main>
 <h1>Allow this site to manage local MoltNet agents?</h1>
 <p><code>${escapeHtml(input.origin)}</code> asks to configure agents and start or stop local daemon runs on this machine.</p>
@@ -8138,7 +8163,7 @@ 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 AgentServerIdentityError("registration_failed", `registration for "${alias}" was rejected`, { cause });
+			throw new AgentServerIdentityError("registration_failed", registrationRejectionMessage(alias, cause), { 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;
@@ -8146,6 +8171,9 @@ async function createManagedAgent(store, secrets, input, connectAgent = connect)
 		releaseAlias();
 	}
 }
+function registrationRejectionMessage(alias, cause) {
+	return `registration for "${alias}" was rejected${cause.statusCode === void 0 ? "" : ` (${cause.statusCode})`}: ${cause.detail?.trim() || cause.message}`;
+}
 /** Resume a fully persisted registration or explicitly abandon local recovery. */
 async function reconcileManagedRegistration(store, secrets, aliasInput, action, connectAgent = connect, signal) {
 	const alias = assertStoreName("agent name", aliasInput);
@@ -8475,7 +8503,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 = {
@@ -8499,6 +8527,7 @@ var RunManager = class {
 			};
 		})();
 		const args = [
+			...runtimeModule ? ["--runtime", runtimeModule] : [],
 			spec.mode,
 			"--agent",
 			target.agentName,
@@ -8569,7 +8598,8 @@ var RunManager = class {
 		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;
@@ -8700,6 +8730,46 @@ 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 AgentServerRunError("run_not_found", `run "${id}" was not found`);
@@ -8882,6 +8952,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)));
 }
@@ -8897,6 +8975,168 @@ async function terminateChild(child) {
 		child.kill("SIGKILL");
 	});
 }
+//#endregion
+//#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;
+	}
+	return {
+		argv: remaining,
+		specifier
+	};
+}
+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 {
+		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");
+}
+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) {
@@ -9194,6 +9434,16 @@ var AgentServerRouteSchemas = {
 			...problemResponse
 		}
 	},
+	deleteProvider: {
+		operationId: "deleteAgentServerProvider",
+		tags: ["providers"],
+		security: pairedSecurity,
+		params: ProviderParamsSchema,
+		response: {
+			204: Type.Any(),
+			...problemResponse
+		}
+	},
 	listSubscriptions: {
 		operationId: "listAgentServerSubscriptions",
 		tags: ["subscriptions"],
@@ -9378,10 +9628,14 @@ function requestOperationSignal(request, shutdownSignal) {
 }
 function buildAgentServer(options) {
 	const { pairing } = options;
-	const app = options.logger ? Fastify({
+	const fastifyOptions = {
 		bodyLimit: BODY_LIMIT,
+		...options.tls ? { https: options.tls } : {}
+	};
+	const app = options.logger ? Fastify({
+		...fastifyOptions,
 		loggerInstance: options.logger
-	}) : Fastify({ bodyLimit: BODY_LIMIT });
+	}) : Fastify(fastifyOptions);
 	options.registerOpenApi?.(app);
 	for (const schema of AGENT_SERVER_SCHEMAS) app.addSchema(schema);
 	registerLoopbackSecurity(app, {
@@ -9440,12 +9694,12 @@ function buildAgentServer(options) {
 	}));
 	app.setErrorHandler(async (error, request, reply) => {
 		const { statusCode, code, message } = normalizeAgentServerError(error);
-		if (statusCode === 500) request.log.error({
+		if (statusCode === 500 || error instanceof AgentServerIdentityError) request.log[statusCode === 500 ? "error" : "warn"]({
 			...safeErrorContext(error),
-			code: "agent_server_request_failed",
+			code: statusCode === 500 ? "agent_server_request_failed" : "agent_server_identity_rejected",
 			method: request.method,
 			route: request.routeOptions.url
-		}, "AgentServer request failed");
+		}, statusCode === 500 ? "AgentServer request failed" : "AgentServer identity request rejected");
 		return reply.code(statusCode).send({
 			code,
 			message
@@ -9672,12 +9926,29 @@ function registerProviderRoutes(app, options, requirePairedOrigin) {
 					provider: FILE_SECRET_PROVIDER,
 					key
 				});
-			} else if (providers[providerId]?.apiKeyRef && providers[providerId].baseUrl === entry.baseUrl) entry.apiKeyRef = providers[providerId].apiKeyRef;
+			} else if (providers[providerId]?.apiKeyRef) entry.apiKeyRef = providers[providerId].apiKeyRef;
 			providers[providerId] = entry;
 			store.writeProviders(providers);
 		});
 		return reply.code(200).send(providerView(entry));
 	});
+	app.delete("/v1/providers/:providerId", {
+		schema: AgentServerRouteSchemas.deleteProvider,
+		attachValidation: true
+	}, async (request, reply) => {
+		requirePairedOrigin(request);
+		const { providerId: rawProviderId } = request.params;
+		const providerId = assertProviderId(rawProviderId);
+		await serialize(async () => {
+			const providers = store.readProviders();
+			const provider = providers[providerId];
+			if (!provider) throw new AgentServerHttpError(404, "agent_server_provider_not_found", `Provider ${providerId} was not found`);
+			if (provider.apiKeyRef) await options.secrets.delete(`pi-provider/${providerId}`);
+			delete providers[providerId];
+			store.writeProviders(providers);
+		});
+		return reply.code(204).send(null);
+	});
 }
 function runViews(runs) {
 	return runs.list(RUN_HISTORY_LIMIT).map((record) => ({
@@ -9829,12 +10100,23 @@ function safeErrorContext(error) {
 	const applicationCode = safeErrorToken(error?.code);
 	if (applicationCode) context["applicationCode"] = applicationCode;
 	const cause = error instanceof Error ? error.cause : void 0;
+	if (cause instanceof Error) {
+		context["causeType"] = cause.name;
+		const causeMessage = safeLogMessage(cause.message);
+		if (causeMessage) context["causeMessage"] = causeMessage;
+	}
 	const fsCode = safeErrorToken(cause?.code);
 	const syscall = safeErrorToken(cause?.syscall);
 	if (fsCode) context["fsCode"] = fsCode;
 	if (syscall) context["syscall"] = syscall;
+	const causeStatus = cause?.statusCode;
+	if (typeof causeStatus === "number") context["causeStatusCode"] = causeStatus;
 	return context;
 }
+function safeLogMessage(value) {
+	const normalized = value.replace(/[\r\n\t]/gu, " ").trim();
+	return normalized ? normalized.slice(0, 500) : void 0;
+}
 function safeErrorToken(value) {
 	return typeof value === "string" && /^[a-z0-9_:-]{1,64}$/iu.test(value) ? value : void 0;
 }
@@ -9906,6 +10188,163 @@ function normalizeAgentServerError(error) {
 	};
 }
 //#endregion
+//#region src/lib/agent-server/tls.ts
+var execFileAsync = promisify(execFile);
+var CA_COMMON_NAME = "MoltNet Local Agent CA";
+var LEAF_COMMON_NAME = "MoltNet Local Agent";
+var RENEW_BEFORE_MS = 720 * 60 * 60 * 1e3;
+function loginKeychainPath() {
+	return join(homedir(), "Library", "Keychains", "login.keychain-db");
+}
+function pemPrivateKey(key) {
+	return webcrypto.subtle.exportKey("pkcs8", key).then((der) => createPrivateKey({
+		key: Buffer.from(der),
+		format: "der",
+		type: "pkcs8"
+	}).export({
+		format: "pem",
+		type: "pkcs8"
+	}).toString());
+}
+async function importCaKeyPair(pem) {
+	const privateKey = createPrivateKey(pem);
+	const privateDer = privateKey.export({
+		format: "der",
+		type: "pkcs8"
+	});
+	const publicDer = createPublicKey(privateKey).export({
+		format: "der",
+		type: "spki"
+	});
+	const [privateCryptoKey, publicCryptoKey] = await Promise.all([webcrypto.subtle.importKey("pkcs8", privateDer, {
+		name: "ECDSA",
+		namedCurve: "P-256"
+	}, false, ["sign"]), webcrypto.subtle.importKey("spki", publicDer, {
+		name: "ECDSA",
+		namedCurve: "P-256"
+	}, false, ["verify"])]);
+	return {
+		privateKey: privateCryptoKey,
+		publicKey: publicCryptoKey
+	};
+}
+async function localTlsMaterialFromDirectory(dir) {
+	try {
+		const [key, cert, ca] = await Promise.all([
+			readFile(join(dir, "loopback-key.pem"), "utf8"),
+			readFile(join(dir, "loopback-cert.pem"), "utf8"),
+			readFile(join(dir, "local-ca.pem"), "utf8")
+		]);
+		const parsed = new X509Certificate(cert);
+		if (Date.parse(parsed.validTo) - Date.now() > RENEW_BEFORE_MS) return {
+			key,
+			cert,
+			ca,
+			fingerprint: new X509Certificate(ca).fingerprint256
+		};
+	} catch {}
+	return null;
+}
+/** Creates a per-user CA and loopback-only leaf certificate under a 0700 directory. */
+async function ensureLocalTlsMaterial(root) {
+	const dir = join(root, "tls");
+	await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const existing = await localTlsMaterialFromDirectory(dir);
+	if (existing) return existing;
+	let ca;
+	let caKeys;
+	let caKey;
+	try {
+		ca = await readFile(join(dir, "local-ca.pem"), "utf8");
+		caKeys = await importCaKeyPair(await readFile(join(dir, "local-ca-key.pem"), "utf8"));
+	} catch {
+		caKeys = await webcrypto.subtle.generateKey({
+			name: "ECDSA",
+			namedCurve: "P-256"
+		}, true, ["sign", "verify"]);
+		ca = (await X509CertificateGenerator.createSelfSigned({
+			name: `CN=${CA_COMMON_NAME}`,
+			keys: caKeys,
+			notAfter: new Date(Date.now() + 10 * 365 * 24 * 60 * 60 * 1e3),
+			extensions: [new BasicConstraintsExtension(true, void 0, true), new KeyUsagesExtension(KeyUsageFlags.keyCertSign | KeyUsageFlags.cRLSign, true)]
+		})).toString("pem");
+		caKey = await pemPrivateKey(caKeys.privateKey);
+	}
+	const leafKeys = await webcrypto.subtle.generateKey({
+		name: "ECDSA",
+		namedCurve: "P-256"
+	}, true, ["sign", "verify"]);
+	const leafCert = await X509CertificateGenerator.create({
+		subject: `CN=${LEAF_COMMON_NAME}`,
+		issuer: `CN=${CA_COMMON_NAME}`,
+		publicKey: leafKeys.publicKey,
+		signingKey: caKeys.privateKey,
+		notAfter: new Date(Date.now() + 365 * 24 * 60 * 60 * 1e3),
+		extensions: [
+			new BasicConstraintsExtension(false, void 0, true),
+			new KeyUsagesExtension(KeyUsageFlags.digitalSignature, true),
+			new ExtendedKeyUsageExtension([ExtendedKeyUsage.serverAuth]),
+			new SubjectAlternativeNameExtension([{
+				type: IP,
+				value: "127.0.0.1"
+			}], true)
+		]
+	});
+	const key = await pemPrivateKey(leafKeys.privateKey);
+	const cert = leafCert.toString("pem");
+	const writes = [writeFile(join(dir, "loopback-key.pem"), key, { mode: 384 }), writeFile(join(dir, "loopback-cert.pem"), cert, { mode: 384 })];
+	if (caKey) writes.push(writeFile(join(dir, "local-ca.pem"), ca, { mode: 384 }), writeFile(join(dir, "local-ca-key.pem"), caKey, { mode: 384 }));
+	await Promise.all(writes);
+	return {
+		key,
+		cert,
+		ca,
+		fingerprint: new X509Certificate(ca).fingerprint256
+	};
+}
+async function trustLocalCa(root) {
+	const caPath = join(root, "tls", "local-ca.pem");
+	await execFileAsync("security", [
+		"add-trusted-cert",
+		"-d",
+		"-r",
+		"trustRoot",
+		"-k",
+		loginKeychainPath(),
+		caPath
+	]);
+}
+async function isLocalCaTrusted(root) {
+	const ca = await readFile(join(root, "tls", "local-ca.pem"), "utf8");
+	try {
+		const { stdout } = await execFileAsync("security", [
+			"find-certificate",
+			"-a",
+			"-p",
+			"-c",
+			CA_COMMON_NAME,
+			loginKeychainPath()
+		]);
+		return stdout.includes(ca.trim());
+	} catch {
+		return false;
+	}
+}
+async function removeLocalCa(root) {
+	await execFileAsync("security", [
+		"delete-certificate",
+		"-Z",
+		new X509Certificate(await readFile(join(root, "tls", "local-ca.pem"), "utf8")).fingerprint256.replaceAll(":", ""),
+		loginKeychainPath()
+	]);
+}
+function isMacos() {
+	return process.platform === "darwin";
+}
+//#endregion
 //#region src/cli/server.ts
 /**
 * `moltnet-agent server` — per-user loopback supervisor (#2061).
@@ -9922,14 +10361,17 @@ async function runAgentServer(argv) {
 		console.log(AGENT_SERVER_HELP);
 		return 0;
 	}
+	const trustRequested = argv[0] === "trust";
+	const commandArgs = trustRequested ? argv.slice(1) : argv;
 	const envConfig = loadAgentServerEnvConfig();
 	const { values } = parseArgs({
-		args: argv,
+		args: commandArgs,
 		options: {
 			port: { type: "string" },
 			"allowed-origins": { type: "string" },
 			root: { type: "string" },
-			"api-url": { type: "string" }
+			"api-url": { type: "string" },
+			remove: { type: "boolean" }
 		}
 	});
 	const port = Number.parseInt(values.port ?? (envConfig.port || `${DEFAULT_PORT}`), 10);
@@ -9944,6 +10386,7 @@ async function runAgentServer(argv) {
 	});
 	const defaultApiUrl = values["api-url"] ?? (envConfig.apiUrl || DEFAULT_API_URL);
 	const store = new AgentServerStore(root).ensure();
+	if (trustRequested) return runTrustCommand(commandArgs, root);
 	const { logger, shutdown: shutdownLogger } = createRootLogger({
 		name: "agent-daemon.server",
 		level: envConfig.logLevel || "info"
@@ -9968,8 +10411,10 @@ async function runAgentServer(argv) {
 					secretProviders,
 					externalSecretProviders,
 					baseEnv: processEnvSnapshot(),
-					logger
+					logger,
+					runtimeRegistry: new RuntimeRegistry(store.root)
 				});
+				const tls = isMacos() ? await ensureTrustedLocalTls(root) : void 0;
 				const app = buildAgentServer({
 					store,
 					secrets,
@@ -9979,7 +10424,11 @@ async function runAgentServer(argv) {
 					runs,
 					subscriptions,
 					allowedOrigins,
-					selfOrigin: `http://127.0.0.1:${port}`,
+					selfOrigin: `${tls ? "https" : "http"}://127.0.0.1:${port}`,
+					...tls ? { tls: {
+						key: tls.key,
+						cert: tls.cert
+					} } : {},
 					defaultApiUrl,
 					version: "dev",
 					logger,
@@ -10015,6 +10464,37 @@ async function runAgentServer(argv) {
 		await shutdownLogger();
 	}
 }
+async function runTrustCommand(argv, root) {
+	if (!isMacos()) {
+		console.error("Local HTTPS trust setup is currently supported on macOS only.");
+		return 1;
+	}
+	if (argv.includes("--remove")) {
+		await removeLocalCa(root);
+		console.error("Removed the MoltNet local CA from your login keychain.");
+		return 0;
+	}
+	await ensureTrustedLocalTls(root);
+	console.error("MoltNet local HTTPS trust is ready for this macOS user.");
+	return 0;
+}
+async function ensureTrustedLocalTls(root) {
+	const material = await ensureLocalTlsMaterial(root);
+	if (await isLocalCaTrusted(root)) return material;
+	if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("Local HTTPS trust is not configured. Run `moltnet-agent server trust` from an interactive terminal.");
+	const prompt = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const answer = await prompt.question(`Trust MoltNet's local CA (${material.fingerprint}) in this macOS login keychain? [y/N] `);
+		if (!/^y(es)?$/i.test(answer.trim())) throw new Error("Local HTTPS trust was not approved.");
+	} finally {
+		prompt.close();
+	}
+	await trustLocalCa(root);
+	return material;
+}
 function waitForAgentServerShutdown(runs, app, shutdownController) {
 	return new Promise((resolvePromise) => {
 		let shuttingDown = false;
@@ -10233,15 +10713,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.52.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 "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);
@@ -10254,5 +10847,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 };

package/dist/main.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { defaultPiDaemonAdapter } from "./pi.js";
-import { runAgentDaemonCli } from "./cli.js";
-import { createRequire } from "node:module";
+import { n as loadDaemonRuntimeAdapter, runAgentDaemonCli, t as extractRuntimeModule } from "./cli.js";
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
 import { DnsInstrumentation } from "@opentelemetry/instrumentation-dns";
 import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
@@ -9,8 +8,6 @@ import { NetInstrumentation } from "@opentelemetry/instrumentation-net";
 import { PgInstrumentation } from "@opentelemetry/instrumentation-pg";
 import { PinoInstrumentation } from "@opentelemetry/instrumentation-pino";
 import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
-import { isAbsolute, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
 //#region ../../libs/observability/src/instrumentation.ts
 /**
 * Register OTel auto-instrumentation for common Node.js modules.
@@ -101,70 +98,6 @@ function installSupervisorParentGuard(proc = process) {
 	return true;
 }
 //#endregion
-//#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;
-	}
-	return {
-		argv: remaining,
-		specifier
-	};
-}
-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 {
-		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/main.ts
 installSupervisorParentGuard();
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/agent-daemon",
-  "version": "0.50.0",
+  "version": "0.52.0",
   "license": "AGPL-3.0-only",
   "type": "module",
   "description": "Universal MoltNet agent daemon host with a built-in Pi/Gondolin runtime and support for trusted operator-owned runtime modules. CLI: moltnet-agent.",
@@ -75,6 +75,7 @@
     "@opentelemetry/sdk-trace-base": "^2.5.1",
     "@opentelemetry/sdk-trace-node": "^2.5.1",
     "@opentelemetry/semantic-conventions": "^1.39.0",
+    "@peculiar/x509": "^2.0.0",
     "fastify": "^5.8.5",
     "fastify-plugin": "^5.1.0",
     "multiformats": "^13.3.0",
@@ -82,11 +83,12 @@
     "pino-opentelemetry-transport": "^3.0.0",
     "pino-pretty": "^13.1.3",
     "proper-lockfile": "4.1.2",
+    "reflect-metadata": "^0.2.2",
     "typebox": "^1.2.8",
+    "@themoltnet/pi-runtime": "0.14.1",
     "@themoltnet/agent-runtime": "0.45.2",
     "@themoltnet/os-keyring": "0.3.0",
-    "@themoltnet/sdk": "0.140.0",
-    "@themoltnet/pi-runtime": "0.14.1"
+    "@themoltnet/sdk": "0.140.0"
   },
   "devDependencies": {
     "@fastify/swagger": "^9.6.1",
@@ -96,15 +98,15 @@
     "vite": "^8.0.0",
     "vite-plugin-dts": "^4.5.4",
     "vitest": "^3.0.0",
+    "@moltnet/bootstrap": "0.1.0",
     "@moltnet/agent-eval": "0.1.0",
     "@moltnet/crypto-service": "0.1.0",
-    "@moltnet/bootstrap": "0.1.0",
     "@moltnet/execution-integrations": "0.1.0",
-    "@moltnet/loopback-companion": "0.1.0",
     "@moltnet/execution-plan": "0.1.0",
+    "@moltnet/loopback-companion": "0.1.0",
     "@moltnet/observability": "0.1.0",
-    "@moltnet/models": "0.1.0",
     "@moltnet/runtime-profiles": "0.1.0",
+    "@moltnet/models": "0.1.0",
     "@moltnet/tasks": "0.1.0"
   },
   "nx": {