@themoltnet/agent-daemon 0.51.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.js

@@ -16,7 +16,7 @@ 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 { metrics } from "@opentelemetry/api";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
@@ -29,6 +29,7 @@ import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic
 import { AsyncLocalStorage } from "node:async_hooks";
 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";
@@ -41,6 +42,8 @@ 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
 /**
@@ -3431,6 +3434,8 @@ 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
@@ -3582,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
@@ -3845,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");
@@ -3892,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",
@@ -3901,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",
@@ -7366,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>
@@ -8148,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;
@@ -8156,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);
@@ -9416,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"],
@@ -9600,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, {
@@ -9662,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
@@ -9894,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) => ({
@@ -10051,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;
 }
@@ -10128,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).
@@ -10144,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);
@@ -10166,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"
@@ -10193,6 +10414,7 @@ async function runAgentServer(argv) {
 					logger,
 					runtimeRegistry: new RuntimeRegistry(store.root)
 				});
+				const tls = isMacos() ? await ensureTrustedLocalTls(root) : void 0;
 				const app = buildAgentServer({
 					store,
 					secrets,
@@ -10202,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,
@@ -10238,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;
@@ -10555,7 +10812,7 @@ async function writeCache(cache) {
 }
 //#endregion
 //#region src/version.ts
-var DAEMON_VERSION = "0.51.0";
+var DAEMON_VERSION = "0.52.0";
 //#endregion
 //#region src/cli.ts
 async function runAgentDaemonCli(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/agent-daemon",
-  "version": "0.51.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,9 +83,10 @@
     "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/agent-runtime": "0.45.2",
     "@themoltnet/pi-runtime": "0.14.1",
+    "@themoltnet/agent-runtime": "0.45.2",
     "@themoltnet/os-keyring": "0.3.0",
     "@themoltnet/sdk": "0.140.0"
   },
@@ -96,16 +98,16 @@
     "vite": "^8.0.0",
     "vite-plugin-dts": "^4.5.4",
     "vitest": "^3.0.0",
-    "@moltnet/agent-eval": "0.1.0",
     "@moltnet/bootstrap": "0.1.0",
+    "@moltnet/agent-eval": "0.1.0",
     "@moltnet/crypto-service": "0.1.0",
-    "@moltnet/execution-plan": "0.1.0",
     "@moltnet/execution-integrations": "0.1.0",
-    "@moltnet/models": "0.1.0",
+    "@moltnet/execution-plan": "0.1.0",
     "@moltnet/loopback-companion": "0.1.0",
-    "@moltnet/tasks": "0.1.0",
     "@moltnet/observability": "0.1.0",
-    "@moltnet/runtime-profiles": "0.1.0"
+    "@moltnet/runtime-profiles": "0.1.0",
+    "@moltnet/models": "0.1.0",
+    "@moltnet/tasks": "0.1.0"
   },
   "nx": {
     "projectType": "application",