@themoltnet/agent-daemon 0.57.1 → 0.58.0

package/README.md

@@ -8,6 +8,27 @@ and finalization in both cases.
 
 ## Install
 
+### MoltNet Agent for Mac
+
+On an Apple Silicon Mac running macOS 13 or newer, download the desktop app
+from [themolt.net/download](https://themolt.net/download). Opening the app:
+
+1. installs or updates the publisher-verified Agent CLI bundle under
+   `~/.local/share/moltnet/agent`;
+2. asks before adding the per-user local HTTPS CA to the login Keychain;
+3. starts a foreground, supervised Agent Server; and
+4. opens Console for process-scoped pairing and runtime management.
+
+Closing the status window hides it. **Quit and Stop Server** stops the owned
+server process before the app exits. Starting the app again requires Console
+pairing again; identities and provider configuration persist.
+
+Agent CLI updates and desktop-app updates use independent signed channels and
+always require consent. Removing the Agent CLI bundle preserves
+`~/.config/moltnet`. Removing the local CA is a separate opt-in action.
+
+### Agent CLI
+
 Install the signed bundle, then use `moltnet-agent` for normal operation:
 
 ```bash

package/dist/cli.js

@@ -27,7 +27,7 @@ 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 { homedir, platform, tmpdir } from "node:os";
-import { writePiConfig } from "@themoltnet/pi-runtime/pi-config";
+import { PI_MODEL_MODALITIES, writePiConfig } from "@themoltnet/pi-runtime/pi-config";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { mkdir, open, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
@@ -3653,10 +3653,15 @@ Options:
                               Default: https://api.themolt.net.
   --heartbeat-interval-ms <n> Child reporter heartbeat cadence. Default: 60000.
   --warm-retention-sec <n>    Child session/workspace retention. Default: 1800.
+  --supervised                Also stop gracefully when stdin reaches EOF.
 
 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.
+login keychain and serves HTTPS. Native supervisors use:
+  server trust --status --json
+  server trust --yes --json
+  server trust --remove --yes --json
+Run \`agent-daemon server trust --remove\` interactively to remove that exact
+CA. Linux continues to use the Chromium PNA HTTP path.
 `;
 var PROVIDERS_HELP = `\
 moltnet-agent providers — manage local model providers.
@@ -3665,6 +3670,7 @@ Usage:
   moltnet-agent providers list [--json] [--root <path>]
   moltnet-agent providers set <id> [--base-url <url>] [--api <pi-api-kind>]
     [--model <id> ... | --clear-models]
+    [--model-input <id>=text,image ...]
     [--api-key-stdin | --clear-api-key] [--root <path>]
   moltnet-agent providers discover <id> [--save] [--json] [--root <path>]
   moltnet-agent providers remove <id> [--yes] [--root <path>]
@@ -3675,6 +3681,11 @@ Usage:
 The default root is ~/.config/moltnet. MOLTNET_AGENT_SERVER_ROOT remains the
 environment override. API keys are accepted only from redirected stdin; they
 are stored separately and providers.json contains only a secret reference.
+
+--model declares a text-only model. --model-input declares a model together
+with the input modalities it accepts, and is what makes a vision model usable:
+a model with no declared modalities is text-only to Pi, which drops image
+content parts before the request leaves the runtime.
 `;
 //#endregion
 //#region src/lib/identity-pin.ts
@@ -5424,6 +5435,17 @@ function resolveAgentServerRoot(input) {
 	if (override) return override;
 	return getConfigDir();
 }
+/**
+* Copy a model entry, dropping an empty `input` so it never reaches the wire.
+* Not a compatibility shim: `providers.json` has exactly one model shape, and
+* `validateProviders` rejects anything else on read.
+*/
+function copyProviderModel(entry) {
+	return {
+		id: entry.id,
+		...entry.input && entry.input.length > 0 ? { input: [...entry.input] } : {}
+	};
+}
 function providerEnvName(providerId) {
 	return `MOLTNET_PROVIDER_${assertProviderId(providerId).replaceAll("-", "_").toUpperCase()}_API_KEY`;
 }
@@ -5622,6 +5644,7 @@ var AgentServerStore = class {
 		for (const [id, provider] of Object.entries(state)) {
 			assertProviderId(id);
 			assertProviderEnvName(id, provider.envName);
+			for (const model of provider.models ?? []) if (typeof model !== "object" || model === null || !model.id) throw new AgentServerStoreError("invalid_state", `provider "${id}" has a model entry that is not { id, input? }; rewrite providers.json entries as objects`);
 		}
 	}
 	runDir(id) {
@@ -7791,14 +7814,41 @@ var AgentServerModelDiscoveryError = class extends Error {
 		this.statusCode = statusCode;
 	}
 };
+/**
+* The Ollama capability that means a model accepts image input. Ollama also
+* reports `completion`, `tools`, `thinking` and `embedding`; none of those map
+* onto a Pi input modality, so only this one is read.
+*/
+var OLLAMA_VISION_CAPABILITY = "vision";
+/**
+* Read Ollama's `capabilities` array, when the endpoint supplies one.
+*
+* Returns `undefined` when the field is absent — which is meaningfully
+* different from "present and without vision". A local Ollama returns
+* capabilities from `/api/tags`; Ollama Cloud does not, and needs a per-model
+* `/api/show` probe. Only an explicit absence should trigger that probe.
+*/
+function readOllamaModalities(value) {
+	if (!isRecord(value) || !Array.isArray(value["capabilities"])) return void 0;
+	return value["capabilities"].includes(OLLAMA_VISION_CAPABILITY) ? ["text", "image"] : [];
+}
 var ModelDiscoveryCollector = class {
-	models = /* @__PURE__ */ new Set();
+	/**
+	* Model id → declared input modalities. `undefined` means the id is known but
+	* its capabilities are not, so it is still a probe candidate; `[]` means the
+	* source answered and the model is text-only.
+	*/
+	models = /* @__PURE__ */ new Map();
+	record(id, input) {
+		if (input === void 0 && this.models.has(id)) return;
+		this.models.set(id, input);
+	}
 	addOpenAiResponse(value) {
 		if (!isRecord(value) || !Array.isArray(value["data"])) return;
 		for (const candidate of value["data"]) {
 			if (!isRecord(candidate)) continue;
 			const id = candidate["id"];
-			if (typeof id === "string" && id.length > 0) this.models.add(id);
+			if (typeof id === "string" && id.length > 0) this.record(id, void 0);
 		}
 	}
 	addOllamaResponse(value) {
@@ -7806,16 +7856,28 @@ var ModelDiscoveryCollector = class {
 		for (const candidate of value["models"]) {
 			if (!isRecord(candidate)) continue;
 			const name = candidate["name"];
-			if (typeof name === "string" && name.length > 0) this.models.add(name);
+			if (typeof name === "string" && name.length > 0) this.record(name, readOllamaModalities(candidate));
 		}
 	}
+	/** Attach modalities learned after collection, e.g. from an `/api/show` probe. */
+	setModalities(id, input) {
+		if (this.models.has(id)) this.models.set(id, input);
+	}
 	get size() {
 		return this.models.size;
 	}
 	result(providerId, failures) {
 		if (this.models.size === 0) throw discoveryFailure(providerId, failures);
+		const ids = [...this.models.keys()].sort().slice(0, 500);
 		return {
-			models: [...this.models].sort().slice(0, 500),
+			models: ids.map((id) => {
+				const input = this.models.get(id);
+				return input && input.length > 0 ? {
+					id,
+					input: [...input]
+				} : { id };
+			}),
+			unresolved: ids.filter((id) => this.models.get(id) === void 0),
 			discoveredCount: this.models.size
 		};
 	}
@@ -7876,6 +7938,12 @@ function safeErrorToken(value) {
 //#endregion
 //#region src/lib/provider-configuration.ts
 var DEFAULT_PROVIDER_API = "openai-completions";
+/**
+* Concurrent `/api/show` probes. Small on purpose: this runs against a
+* third-party endpoint on an operator's behalf, and discovery is interactive,
+* so the cap favours being a polite client over shaving a second.
+*/
+var MODALITY_PROBE_CONCURRENCY = 5;
 var ProviderConfigurationError = class extends Error {
 	name = "ProviderConfigurationError";
 	constructor(code, message, statusCode, options) {
@@ -7913,7 +7981,7 @@ var ProviderConfigurationService = class {
 				api: input.api ?? previous?.api ?? DEFAULT_PROVIDER_API,
 				baseUrl,
 				envName: assertProviderEnvName(providerId, input.envName ?? previous?.envName ?? providerEnvName(providerId)),
-				models: [...input.models ?? previous?.models ?? []],
+				models: (input.models ?? previous?.models ?? []).map(copyProviderModel),
 				...!input.clearApiKey && previous?.apiKeyRef ? { apiKeyRef: previous.apiKeyRef } : {}
 			};
 			const key = `pi-provider/${providerId}`;
@@ -8014,13 +8082,65 @@ var ProviderConfigurationService = class {
 			providerId,
 			returnedCount: 500
 		}, "Provider model discovery result was truncated");
-		if (options.save) await this.set(providerId, { models: result.models }, options);
+		if (isOllamaProvider(providerId, parsed) && result.unresolved.length > 0) await this.resolveOllamaModalities({
+			collector,
+			headers,
+			ids: result.unresolved,
+			origin: parsed.origin,
+			providerId,
+			signal: options.signal
+		});
+		const resolved = collector.result(providerId, failures);
+		const declared = new Map(provider.models.map((model) => [model.id, model.input]));
+		const models = resolved.models.map((model) => {
+			const override = declared.get(model.id);
+			return override && override.length > 0 ? {
+				id: model.id,
+				input: [...override]
+			} : model;
+		});
+		const detected = models.filter((model) => model.input?.includes("image") && !declared.get(model.id)?.includes("image"));
+		if (detected.length > 0) this.logger.info({
+			code: "agent_server_provider_discovery_modalities_detected",
+			models: detected.map((model) => model.id),
+			providerId
+		}, "Provider models reported image input support");
+		if (options.save) await this.set(providerId, { models }, options);
 		this.logger.info({
 			code: "agent_server_provider_discovery_completed",
-			modelCount: result.models.length,
+			modelCount: models.length,
 			providerId
 		}, "Provider model discovery completed");
-		return { models: result.models };
+		return { models };
+	}
+	/**
+	* Fill in modalities Ollama Cloud's `/api/tags` omits, one `/api/show` per
+	* still-unknown model.
+	*
+	* Failures here are deliberately not pushed into the discovery `failures`
+	* array: that array decides the error code of a *failed* discovery, so a
+	* probe rejection must not relabel an otherwise-successful one. A model whose
+	* probe fails simply stays text-only.
+	*/
+	async resolveOllamaModalities(input) {
+		const url = `${input.origin}/api/show`;
+		for (let index = 0; index < input.ids.length; index += MODALITY_PROBE_CONCURRENCY) {
+			if (input.signal?.aborted) throw new ProviderConfigurationError("operation_aborted", `provider "${input.providerId}" discovery was cancelled`, 408, { cause: input.signal.reason });
+			const batch = input.ids.slice(index, index + MODALITY_PROBE_CONCURRENCY);
+			await Promise.all(batch.map(async (id) => {
+				const modalities = readOllamaModalities(await this.requestDiscoveryEndpoint({
+					body: { model: id },
+					endpoint: "ollama_show",
+					failures: [],
+					headers: input.headers,
+					method: "POST",
+					providerId: input.providerId,
+					signal: input.signal,
+					url
+				}));
+				if (modalities) input.collector.setModalities(id, modalities);
+			}));
+		}
 	}
 	async resolveApiKey(providerId, provider) {
 		if (!provider.apiKeyRef) return void 0;
@@ -8041,7 +8161,14 @@ var ProviderConfigurationService = class {
 		let response;
 		try {
 			response = await this.fetchImpl(input.url, {
-				headers: input.headers,
+				...input.body ? {
+					body: JSON.stringify(input.body),
+					method: input.method
+				} : {},
+				headers: input.body ? {
+					...input.headers,
+					"content-type": "application/json"
+				} : input.headers,
 				redirect: "error",
 				signal: input.signal ? AbortSignal.any([input.signal, timeout]) : timeout
 			});
@@ -8108,7 +8235,7 @@ function providerView(provider) {
 		api: provider.api,
 		baseUrl: provider.baseUrl,
 		envName: provider.envName,
-		models: [...provider.models],
+		models: provider.models.map(copyProviderModel),
 		hasApiKey: Boolean(provider.apiKeyRef)
 	};
 }
@@ -8130,6 +8257,31 @@ function providerAbortSource(reason) {
 }
 //#endregion
 //#region src/cli/providers.ts
+var MODEL_MODALITIES$1 = PI_MODEL_MODALITIES;
+/**
+* Build the model list from `--model <id>` (text-only) and
+* `--model-input <id>=text,image` (declares modalities). Model ids contain
+* colons, so `=` separates the id from its modality list. A `--model-input`
+* entry also declares the model, and overrides a bare `--model` for that id.
+*/
+function parseModelArgs(models, modelInputs) {
+	if (!models && !modelInputs) return void 0;
+	const entries = /* @__PURE__ */ new Map();
+	for (const id of models ?? []) entries.set(id, { id });
+	for (const raw of modelInputs ?? []) {
+		const separator = raw.indexOf("=");
+		if (separator <= 0) throw new ProviderCliError("invalid_arguments", `--model-input expects <model-id>=<modality>[,<modality>], received "${raw}"`);
+		const id = raw.slice(0, separator);
+		const input = raw.slice(separator + 1).split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+		if (input.length === 0) throw new ProviderCliError("invalid_arguments", `--model-input for "${id}" declared no modality`);
+		for (const modality of input) if (!MODEL_MODALITIES$1.includes(modality)) throw new ProviderCliError("invalid_arguments", `--model-input for "${id}" has unknown modality "${modality}"; expected ${MODEL_MODALITIES$1.join(" or ")}`);
+		entries.set(id, {
+			id,
+			input
+		});
+	}
+	return [...entries.values()];
+}
 async function runProviders(argv, dependencies = {}) {
 	if (isHelpFlag(argv) || argv.length === 0) {
 		(dependencies.stdout ?? console.log)(PROVIDERS_HELP);
@@ -8203,6 +8355,10 @@ function parseProviderArgs(command, args) {
 						type: "string",
 						multiple: true
 					},
+					"model-input": {
+						type: "string",
+						multiple: true
+					},
 					"clear-models": { type: "boolean" },
 					"api-key-stdin": { type: "boolean" },
 					"clear-api-key": { type: "boolean" }
@@ -8212,6 +8368,7 @@ function parseProviderArgs(command, args) {
 			});
 			requirePositionals(positionals, 1, "providers set <id>");
 			if (values.model && values["clear-models"]) throw new ProviderCliError("invalid_arguments", "--model and --clear-models cannot be used together");
+			if (values["model-input"] && values["clear-models"]) throw new ProviderCliError("invalid_arguments", "--model-input and --clear-models cannot be used together");
 			if (values["api-key-stdin"] && values["clear-api-key"]) throw new ProviderCliError("invalid_arguments", "--api-key-stdin and --clear-api-key cannot be used together");
 			return {
 				command,
@@ -8219,7 +8376,7 @@ function parseProviderArgs(command, args) {
 				providerId: positionals[0],
 				baseUrl: values["base-url"],
 				api: values.api,
-				models: values["clear-models"] ? [] : values.model,
+				models: values["clear-models"] ? [] : parseModelArgs(values.model, values["model-input"]),
 				apiKeyStdin: values["api-key-stdin"] ?? false,
 				clearApiKey: values["clear-api-key"] ?? false
 			};
@@ -8374,7 +8531,7 @@ async function discoverProvider(context, parsed) {
 		signal: context.signal
 	});
 	if (parsed.json) context.stdout(JSON.stringify(result));
-	else for (const model of result.models) context.stdout(model);
+	else for (const model of result.models) context.stdout(model.input && model.input.length > 0 ? `${model.id}\t${model.input.join(",")}` : model.id);
 	return 0;
 }
 async function removeProvider(context, parsed) {
@@ -10371,6 +10528,13 @@ function writeRegistry(path, entries) {
 //#region src/lib/agent-server/protocol.ts
 var DateTime = Type.String({ format: "date-time" });
 var StringList = Type.Array(Type.String());
+/** A model the provider offers, with the input modalities it accepts. */
+var ProviderModelSchema = Type.Object({
+	id: Type.String(),
+	input: Type.Optional(Type.Array(Type.Union(PI_MODEL_MODALITIES.map((modality) => Type.Literal(modality))), { minItems: 1 }))
+});
+/** One shape on the wire, for both requests and responses. */
+var ProviderModelList = Type.Array(ProviderModelSchema);
 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");
@@ -10403,7 +10567,7 @@ var AgentServerProviderSchema = Type.Object({
 	api: Type.String(),
 	baseUrl: Type.String({ format: "uri" }),
 	envName: Type.String(),
-	models: StringList,
+	models: ProviderModelList,
 	hasApiKey: Type.Boolean()
 }, { $id: "AgentServerProvider" });
 var AgentServerRunRecordSchema = Type.Object({
@@ -10480,10 +10644,10 @@ var PutProviderSchema = Type.Object({
 	api: Type.String(),
 	baseUrl: Type.String({ format: "uri" }),
 	envName: Type.String(),
-	models: StringList,
+	models: ProviderModelList,
 	apiKey: Type.Optional(Type.String())
 });
-var DiscoverModelsSchema = Type.Object({ models: StringList }, { $id: "DiscoveredModels" });
+var DiscoverModelsSchema = Type.Object({ models: ProviderModelList }, { $id: "DiscoveredModels" });
 var StartRunSchema = Type.Object({
 	agent: Type.String(),
 	teamId: Type.String(),
@@ -10798,6 +10962,27 @@ function stringArray(body, field, options = {}) {
 	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;
 }
+var MODEL_MODALITIES = new Set(PI_MODEL_MODALITIES);
+/** Parse the provider `models` field: `{ id, input? }` entries only. */
+function modelArray(body, field) {
+	const value = body[field];
+	const invalid = (detail) => {
+		throw new AgentServerHttpError(400, "invalid_body", detail);
+	};
+	if (!Array.isArray(value)) return invalid(`"${field}" must be an array of { id, input? } entries`);
+	return value.map((item) => {
+		if (typeof item !== "object" || item === null || Array.isArray(item)) return invalid(`"${field}" entries must be an { id, input? } object`);
+		const entry = item;
+		const id = entry.id;
+		if (typeof id !== "string" || id.length === 0) return invalid(`"${field}" entries must carry a non-empty "id"`);
+		if (entry.input === void 0) return { id };
+		if (!Array.isArray(entry.input) || entry.input.length === 0 || entry.input.some((modality) => typeof modality !== "string" || !MODEL_MODALITIES.has(modality))) return invalid(`"${field}" entry "${id}" must declare "input" as a non-empty array of "text" or "image"`);
+		return {
+			id,
+			input: entry.input
+		};
+	});
+}
 function requestOperationSignal(request, shutdownSignal) {
 	const disconnected = new AbortController();
 	if (request.raw.aborted) disconnected.abort({ source: "request" });
@@ -11018,7 +11203,7 @@ function registerProviderRoutes(app, options, requirePairedOrigin) {
 			api: requireString(body, "api"),
 			baseUrl: requireString(body, "baseUrl"),
 			envName: requireString(body, "envName"),
-			models: stringArray(body, "models", { allowEmpty: true }),
+			models: modelArray(body, "models"),
 			...optionalString(body, "apiKey") ? { apiKey: optionalString(body, "apiKey") } : {}
 		});
 		return reply.code(200).send(entry);
@@ -11423,6 +11608,7 @@ async function runAgentServer(argv) {
 	const trustRequested = argv[0] === "trust";
 	const commandArgs = trustRequested ? argv.slice(1) : argv;
 	const envConfig = loadAgentServerEnvConfig();
+	if (trustRequested) return runTrustCommand(commandArgs, resolveAgentServerRoot({ root: envConfig.root }));
 	const { values } = parseArgs({
 		args: commandArgs,
 		options: {
@@ -11432,7 +11618,7 @@ async function runAgentServer(argv) {
 			"api-url": { type: "string" },
 			"heartbeat-interval-ms": { type: "string" },
 			"warm-retention-sec": { type: "string" },
-			remove: { type: "boolean" }
+			supervised: { type: "boolean" }
 		}
 	});
 	const port = Number.parseInt(values.port ?? (envConfig.port || `${DEFAULT_PORT}`), 10);
@@ -11445,7 +11631,6 @@ async function runAgentServer(argv) {
 	const defaultApiUrl = values["api-url"] ?? (envConfig.apiUrl || DEFAULT_API_URL);
 	const runtimeSettings = parseLocalOperationalSettings(values);
 	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"
@@ -11512,7 +11697,7 @@ async function runAgentServer(argv) {
 					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 waitForAgentServerShutdown(runs, app, shutdownController);
+					return await waitForAgentServerShutdown(runs, app, shutdownController, Boolean(values.supervised));
 				} catch (cause) {
 					await app.close().catch(() => void 0);
 					throw cause;
@@ -11533,19 +11718,80 @@ 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.");
+async function runTrustCommand(argv, defaultRoot) {
+	try {
+		const { values } = parseArgs({
+			args: argv,
+			options: {
+				root: { type: "string" },
+				remove: { type: "boolean" },
+				status: { type: "boolean" },
+				yes: { type: "boolean" },
+				json: { type: "boolean" }
+			}
+		});
+		const root = values.root ?? defaultRoot;
+		const statusRequested = Boolean(values.status);
+		const removeRequested = Boolean(values.remove);
+		const yes = Boolean(values.yes);
+		const json = Boolean(values.json);
+		if (statusRequested && (removeRequested || yes)) {
+			console.error("Usage: moltnet-agent server trust --status [--json]");
+			return 1;
+		}
+		if (!isMacos()) {
+			if (json) {
+				printTrustStatus({
+					supported: false,
+					trusted: false,
+					fingerprint: null
+				});
+				return 0;
+			}
+			console.error("Local HTTPS trust setup is currently supported on macOS only.");
+			return 1;
+		}
+		const material = await ensureLocalTlsMaterial(root);
+		if (statusRequested) {
+			const trusted = await isLocalCaTrusted(root);
+			if (json) printTrustStatus({
+				supported: true,
+				trusted,
+				fingerprint: material.fingerprint
+			});
+			else console.log(trusted ? `MoltNet local CA ${material.fingerprint} is trusted.` : `MoltNet local CA ${material.fingerprint} is not trusted.`);
+			return 0;
+		}
+		if (json && !yes) {
+			console.error("Machine-readable trust changes require --yes after native app consent.");
+			return 1;
+		}
+		if (removeRequested) {
+			await removeLocalCa(root);
+			if (json) printTrustStatus({
+				supported: true,
+				trusted: false,
+				fingerprint: material.fingerprint
+			});
+			else console.log("Removed the MoltNet local CA from your login keychain.");
+			return 0;
+		}
+		if (yes) await trustLocalCa(root);
+		else await ensureTrustedLocalTls(root);
+		if (json) printTrustStatus({
+			supported: true,
+			trusted: await isLocalCaTrusted(root),
+			fingerprint: material.fingerprint
+		});
+		else console.log("MoltNet local HTTPS trust is ready for this macOS user.");
 		return 0;
+	} catch (cause) {
+		console.error(`Agent Server trust command failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+		return 1;
 	}
-	await ensureTrustedLocalTls(root);
-	console.error("MoltNet local HTTPS trust is ready for this macOS user.");
-	return 0;
+}
+function printTrustStatus(status) {
+	console.log(JSON.stringify(status));
 }
 async function ensureTrustedLocalTls(root) {
 	const material = await ensureLocalTlsMaterial(root);
@@ -11564,12 +11810,13 @@ async function ensureTrustedLocalTls(root) {
 	await trustLocalCa(root);
 	return material;
 }
-function waitForAgentServerShutdown(runs, app, shutdownController) {
+function waitForAgentServerShutdown(runs, app, shutdownController, supervised) {
 	return new Promise((resolvePromise) => {
 		let shuttingDown = false;
-		const shutdown = () => {
+		const shutdown = (source) => {
 			if (shuttingDown) return;
 			shuttingDown = true;
+			if (source === "stdin") console.error("shutting down: stdin EOF");
 			shutdownController.abort({ source: "shutdown" });
 			(async () => {
 				app.server.closeAllConnections();
@@ -11595,16 +11842,31 @@ function waitForAgentServerShutdown(runs, app, shutdownController) {
 				const failures = results.filter((result) => result.status === "rejected");
 				for (const failure of failures) console.error(`shutdown cleanup failed: ${failure.reason.message}`);
 				handlers.dispose();
+				stdinGuard.dispose();
 				const exitCode = typeof process.exitCode === "number" ? process.exitCode : 0;
 				resolvePromise(failures.length > 0 ? 1 : exitCode);
 			})();
 		};
 		const handlers = installShutdownSignalHandlers({
 			logDrain: () => console.error("shutting down: stopping runs…"),
-			drain: shutdown
+			drain: () => shutdown()
+		});
+		const stdinGuard = installSupervisedStdinGuard({
+			enabled: supervised,
+			shutdown: () => shutdown("stdin")
 		});
 	});
 }
+/** Makes the supervising process's stdin pipe part of the server lifecycle. */
+function installSupervisedStdinGuard(options) {
+	if (!options.enabled) return { dispose: () => void 0 };
+	const input = options.input ?? process.stdin;
+	const onEnd = () => options.shutdown();
+	input.once("end", onEnd);
+	input.resume();
+	if (input.readableEnded) queueMicrotask(onEnd);
+	return { dispose: () => input.off("end", onEnd) };
+}
 //#endregion
 //#region src/lib/runtime-session-sync.ts
 async function syncRuntimeSessions(deps, input) {
@@ -11942,7 +12204,7 @@ async function writeCache(cache) {
 }
 //#endregion
 //#region src/version.ts
-var DAEMON_VERSION = "0.57.1";
+var DAEMON_VERSION = "0.58.0";
 //#endregion
 //#region src/cli.ts
 async function runAgentDaemonCli(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/agent-daemon",
-  "version": "0.57.1",
+  "version": "0.58.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.",
@@ -86,8 +86,8 @@
     "reflect-metadata": "^0.2.2",
     "typebox": "^1.2.8",
     "@themoltnet/agent-runtime": "1.0.3",
+    "@themoltnet/pi-runtime": "0.17.0",
     "@themoltnet/sdk": "0.142.0",
-    "@themoltnet/pi-runtime": "0.16.0",
     "@themoltnet/os-keyring": "0.3.0"
   },
   "devDependencies": {
@@ -98,15 +98,15 @@
     "vite": "^8.0.0",
     "vite-plugin-dts": "^4.5.4",
     "vitest": "^3.0.0",
-    "@moltnet/api-client": "0.1.0",
     "@moltnet/agent-eval": "0.1.0",
+    "@moltnet/api-client": "0.1.0",
+    "@moltnet/loopback-companion": "0.1.0",
+    "@moltnet/execution-plan": "0.1.0",
+    "@moltnet/bootstrap": "0.1.0",
+    "@moltnet/models": "0.1.0",
     "@moltnet/execution-integrations": "0.1.0",
     "@moltnet/crypto-service": "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/bootstrap": "0.1.0",
     "@moltnet/runtime-profiles": "0.1.0",
     "@moltnet/tasks": "0.1.0"
   },