@themoltnet/agent-daemon 0.57.0 → 0.58.0

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/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 { a as cryptoService, defaultPiDaemonAdapter, i as compileExecutionPlan, n as createExecutionPlanSnapshot, r as parseCredentialRequirements, t as runtimeExecutionOffer } from "./pi.js";
 import { createRequire } from "node:module";
 import { pino, transport } from "pino";
 import { Type } from "typebox";
@@ -10,7 +10,7 @@ import "multiformats/hashes/sha2";
 import "typebox/value";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { parseArgs, promisify } from "node:util";
-import { AgentRuntime, ApiTaskReporter, ApiTaskSource, PollingApiTaskSource, createLocalSeedSigner, resolveAgentIdentity, resolveProfileWarmSessionTtlSec, resolveRuntimeProfile, resolveRuntimeProfiles, validateRuntimeProfilePrerequisites } from "@themoltnet/agent-runtime";
+import { AgentRuntime, ApiTaskReporter, ApiTaskSource, PollingApiTaskSource, createLocalSeedSigner, resolveAgentIdentity, resolveRuntimeProfile, resolveRuntimeProfiles, validateRuntimeProfilePrerequisites } from "@themoltnet/agent-runtime";
 import { GuestEnvironmentBoundaryError, assertGuestEnvironmentBoundary, createPiRetryTriage, findMainWorktree, isResolvedPathInsideRoot, normalizeRetryTriageResult, redactRetryTriageSecrets, resolveRuntimeProfileModel } from "@themoltnet/pi-runtime";
 import { FILE_SECRET_PROVIDER, FileSecretProvider, RegisterIdentityError, boundedIdentitySignal, connect, createNodeSecretProviderRegistry, register } from "@themoltnet/sdk/node";
 import { constants, copyFileSync, createReadStream, createWriteStream, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
@@ -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";
@@ -1937,18 +1937,6 @@ var RuntimeProfileRef = Type.Object({ profileId: Type.String({ format: "uuid" })
 	$id: "RuntimeProfileRef",
 	additionalProperties: false
 });
-var RuntimeProfileLeaseTtlSec = Type.Integer({
-	minimum: 1,
-	maximum: 86400
-});
-var RuntimeProfileHeartbeatIntervalMs = Type.Integer({
-	minimum: 0,
-	maximum: 36e5
-});
-var RuntimeProfileMaxBatchSize = Type.Integer({
-	minimum: 1,
-	maximum: 1e3
-});
 var RuntimeProfileMaxTurns = Type.Integer({
 	minimum: 0,
 	maximum: 1e4
@@ -1977,21 +1965,8 @@ Type.Object({
 	maxOutputTokens: RuntimeProfileNullableMaxOutputTokens,
 	runtimeKind: RuntimeProfileRuntimeKind,
 	sandbox: RuntimeProfileSandbox,
-	sessionStorageMode: Type.Literal("local"),
-	workspaceStorageMode: Type.Literal("local"),
 	defaultWorkspaceMode: Type.Union([RuntimeProfileWorkspaceMode, Type.Null()]),
 	allowedWorkspaceModes: RuntimeProfileAllowedWorkspaceModes,
-	sessionTtlSec: Type.Integer({
-		minimum: 1,
-		maximum: 86400
-	}),
-	workspaceTtlSec: Type.Integer({
-		minimum: 1,
-		maximum: 86400
-	}),
-	leaseTtlSec: RuntimeProfileLeaseTtlSec,
-	heartbeatIntervalMs: RuntimeProfileHeartbeatIntervalMs,
-	maxBatchSize: RuntimeProfileMaxBatchSize,
 	maxTurns: RuntimeProfileMaxTurns,
 	maxBashTimeouts: RuntimeProfileMaxBashTimeouts,
 	toolEnforcement: RuntimeProfileToolEnforcement,
@@ -2124,6 +2099,7 @@ var ResolvedRuntimeSlot = Type.Object({
 	workspace: Type.Union([RuntimeWorkspace, Type.Null()])
 }, { $id: "ResolvedRuntimeSlot" });
 Type.Object({ items: Type.Array(ResolvedRuntimeSlot) }, { $id: "RuntimeSlotListResponse" });
+var MAX_RUNTIME_WARM_RETENTION_SEC = 86400;
 Type.Object({
 	agentName: Type.String({
 		minLength: 1,
@@ -2150,7 +2126,11 @@ Type.Object({
 	worktreeBranch: Type.Optional(Type.String({ minLength: 1 })),
 	workspaceKind: Type.Optional(RuntimeWorkspaceKind),
 	lastTaskId: Type.String({ format: "uuid" }),
-	lastAttemptN: Type.Integer({ minimum: 1 })
+	lastAttemptN: Type.Integer({ minimum: 1 }),
+	warmRetentionSec: Type.Integer({
+		minimum: 0,
+		maximum: MAX_RUNTIME_WARM_RETENTION_SEC
+	})
 }, {
 	$id: "BeginRuntimeSlotBody",
 	additionalProperties: false
@@ -2172,7 +2152,11 @@ Type.Object({
 	slotKey: Type.String({ minLength: 1 }),
 	taskId: Type.String({ format: "uuid" }),
 	attemptN: Type.Integer({ minimum: 1 }),
-	sessionPath: Type.Optional(Type.String({ minLength: 1 }))
+	sessionPath: Type.Optional(Type.String({ minLength: 1 })),
+	warmRetentionSec: Type.Integer({
+		minimum: 0,
+		maximum: MAX_RUNTIME_WARM_RETENTION_SEC
+	})
 }, {
 	$id: "FinishRuntimeSlotBody",
 	additionalProperties: false
@@ -3461,7 +3445,7 @@ var COMMON_REQUIRED_FLAGS = `\
   --profile <uuid|name>       Remote runtime profile. Repeat for poll/drain
                               to declare priority order. Provider, model,
                               sandbox policy, prerequisites, and runtime
-                              defaults come from the selected profile.`;
+                              execution policy come from the selected profile.`;
 var COMMON_OPTIONAL_FLAGS = `\
   --sandbox <path>            Deprecated. Remote runtime profiles define
                               sandbox policy.
@@ -3473,24 +3457,10 @@ var COMMON_OPTIONAL_FLAGS = `\
                               host git config. Configless agent-key runs must
                               provide this flag or MOLTNET_GIT_AUTHOR.
                               Env: MOLTNET_GIT_AUTHOR.
-  --lease-ttl-sec <n>         Sliding liveness window. Silence longer than
-                              this ends the attempt with lease_expired.
-                              Default: 300.
   --heartbeat-interval-ms <n> Reporter heartbeat cadence. Default: 60000.
-  --max-batch-size <n>        Reporter message batch size. Default: 50.
-  --flush-interval-ms <n>     Reporter flush window. Default: 200.
-  --max-turns <n>             Cap on tool-use turns per attempt; over this,
-                              the pi session aborts and the attempt fails
-                              with code 'max_turns_exceeded'. 0 = disabled.
-                              Default: 0. Recommended ~30 for fulfill_brief.
-  --max-bash-timeouts <n>     Cap on bash-tool timeouts per attempt; over
-                              this, the pi session aborts and the attempt
-                              fails with code 'max_bash_timeouts_exceeded'.
-                              0 = disabled. Default: 3.
-  --warm-session-ttl-sec <n>  Resumability window for runtime slots
+  --warm-retention-sec <n>    Resumability window for runtime slots
                               (Pi sessions + reusable worktrees) after use.
-                              Default: 1800, or min(profile session/workspace
-                              TTL) when --profile is set.
+                              Default: 1800.
   --debug                     Verbose logging: also log successful list/claim
                               outcomes (candidate counts, claim attempts).`;
 var REGISTERED_TASK_TYPES = Object.keys(BUILT_IN_TASK_TYPES).sort();
@@ -3681,10 +3651,17 @@ Options:
                               (or MOLTNET_AGENT_SERVER_ROOT).
   --api-url <url>             Default MoltNet API for new managed agents.
                               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.
@@ -3693,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>]
@@ -3703,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
@@ -4189,10 +4172,10 @@ function slugifySessionComponent(input) {
 }
 //#endregion
 //#region src/lib/task-execution-plan.ts
-function buildDaemonTaskExecutionPlan(task, stateDirs, identity, warmSessionTtlSec, runtimeProfileWorkspacePolicy = {}, attemptN) {
+function buildDaemonTaskExecutionPlan(task, stateDirs, identity, warmRetentionSec, runtimeProfileWorkspacePolicy = {}, attemptN) {
 	const descriptor = deriveTaskSessionDescriptor(task);
 	const workspaceMode = resolveTaskWorkspaceMode(task, descriptor.policy, runtimeProfileWorkspacePolicy);
-	const slotKey = warmSessionTtlSec > 0 && descriptor.sessionKey ? buildRuntimeSlotKey(descriptor.sessionKey, identity.runtimeInstanceId) : null;
+	const slotKey = warmRetentionSec > 0 && descriptor.sessionKey ? buildRuntimeSlotKey(descriptor.sessionKey, identity.runtimeInstanceId) : null;
 	const workspaceScope = slotKey !== null ? descriptor.policy.workspaceScope : "attempt";
 	const slotId = slotKey ? buildDaemonSlotId(identity, slotKey) : null;
 	const sessionDir = slotId ? `${stateDirs.piSessionsDir}/${boundedKeyDirComponent(slotId)}` : null;
@@ -4331,7 +4314,7 @@ function createExecutionPlanCache(args) {
 			const key = buildClaimedTaskKey(claimedTask);
 			const existing = cache.get(key);
 			if (existing) return existing;
-			const plan = await maybeAttachWarmSlotContext(claimedTask, buildDaemonTaskExecutionPlan(claimedTask.task, args.stateDirs, args.slotIdentity, args.warmSessionTtlSec, args.workspacePolicy, claimedTask.attemptN), args.stateDirs, args.slotRegistry, runtimeSessionStore, sourceAttemptResolver);
+			const plan = await maybeAttachWarmSlotContext(claimedTask, buildDaemonTaskExecutionPlan(claimedTask.task, args.stateDirs, args.slotIdentity, args.warmRetentionSec, args.workspacePolicy, claimedTask.attemptN), args.stateDirs, args.slotRegistry, runtimeSessionStore, sourceAttemptResolver);
 			assertPlanAllowedByWorkspacePolicy(plan, args.workspacePolicy, args.slotIdentity.runtimeProfileId);
 			cache.set(key, plan);
 			return plan;
@@ -5022,7 +5005,8 @@ function ownBinding(bindings, name) {
 }
 //#endregion
 //#region ../../libs/execution-integrations/src/runtime-profile.ts
-var CURRENT_EFFECTIVE_POLICY_SNAPSHOT_VERSION = "effective-policy:v1";
+var CURRENT_EFFECTIVE_POLICY_SNAPSHOT_VERSION = "effective-policy:v2";
+var DEFAULT_EXECUTION_LEASE_TTL_SEC = 300;
 /**
 * Maps resolved product authority into portable intent. Policy composition is
 * deliberately upstream: this boundary accepts no policy IDs and performs no
@@ -5046,7 +5030,7 @@ function executionIntentFromRuntimeProfile(input) {
 		credentialRequirements: structuredClone(input.credentialRequirements),
 		requiredCapabilities: [...input.requiredCapabilities ?? []],
 		lease: {
-			ttlSec: input.profile.leaseTtlSec,
+			ttlSec: DEFAULT_EXECUTION_LEASE_TTL_SEC,
 			requiredControls: [...input.requiredLeaseControls ?? []]
 		},
 		network: {
@@ -5296,14 +5280,9 @@ async function logDaemonStartupFailure(input) {
 }
 //#endregion
 //#region src/lib/options.ts
-var DEFAULTS = {
-	leaseTtlSec: 300,
+var DEFAULT_LOCAL_OPERATIONAL_SETTINGS = {
 	heartbeatIntervalMs: 6e4,
-	maxBatchSize: 50,
-	flushIntervalMs: 200,
-	maxTurns: 0,
-	maxBashTimeouts: 3,
-	warmSessionTtlSec: 1800
+	warmRetentionSec: 1800
 };
 var MissingRequiredOptionError = class extends Error {
 	constructor(flag) {
@@ -5312,42 +5291,33 @@ var MissingRequiredOptionError = class extends Error {
 		this.name = "MissingRequiredOptionError";
 	}
 };
-function parseCommonOptions(args, options = {}) {
-	const runtimeDefaults = {
-		leaseTtlSec: options.runtimeDefaults?.leaseTtlSec ?? DEFAULTS.leaseTtlSec,
-		heartbeatIntervalMs: options.runtimeDefaults?.heartbeatIntervalMs ?? DEFAULTS.heartbeatIntervalMs,
-		maxBatchSize: options.runtimeDefaults?.maxBatchSize ?? DEFAULTS.maxBatchSize,
-		maxTurns: options.runtimeDefaults?.maxTurns ?? DEFAULTS.maxTurns,
-		maxBashTimeouts: options.runtimeDefaults?.maxBashTimeouts ?? DEFAULTS.maxBashTimeouts,
-		warmSessionTtlSec: options.runtimeDefaults?.warmSessionTtlSec ?? DEFAULTS.warmSessionTtlSec
-	};
+function parseIdentityProcessOptions(args) {
 	if (!args.agent) throw new MissingRequiredOptionError("agent");
 	if (!/^[a-zA-Z0-9_-]+$/.test(args.agent)) throw new Error(`Invalid --agent "${args.agent}": must match /^[a-zA-Z0-9_-]+$/`);
 	return {
 		agent: args.agent,
-		leaseTtlSec: parsePositiveInt(args["lease-ttl-sec"], "lease-ttl-sec", runtimeDefaults.leaseTtlSec),
-		heartbeatIntervalMs: parseNonNegativeInt(args["heartbeat-interval-ms"], "heartbeat-interval-ms", runtimeDefaults.heartbeatIntervalMs),
-		maxBatchSize: parsePositiveInt(args["max-batch-size"], "max-batch-size", runtimeDefaults.maxBatchSize),
-		flushIntervalMs: parseNonNegativeInt(args["flush-interval-ms"], "flush-interval-ms", DEFAULTS.flushIntervalMs),
-		maxTurns: parseNonNegativeInt(args["max-turns"], "max-turns", runtimeDefaults.maxTurns),
-		maxBashTimeouts: parseNonNegativeInt(args["max-bash-timeouts"], "max-bash-timeouts", runtimeDefaults.maxBashTimeouts),
-		warmSessionTtlSec: parseNonNegativeInt(args["warm-session-ttl-sec"], "warm-session-ttl-sec", runtimeDefaults.warmSessionTtlSec),
 		debug: args.debug === true
 	};
 }
-function parsePositiveInt(raw, name, defaultValue) {
-	if (raw === void 0) return defaultValue;
-	const v = Number(raw);
-	if (!Number.isInteger(v) || v < 1) throw new Error(`Invalid --${name} "${raw}": must be a positive integer`);
-	return v;
+function parseLocalOperationalSettings(args) {
+	return {
+		heartbeatIntervalMs: parseNonNegativeInt(args["heartbeat-interval-ms"], "heartbeat-interval-ms", DEFAULT_LOCAL_OPERATIONAL_SETTINGS.heartbeatIntervalMs),
+		warmRetentionSec: parseNonNegativeInt(args["warm-retention-sec"], "warm-retention-sec", DEFAULT_LOCAL_OPERATIONAL_SETTINGS.warmRetentionSec, MAX_RUNTIME_WARM_RETENTION_SEC)
+	};
+}
+function parseRuntimeCommandOptions(args) {
+	return {
+		identity: parseIdentityProcessOptions(args),
+		operations: parseLocalOperationalSettings(args)
+	};
 }
-function parseNonNegativeInt(raw, name, defaultValue) {
+function parseNonNegativeInt(raw, name, defaultValue, maximum = Number.MAX_SAFE_INTEGER) {
 	if (raw === void 0) return defaultValue;
-	const v = Number(raw);
-	if (!Number.isInteger(v) || v < 0) throw new Error(`Invalid --${name} "${raw}": must be a non-negative integer`);
-	return v;
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value < 0 || value > maximum) throw new Error(`Invalid --${name} "${raw}": must be a non-negative integer no greater than ${maximum}`);
+	return value;
 }
-function commonOptionDefs() {
+function identityOptionDefs() {
 	return {
 		agent: {
 			type: "string",
@@ -5355,18 +5325,18 @@ function commonOptionDefs() {
 		},
 		"agent-root": { type: "string" },
 		"git-author": { type: "string" },
-		"lease-ttl-sec": { type: "string" },
-		"heartbeat-interval-ms": { type: "string" },
-		"max-batch-size": { type: "string" },
-		"flush-interval-ms": { type: "string" },
-		"max-turns": { type: "string" },
-		"max-bash-timeouts": { type: "string" },
-		"warm-session-ttl-sec": { type: "string" },
 		debug: { type: "boolean" }
 	};
 }
+function runtimeCommandOptionDefs() {
+	return {
+		...identityOptionDefs(),
+		"heartbeat-interval-ms": { type: "string" },
+		"warm-retention-sec": { type: "string" }
+	};
+}
 function validateTaskTypes(types) {
-	const unknown = types.filter((t) => !Object.prototype.hasOwnProperty.call(BUILT_IN_TASK_TYPES, t));
+	const unknown = types.filter((taskType) => !Object.prototype.hasOwnProperty.call(BUILT_IN_TASK_TYPES, taskType));
 	if (unknown.length > 0) throw new Error(`Unknown task type(s): ${unknown.join(", ")}. Known types: ${knownTaskTypesList()}.`);
 	return [...types];
 }
@@ -5465,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`;
 }
@@ -5663,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) {
@@ -5936,6 +5918,64 @@ function mergePiModels(store, repo) {
 	return { providers };
 }
 //#endregion
+//#region src/lib/state-dir.ts
+function ensureDaemonStateDirs(mountPath) {
+	const rootDir = join(mountPath, ".moltnet", "d");
+	const piSessionsDir = join(rootDir, "pi-sessions");
+	mkdirSync(piSessionsDir, { recursive: true });
+	return {
+		rootDir,
+		piSessionsDir
+	};
+}
+//#endregion
+//#region src/lib/prepare-runtime-profile.ts
+/** Validate and prepare a profile through the shared daemon execution path. */
+async function prepareRuntimeProfile(input) {
+	const { profile } = input;
+	assertRuntimeAdapterSupportsProfile(input.runtimeAdapter, profile);
+	const preparedRuntime = attestPreparedRuntime(await input.runtimeAdapter.prepare({ profile }), input.signingPrivateKey);
+	validateRuntimeProfilePrerequisites(profile, input.prerequisiteEnv, {
+		tools: preparedRuntime.tools,
+		executables: preparedRuntime.executables
+	});
+	assertGuestEnvironmentBoundary({
+		forwardEnv: profile.requiredEnv,
+		sandboxEnv: profile.sandboxConfig.env
+	});
+	await input.agent.tasks.registerExecutorManifest(await preparedRuntime.attestor.registration());
+	const sandbox = {
+		config: profile.sandboxConfig,
+		rootDir: profile.mountPath,
+		path: profile.source
+	};
+	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
+	const slotIdentity = {
+		agentName: input.agentName,
+		runtimeProfileId: profile.id,
+		runtimeInstanceId: input.runtimeInstanceId
+	};
+	return {
+		profile,
+		preparedRuntime,
+		sandbox,
+		stateDirs,
+		slotIdentity,
+		executionPlans: createExecutionPlanCache({
+			stateDirs,
+			slotIdentity,
+			warmRetentionSec: input.warmRetentionSec,
+			workspacePolicy: {
+				defaultWorkspaceMode: profile.defaultWorkspaceMode,
+				allowedWorkspaceModes: profile.allowedWorkspaceModes
+			},
+			slotRegistry: input.slotRegistry,
+			runtimeSessionStore: input.runtimeSessionStore,
+			sourceAttemptResolver: input.sourceAttemptResolver
+		})
+	};
+}
+//#endregion
 //#region src/lib/runtime-context.ts
 var storage = new AsyncLocalStorage();
 function runWithDaemonRuntimeContext(context, callback) {
@@ -6331,13 +6371,14 @@ function createApiRuntimeSlotStore(args) {
 				sessionPath: input.sessionPath ?? void 0,
 				slotKey: input.slotKey,
 				taskType: input.taskType,
+				warmRetentionSec: input.warmRetentionSec,
 				workspaceId: input.workspaceId ?? void 0,
 				workspaceKind: input.workspaceKind,
 				worktreeBranch: input.worktreeBranch ?? void 0,
 				worktreePath: input.worktreePath ?? void 0
 			}, { teamId: input.teamId });
 		},
-		async finishSlot(teamId, taskId, attemptN, identity, slotKey, provider, model, sessionPath) {
+		async finishSlot(teamId, taskId, attemptN, identity, slotKey, provider, model, sessionPath, warmRetentionSec) {
 			await agent.runtimeSlots.finish({
 				agentName: identity.agentName,
 				attemptN,
@@ -6346,7 +6387,8 @@ function createApiRuntimeSlotStore(args) {
 				provider,
 				sessionPath: sessionPath ?? void 0,
 				slotKey,
-				taskId
+				taskId,
+				warmRetentionSec
 			}, { teamId });
 		},
 		async findLatestSlotByTaskAttempt(teamId, taskId, attemptN) {
@@ -6482,17 +6524,6 @@ function resolveOutputBranch(output) {
 	return typeof branch === "string" && branch.length > 0 ? branch : null;
 }
 //#endregion
-//#region src/lib/state-dir.ts
-function ensureDaemonStateDirs(mountPath) {
-	const rootDir = join(mountPath, ".moltnet", "d");
-	const piSessionsDir = join(rootDir, "pi-sessions");
-	mkdirSync(piSessionsDir, { recursive: true });
-	return {
-		rootDir,
-		piSessionsDir
-	};
-}
-//#endregion
 //#region src/lib/turn-event-logger.ts
 function makeTurnEventHandler(base, context = {}) {
 	const log = base.child({
@@ -6523,7 +6554,7 @@ async function runPolling(opts) {
 	const { values } = parseArgs({
 		args: opts.argv,
 		options: {
-			...commonOptionDefs(),
+			...runtimeCommandOptionDefs(),
 			team: { type: "string" },
 			"task-types": { type: "string" },
 			"correlation-id": { type: "string" },
@@ -6561,9 +6592,9 @@ async function runPolling(opts) {
 		return 1;
 	}
 	const diaryIds = parseCsv(values["diary-ids"]);
-	let baseCommon;
+	let commandOptions;
 	try {
-		baseCommon = parseCommonOptions(values);
+		commandOptions = parseRuntimeCommandOptions(values);
 	} catch (err) {
 		if (err instanceof MissingRequiredOptionError) {
 			console.error(`${err.message}\n`);
@@ -6572,6 +6603,7 @@ async function runPolling(opts) {
 		}
 		throw err;
 	}
+	const { identity, operations } = commandOptions;
 	const pollIntervalMs = optionalPositiveInt(values["poll-interval-ms"], "poll-interval-ms", 2e3);
 	const maxPollIntervalMs = optionalPositiveInt(values["max-poll-interval-ms"], "max-poll-interval-ms", 3e4);
 	const listLimit = optionalPositiveInt(values["list-limit"], "list-limit", 10);
@@ -6596,7 +6628,7 @@ async function runPolling(opts) {
 	const { ctx, signingPrivateKey, startupWhoami, agentIdentity, hostCapabilitySigner } = await (async () => {
 		let gate = "resolve_agent_context";
 		try {
-			const resolvedContext = await resolveAgentContext(baseCommon.agent, {
+			const resolvedContext = await resolveAgentContext(identity.agent, {
 				agentRootDir: explicitAgentRootDir,
 				credentialSource: cfg.credentialSource,
 				envApiUrl: cfg.apiUrl
@@ -6623,7 +6655,7 @@ async function runPolling(opts) {
 			});
 			gate = "resolve_agent_identity";
 			const agentIdentity = await resolveDaemonAgentIdentity({
-				agentName: baseCommon.agent,
+				agentName: identity.agent,
 				whoami,
 				credentialSource: cfg.credentialSource,
 				agentDir: resolvedContext.agentDir,
@@ -6643,9 +6675,9 @@ async function runPolling(opts) {
 		} catch (error) {
 			await logDaemonStartupFailure({
 				serviceName: `agent-daemon.${opts.modeLabel}`,
-				level: cfg.logLevel || (baseCommon.debug ? "debug" : "info"),
+				level: cfg.logLevel || (identity.debug ? "debug" : "info"),
 				gate,
-				agent: baseCommon.agent,
+				agent: identity.agent,
 				credentialSource: cfg.credentialSource,
 				error
 			});
@@ -6659,23 +6691,43 @@ async function runPolling(opts) {
 		teamId,
 		cwd: daemonRootDir
 	});
+	const { logger, shutdown: shutdownLogger } = createRootLogger({
+		name: `agent-daemon.${opts.modeLabel}`,
+		level: cfg.logLevel || (identity.debug ? "debug" : "info")
+	});
+	const rootLogger = logger.child({
+		mode: opts.modeLabel,
+		agent: identity.agent,
+		teamId,
+		runtimeProfileIds: resolvedProfiles.map((profile) => profile.id),
+		runtimeProfileNames: resolvedProfiles.map((profile) => profile.name)
+	});
 	const runtimeAdapter = opts.runtimeAdapter ?? defaultPiDaemonAdapter;
-	const preparedRuntimes = /* @__PURE__ */ new Map();
 	const profiles = [];
+	const runtimes = /* @__PURE__ */ new Map();
 	const skippedProfileBoundaries = [];
+	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
+	const runtimeSessionStore = createApiRuntimeSessionStore({
+		agent: ctx.agent,
+		logger: { warn: (context, message) => rootLogger.warn(context, message) }
+	});
+	const sourceAttemptResolver = createApiSourceAttemptResolver({ agent: ctx.agent });
+	const runtimeInstanceId = createRuntimeInstanceId();
 	for (const profile of resolvedProfiles) try {
-		assertRuntimeAdapterSupportsProfile(runtimeAdapter, profile);
-		const prepared = attestPreparedRuntime(await runtimeAdapter.prepare({ profile }), signingPrivateKey);
-		validateRuntimeProfilePrerequisites(profile, cfg.profilePrerequisiteEnv, {
-			tools: prepared.tools,
-			executables: prepared.executables
-		});
-		assertGuestEnvironmentBoundary({
-			forwardEnv: profile.requiredEnv,
-			sandboxEnv: profile.sandboxConfig.env
+		const prepared = await prepareRuntimeProfile({
+			agent: ctx.agent,
+			agentName: identity.agent,
+			profile,
+			prerequisiteEnv: cfg.profilePrerequisiteEnv,
+			runtimeAdapter,
+			runtimeInstanceId,
+			signingPrivateKey,
+			slotRegistry,
+			runtimeSessionStore,
+			sourceAttemptResolver,
+			warmRetentionSec: operations.warmRetentionSec
 		});
-		await ctx.agent.tasks.registerExecutorManifest(await prepared.attestor.registration());
-		preparedRuntimes.set(profile.id, prepared);
+		runtimes.set(profile.id, prepared);
 		profiles.push(profile);
 	} catch (error) {
 		if (!(error instanceof GuestEnvironmentBoundaryError)) throw error;
@@ -6688,84 +6740,22 @@ async function runPolling(opts) {
 		const details = skippedProfileBoundaries.map(({ profile, error }) => `${profile.name}: ${error.message}`).join("; ");
 		throw new Error(`No safe runtime profiles remain. ${details}`);
 	}
-	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
-	const runtimeSessionStore = createApiRuntimeSessionStore({
-		agent: ctx.agent,
-		logger: { warn: (context, message) => rootLogger.warn(context, message) }
-	});
-	const sourceAttemptResolver = createApiSourceAttemptResolver({ agent: ctx.agent });
-	const runtimeInstanceId = createRuntimeInstanceId();
 	const piAgentDir = await resolvePiAgentDir(cfg, profiles[0].mountPath, profiles);
 	process.once("exit", piAgentDir.cleanup);
 	activatePiCodingAgentDir(piAgentDir.path, piAgentDir.env);
-	const runtimes = /* @__PURE__ */ new Map();
-	for (const profile of profiles) {
-		const common = parseCommonOptions(values, { runtimeDefaults: {
-			leaseTtlSec: profile.leaseTtlSec,
-			heartbeatIntervalMs: profile.heartbeatIntervalMs,
-			maxBatchSize: profile.maxBatchSize,
-			maxTurns: profile.maxTurns,
-			maxBashTimeouts: profile.maxBashTimeouts,
-			warmSessionTtlSec: resolveProfileWarmSessionTtlSec(profile)
-		} });
-		const sandbox = {
-			config: profile.sandboxConfig,
-			rootDir: profile.mountPath,
-			path: profile.source
-		};
-		const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
-		const slotIdentity = {
-			agentName: common.agent,
-			runtimeProfileId: profile.id,
-			runtimeInstanceId
-		};
-		const executionPlans = createExecutionPlanCache({
-			stateDirs,
-			slotIdentity,
-			warmSessionTtlSec: common.warmSessionTtlSec,
-			workspacePolicy: {
-				defaultWorkspaceMode: profile.defaultWorkspaceMode,
-				allowedWorkspaceModes: profile.allowedWorkspaceModes
-			},
-			slotRegistry,
-			runtimeSessionStore,
-			sourceAttemptResolver
-		});
-		runtimes.set(profile.id, {
-			common,
-			profile,
-			sandbox,
-			stateDirs,
-			slotIdentity,
-			executionPlans,
-			preparedRuntime: preparedRuntimes.get(profile.id)
-		});
-	}
-	const firstRuntime = runtimes.get(profiles[0].id);
-	if (!firstRuntime) throw new Error("No runtime profiles resolved");
+	if (!runtimes.has(profiles[0].id)) throw new Error("No runtime profiles resolved");
 	const otelShutdown = await initWorkerOtel({
 		serviceName: opts.serviceName,
 		agent: ctx.agent,
 		endpoint: cfg.otelEndpoint,
 		resourceAttributes: {
 			"moltnet.team.id": teamId,
-			"moltnet.agent.name": baseCommon.agent,
+			"moltnet.agent.name": identity.agent,
 			"moltnet.credential.source": ctx.credentialSource,
 			"moltnet.runtime_profile.count": String(profiles.length),
 			"moltnet.runtime_profile.ids": profiles.map((p) => p.id).join(",")
 		}
 	});
-	const { logger, shutdown: shutdownLogger } = createRootLogger({
-		name: `agent-daemon.${opts.modeLabel}`,
-		level: cfg.logLevel || (baseCommon.debug ? "debug" : "info")
-	});
-	const rootLogger = logger.child({
-		mode: opts.modeLabel,
-		agent: baseCommon.agent,
-		teamId,
-		runtimeProfileIds: profiles.map((p) => p.id),
-		runtimeProfileNames: profiles.map((p) => p.name)
-	});
 	for (const { profile, error } of skippedProfileBoundaries) rootLogger.warn({
 		runtimeProfileId: profile.id,
 		runtimeProfileName: profile.name,
@@ -6821,13 +6811,10 @@ async function runPolling(opts) {
 				topK: profile.topK,
 				maxOutputTokens: profile.maxOutputTokens,
 				sandbox: runtime.sandbox.path,
-				leaseTtlSec: runtime.common.leaseTtlSec,
-				heartbeatIntervalMs: runtime.common.heartbeatIntervalMs,
-				maxTurns: runtime.common.maxTurns,
-				maxBashTimeouts: runtime.common.maxBashTimeouts,
-				warmSessionTtlSec: runtime.common.warmSessionTtlSec,
-				profileSessionTtlSec: profile.sessionTtlSec,
-				profileWorkspaceTtlSec: profile.workspaceTtlSec,
+				heartbeatIntervalMs: operations.heartbeatIntervalMs,
+				maxTurns: profile.maxTurns,
+				maxBashTimeouts: profile.maxBashTimeouts,
+				warmRetentionSec: operations.warmRetentionSec,
 				defaultWorkspaceMode: profile.defaultWorkspaceMode,
 				allowedWorkspaceModes: profile.allowedWorkspaceModes
 			};
@@ -6852,7 +6839,7 @@ async function runPolling(opts) {
 					runtimeSlotStore: slotRegistry,
 					taskReader: ctx.agent.tasks
 				}, {
-					agentName: selected.common.agent,
+					agentName: identity.agent,
 					mainWorktree: resolveMainWorktree$1(selected.sandbox.rootDir),
 					runtimeInstanceId,
 					runtimeProfileId: profile.id,
@@ -6885,12 +6872,8 @@ async function runPolling(opts) {
 				teamId,
 				taskTypes: taskTypes.length > 0 ? taskTypes : void 0,
 				correlationId: values["correlation-id"],
-				profiles: profiles.map((profile) => ({
-					profileId: profile.id,
-					leaseTtlSec: requireRuntime(runtimes, profile.id).common.leaseTtlSec
-				})),
+				profiles: profiles.map((profile) => ({ profileId: profile.id })),
 				diaryIds: diaryIds.length > 0 ? diaryIds : void 0,
-				leaseTtlSec: firstRuntime.common.leaseTtlSec,
 				listLimit,
 				pollIntervalMs,
 				maxPollIntervalMs,
@@ -6898,7 +6881,7 @@ async function runPolling(opts) {
 				stopWhenEmpty: opts.stopWhenEmpty,
 				waitForFirstTaskMs: waitForFirstTaskSec * 1e3,
 				waitAfterTaskMs: waitAfterTaskSec * 1e3,
-				debug: baseCommon.debug,
+				debug: identity.debug,
 				traceIdlePolling: cfg.traceIdlePolling,
 				logger: rootLogger,
 				executorFingerprints: Object.fromEntries(profiles.map((profile) => [profile.id, requireRuntime(runtimes, profile.id).preparedRuntime.attestor.fingerprint])),
@@ -6907,14 +6890,11 @@ async function runPolling(opts) {
 				sourceAttemptResolver
 			}),
 			makeReporter: (claimedTask) => {
-				const selected = runtimeForClaimedTask(runtimes, claimedTask);
 				return new ApiTaskReporter({
 					tasks: ctx.agent.tasks,
 					teamId: claimedTask.task.teamId,
-					leaseTtlSec: selected.common.leaseTtlSec,
-					heartbeatIntervalMs: selected.common.heartbeatIntervalMs,
-					maxBatchSize: selected.common.maxBatchSize,
-					flushIntervalMs: selected.common.flushIntervalMs
+					heartbeatIntervalMs: operations.heartbeatIntervalMs,
+					logger: rootLogger
 				});
 			},
 			onTaskFinished: async (output, claimedTask) => {
@@ -6962,7 +6942,7 @@ async function runPolling(opts) {
 			},
 			executeTask: async (claimedTask, reporter) => {
 				const selected = runtimeForClaimedTask(runtimes, claimedTask);
-				const { common, executionPlans, profile, sandbox, slotIdentity, stateDirs } = selected;
+				const { executionPlans, profile, sandbox, slotIdentity, stateDirs } = selected;
 				if (runtimeCredentialConfig) await observeGovernancePlanSafely({
 					config: runtimeCredentialConfig,
 					profile,
@@ -7076,10 +7056,11 @@ async function runPolling(opts) {
 					worktreeBranch: executionPlan.worktreeBranch,
 					workspaceKind: executionPlan.workspaceKind,
 					lastTaskId: claimedTask.task.id,
-					lastAttemptN: claimedTask.attemptN
+					lastAttemptN: claimedTask.attemptN,
+					warmRetentionSec: operations.warmRetentionSec
 				});
 				const rawExecuteTask = selected.preparedRuntime.createTaskExecutor({
-					agentName: common.agent,
+					agentName: identity.agent,
 					moltnetAgent: ctx.agent,
 					agentIdentity,
 					hostCapabilitySigner,
@@ -7109,8 +7090,8 @@ async function runPolling(opts) {
 					makeExecutionPlan: (task) => executionPlans.getOrCreate(task),
 					makeOnTurnEvent: makeTurnEventHandlerFactory(taskLogger),
 					toolPolicyLogger: taskLogger,
-					maxTurns: common.maxTurns,
-					maxBashTimeouts: common.maxBashTimeouts
+					maxTurns: profile.maxTurns,
+					maxBashTimeouts: profile.maxBashTimeouts
 				});
 				try {
 					active = {
@@ -7131,7 +7112,7 @@ async function runPolling(opts) {
 				} finally {
 					active = null;
 					executionPlans.delete(claimedTask);
-					if (executionPlan.slotKey) await slotRegistry.finishSlot(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN, slotIdentity, executionPlan.slotKey, profile.provider, profile.model, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null);
+					if (executionPlan.slotKey) await slotRegistry.finishSlot(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN, slotIdentity, executionPlan.slotKey, profile.provider, profile.model, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null, operations.warmRetentionSec);
 				}
 			}
 		});
@@ -7207,7 +7188,7 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 	const { values } = parseArgs({
 		args: argv,
 		options: {
-			...commonOptionDefs(),
+			...runtimeCommandOptionDefs(),
 			"task-id": {
 				type: "string",
 				short: "t"
@@ -7228,9 +7209,9 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 		console.error(ONCE_HELP);
 		return 1;
 	}
-	let opts;
+	let commandOptions;
 	try {
-		opts = parseCommonOptions(values);
+		commandOptions = parseRuntimeCommandOptions(values);
 	} catch (err) {
 		if (err instanceof MissingRequiredOptionError) {
 			console.error(`${err.message}\n`);
@@ -7239,6 +7220,7 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 		}
 		throw err;
 	}
+	const { identity, operations } = commandOptions;
 	if (values.sandbox) {
 		console.error("Cannot use --sandbox. Remote runtime profiles define sandbox policy.");
 		return 1;
@@ -7249,12 +7231,11 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 		bindings: cfg.credentialBindings
 	};
 	const runtimeCredentialConfig = resolveCredentialEnforcement(cfg.credentialEnforcement, credentialSources) === "off" ? null : loadRuntimeCredentialConfig(credentialSources);
-	const initialOpts = opts;
 	const explicitAgentRootDir = values["agent-root"] ? resolve(process.cwd(), values["agent-root"]) : void 0;
 	const { ctx, signingPrivateKey, agentIdentity, hostCapabilitySigner } = await (async () => {
 		let gate = "resolve_agent_context";
 		try {
-			const resolvedContext = await resolveAgentContext(initialOpts.agent, {
+			const resolvedContext = await resolveAgentContext(identity.agent, {
 				agentRootDir: explicitAgentRootDir,
 				credentialSource: cfg.credentialSource,
 				envApiUrl: cfg.apiUrl
@@ -7281,7 +7262,7 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 			});
 			gate = "resolve_agent_identity";
 			const agentIdentity = await resolveDaemonAgentIdentity({
-				agentName: initialOpts.agent,
+				agentName: identity.agent,
 				whoami,
 				credentialSource: cfg.credentialSource,
 				agentDir: resolvedContext.agentDir,
@@ -7300,9 +7281,9 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 		} catch (error) {
 			await logDaemonStartupFailure({
 				serviceName: "agent-daemon.once",
-				level: cfg.logLevel || (initialOpts.debug ? "debug" : "info"),
+				level: cfg.logLevel || (identity.debug ? "debug" : "info"),
 				gate,
-				agent: initialOpts.agent,
+				agent: identity.agent,
 				credentialSource: cfg.credentialSource,
 				error
 			});
@@ -7316,34 +7297,23 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 		teamId: values.team,
 		cwd: daemonRootDir
 	});
-	assertRuntimeAdapterSupportsProfile(runtimeAdapter, profile);
-	const preparedRuntime = attestPreparedRuntime(await runtimeAdapter.prepare({ profile }), signingPrivateKey);
-	validateRuntimeProfilePrerequisites(profile, cfg.profilePrerequisiteEnv, {
-		tools: preparedRuntime.tools,
-		executables: preparedRuntime.executables
+	const { logger, shutdown: shutdownLogger } = createRootLogger({
+		name: "agent-daemon.once",
+		level: cfg.logLevel || (identity.debug ? "debug" : "info")
 	});
-	assertGuestEnvironmentBoundary({
-		forwardEnv: profile.requiredEnv,
-		sandboxEnv: profile.sandboxConfig.env
+	const rootLogger = logger.child({
+		mode: "once",
+		agent: identity.agent,
+		provider: profile.provider,
+		model: profile.model,
+		thinkingLevel: profile.thinkingLevel,
+		temperature: profile.temperature,
+		topP: profile.topP,
+		topK: profile.topK,
+		maxOutputTokens: profile.maxOutputTokens,
+		runtimeProfileId: profile.id,
+		runtimeProfileName: profile.name
 	});
-	await ctx.agent.tasks.registerExecutorManifest(await preparedRuntime.attestor.registration());
-	opts = parseCommonOptions(values, { runtimeDefaults: {
-		leaseTtlSec: profile.leaseTtlSec,
-		heartbeatIntervalMs: profile.heartbeatIntervalMs,
-		maxBatchSize: profile.maxBatchSize,
-		maxTurns: profile.maxTurns,
-		maxBashTimeouts: profile.maxBashTimeouts,
-		warmSessionTtlSec: resolveProfileWarmSessionTtlSec(profile)
-	} });
-	const sandbox = {
-		config: profile.sandboxConfig,
-		rootDir: profile.mountPath,
-		path: profile.source
-	};
-	const piAgentDir = await resolvePiAgentDir(cfg, sandbox.rootDir, [profile]);
-	process.once("exit", piAgentDir.cleanup);
-	activatePiCodingAgentDir(piAgentDir.path, piAgentDir.env);
-	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
 	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
 	const runtimeSessionStore = createApiRuntimeSessionStore({
 		agent: ctx.agent,
@@ -7351,30 +7321,29 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 	});
 	const sourceAttemptResolver = createApiSourceAttemptResolver({ agent: ctx.agent });
 	const runtimeInstanceId = createRuntimeInstanceId();
-	const slotIdentity = {
-		agentName: opts.agent,
-		runtimeProfileId: profile.id,
-		runtimeInstanceId
-	};
-	const executionPlans = createExecutionPlanCache({
-		stateDirs,
-		slotIdentity,
-		warmSessionTtlSec: opts.warmSessionTtlSec,
-		workspacePolicy: {
-			defaultWorkspaceMode: profile.defaultWorkspaceMode,
-			allowedWorkspaceModes: profile.allowedWorkspaceModes
-		},
+	const { executionPlans, preparedRuntime, sandbox, slotIdentity, stateDirs } = await prepareRuntimeProfile({
+		agent: ctx.agent,
+		agentName: identity.agent,
+		profile,
+		prerequisiteEnv: cfg.profilePrerequisiteEnv,
+		runtimeAdapter,
+		runtimeInstanceId,
+		signingPrivateKey,
 		slotRegistry,
 		runtimeSessionStore,
-		sourceAttemptResolver
+		sourceAttemptResolver,
+		warmRetentionSec: operations.warmRetentionSec
 	});
+	const piAgentDir = await resolvePiAgentDir(cfg, sandbox.rootDir, [profile]);
+	process.once("exit", piAgentDir.cleanup);
+	activatePiCodingAgentDir(piAgentDir.path, piAgentDir.env);
 	const otelShutdown = await initWorkerOtel({
 		serviceName: "moltnet.agent-daemon.once",
 		agent: ctx.agent,
 		endpoint: cfg.otelEndpoint,
 		resourceAttributes: {
 			"moltnet.task.id": taskId,
-			"moltnet.agent.name": opts.agent,
+			"moltnet.agent.name": identity.agent,
 			"moltnet.credential.source": ctx.credentialSource,
 			"moltnet.llm.provider": profile.provider,
 			"moltnet.llm.model": profile.model,
@@ -7386,34 +7355,14 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 			"moltnet.runtime_profile.id": profile.id
 		}
 	});
-	const { logger, shutdown: shutdownLogger } = createRootLogger({
-		name: "agent-daemon.once",
-		level: cfg.logLevel || (opts.debug ? "debug" : "info")
-	});
-	const rootLogger = logger.child({
-		mode: "once",
-		agent: opts.agent,
-		provider: profile.provider,
-		model: profile.model,
-		thinkingLevel: profile.thinkingLevel,
-		temperature: profile.temperature,
-		topP: profile.topP,
-		topK: profile.topK,
-		maxOutputTokens: profile.maxOutputTokens,
-		runtimeProfileId: profile.id,
-		runtimeProfileName: profile.name
-	});
 	rootLogger.info({
 		sandbox: sandbox.path,
 		taskId,
-		leaseTtlSec: opts.leaseTtlSec,
-		heartbeatIntervalMs: opts.heartbeatIntervalMs,
-		maxTurns: opts.maxTurns,
-		maxBashTimeouts: opts.maxBashTimeouts,
-		warmSessionTtlSec: opts.warmSessionTtlSec,
+		heartbeatIntervalMs: operations.heartbeatIntervalMs,
+		maxTurns: profile.maxTurns,
+		maxBashTimeouts: profile.maxBashTimeouts,
+		warmRetentionSec: operations.warmRetentionSec,
 		profileId: profile.id,
-		profileSessionTtlSec: profile.sessionTtlSec,
-		profileWorkspaceTtlSec: profile.workspaceTtlSec,
 		piAgentDir: piAgentDir.path,
 		piAgentDirSource: piAgentDir.source
 	}, "agent-daemon.starting");
@@ -7425,7 +7374,7 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 			runtimeSlotStore: slotRegistry,
 			taskReader: ctx.agent.tasks
 		}, {
-			agentName: opts.agent,
+			agentName: identity.agent,
 			mainWorktree: resolveMainWorktree(sandbox.rootDir),
 			runtimeInstanceId,
 			runtimeProfileId: profile.id,
@@ -7471,7 +7420,7 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 	});
 	try {
 		const rawExecuteTask = preparedRuntime.createTaskExecutor({
-			agentName: opts.agent,
+			agentName: identity.agent,
 			moltnetAgent: ctx.agent,
 			agentIdentity,
 			hostCapabilitySigner,
@@ -7501,8 +7450,8 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 			makeExecutionPlan: (claimedTask) => executionPlans.getOrCreate(claimedTask),
 			onTurnEvent: makeTurnEventHandler(rootLogger, { taskId }),
 			toolPolicyLogger: rootLogger,
-			maxTurns: opts.maxTurns,
-			maxBashTimeouts: opts.maxBashTimeouts
+			maxTurns: profile.maxTurns,
+			maxBashTimeouts: profile.maxBashTimeouts
 		});
 		const executeTask = async (claimedTask, reporter) => {
 			if (runtimeCredentialConfig) await observeGovernancePlanSafely({
@@ -7559,7 +7508,8 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 				worktreeBranch: executionPlan.worktreeBranch,
 				workspaceKind: executionPlan.workspaceKind,
 				lastTaskId: claimedTask.task.id,
-				lastAttemptN: claimedTask.attemptN
+				lastAttemptN: claimedTask.attemptN,
+				warmRetentionSec: operations.warmRetentionSec
 			});
 			activeAttemptN = claimedTask.attemptN;
 			try {
@@ -7577,7 +7527,7 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 			} finally {
 				activeAttemptN = null;
 				executionPlans.delete(claimedTask);
-				if (executionPlan.slotKey) await slotRegistry.finishSlot(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN, slotIdentity, executionPlan.slotKey, profile.provider, profile.model, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null);
+				if (executionPlan.slotKey) await slotRegistry.finishSlot(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN, slotIdentity, executionPlan.slotKey, profile.provider, profile.model, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null, operations.warmRetentionSec);
 			}
 		};
 		const writeCorrelationAnchors = makePrBodyAnchorWriter({
@@ -7590,17 +7540,14 @@ async function runOnce(argv, runtimeAdapter = defaultPiDaemonAdapter) {
 				agent: ctx.agent,
 				taskId,
 				teamId: profile.teamId,
-				leaseTtlSec: opts.leaseTtlSec,
 				profileId: profile.id,
 				executorFingerprint: preparedRuntime.attestor.fingerprint
 			}),
 			makeReporter: () => new ApiTaskReporter({
 				tasks: ctx.agent.tasks,
 				teamId: profile.teamId,
-				leaseTtlSec: opts.leaseTtlSec,
-				heartbeatIntervalMs: opts.heartbeatIntervalMs,
-				maxBatchSize: opts.maxBatchSize,
-				flushIntervalMs: opts.flushIntervalMs
+				heartbeatIntervalMs: operations.heartbeatIntervalMs,
+				logger: rootLogger
 			}),
 			onTaskFinished: async (output, claimedTask) => {
 				const resolved = await slotRegistry.findLatestSlotByTaskAttempt(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN);
@@ -7867,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) {
@@ -7882,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
 		};
 	}
@@ -7952,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) {
@@ -7989,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}`;
@@ -8090,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;
@@ -8117,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
 			});
@@ -8184,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)
 	};
 }
@@ -8206,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);
@@ -8279,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" }
@@ -8288,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,
@@ -8295,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
 			};
@@ -8450,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) {
@@ -9842,6 +9923,7 @@ var RunManager = class {
 				extraArgs: ["--agent-root", agentRoot]
 			};
 		})();
+		const runtimeSettings = this.options.runtimeSettings ?? DEFAULT_LOCAL_OPERATIONAL_SETTINGS;
 		const args = [
 			...runtimeModule ? ["--runtime", runtimeModule] : [],
 			spec.mode,
@@ -9852,6 +9934,10 @@ var RunManager = class {
 			...spec.profiles.flatMap((profile) => ["--profile", profile]),
 			"--task-types",
 			spec.taskTypes.join(","),
+			"--heartbeat-interval-ms",
+			String(runtimeSettings.heartbeatIntervalMs),
+			"--warm-retention-sec",
+			String(runtimeSettings.warmRetentionSec),
 			...target.extraArgs
 		];
 		if (activation.source === "managed") {
@@ -10442,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");
@@ -10474,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({
@@ -10522,7 +10615,11 @@ var AgentServerStatusSchema = Type.Object({
 	identities: Type.Array(schemaRef(AgentServerIdentitySchema)),
 	selectedIdentity: Type.Optional(Type.String()),
 	providers: Type.Record(Type.String(), schemaRef(AgentServerProviderSchema)),
-	runs: Type.Array(schemaRef(AgentServerRunSchema))
+	runs: Type.Array(schemaRef(AgentServerRunSchema)),
+	runtimeSettings: Type.Object({
+		heartbeatIntervalMs: Type.Integer({ minimum: 0 }),
+		warmRetentionSec: Type.Integer({ minimum: 0 })
+	})
 }, { $id: "AgentServerStatus" });
 var PairingStartedSchema = Type.Object({
 	pairingId: Type.String(),
@@ -10547,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(),
@@ -10865,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" });
@@ -10996,7 +11114,8 @@ function registerStatusRoute(app, options, requirePairedOrigin) {
 			identities: identityViews(store),
 			...selected ? { selectedIdentity: selected } : {},
 			providers: options.providers.list(),
-			runs: runViews(runs)
+			runs: runViews(runs),
+			runtimeSettings: options.runtimeSettings ?? DEFAULT_LOCAL_OPERATIONAL_SETTINGS
 		};
 	});
 }
@@ -11084,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);
@@ -11489,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: {
@@ -11496,7 +11616,9 @@ async function runAgentServer(argv) {
 			"allowed-origins": { type: "string" },
 			root: { type: "string" },
 			"api-url": { type: "string" },
-			remove: { type: "boolean" }
+			"heartbeat-interval-ms": { type: "string" },
+			"warm-retention-sec": { type: "string" },
+			supervised: { type: "boolean" }
 		}
 	});
 	const port = Number.parseInt(values.port ?? (envConfig.port || `${DEFAULT_PORT}`), 10);
@@ -11507,8 +11629,8 @@ async function runAgentServer(argv) {
 	const allowedOrigins = parseAllowedOrigins(values["allowed-origins"] ?? (envConfig.allowedOrigins || DEFAULT_ALLOWED_ORIGINS));
 	const root = values.root ?? resolveAgentServerRoot({ root: envConfig.root });
 	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"
@@ -11540,7 +11662,8 @@ async function runAgentServer(argv) {
 					externalSecretProviders,
 					baseEnv: processEnvSnapshot(),
 					logger,
-					runtimeRegistry: new RuntimeRegistry(store.root)
+					runtimeRegistry: new RuntimeRegistry(store.root),
+					runtimeSettings
 				});
 				const tls = isMacos() ? await ensureTrustedLocalTls(root) : void 0;
 				const app = buildAgentServer({
@@ -11559,6 +11682,7 @@ async function runAgentServer(argv) {
 						cert: tls.cert
 					} } : {},
 					defaultApiUrl,
+					runtimeSettings,
 					...envConfig.activeIdentity ? { activeIdentity: envConfig.activeIdentity } : {},
 					version: "dev",
 					logger,
@@ -11573,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;
@@ -11594,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);
@@ -11625,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();
@@ -11656,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) {
@@ -11782,7 +11983,7 @@ async function runSyncSessions(argv) {
 	const { values } = parseArgs({
 		args: argv,
 		options: {
-			...commonOptionDefs(),
+			...identityOptionDefs(),
 			team: { type: "string" },
 			"runtime-profile-id": { type: "string" },
 			state: { type: "string" },
@@ -11795,9 +11996,9 @@ async function runSyncSessions(argv) {
 		console.error(SYNC_SESSIONS_HELP);
 		return 1;
 	}
-	let opts;
+	let identity;
 	try {
-		opts = parseCommonOptions(values);
+		identity = parseIdentityProcessOptions(values);
 	} catch (err) {
 		if (err instanceof MissingRequiredOptionError) {
 			console.error(`${err.message}\n`);
@@ -11811,7 +12012,7 @@ async function runSyncSessions(argv) {
 	const agentRootDir = resolve(process.cwd(), values["agent-root"] ?? process.cwd());
 	const explicitAgentRootDir = values["agent-root"] ? resolve(process.cwd(), values["agent-root"]) : void 0;
 	const cfg = loadConfig();
-	const ctx = await resolveAgentContext(opts.agent, {
+	const ctx = await resolveAgentContext(identity.agent, {
 		credentialSource: cfg.credentialSource,
 		envApiUrl: cfg.apiUrl,
 		agentRootDir: explicitAgentRootDir
@@ -11826,7 +12027,7 @@ async function runSyncSessions(argv) {
 		runtimeSlotStore: createApiRuntimeSlotStore({ agent: ctx.agent }),
 		taskReader: ctx.agent.tasks
 	}, {
-		agentName: opts.agent,
+		agentName: identity.agent,
 		dryRun: values["dry-run"] === true,
 		limit,
 		runtimeProfileId: values["runtime-profile-id"],
@@ -12003,7 +12204,7 @@ async function writeCache(cache) {
 }
 //#endregion
 //#region src/version.ts
-var DAEMON_VERSION = "0.57.0";
+var DAEMON_VERSION = "0.58.0";
 //#endregion
 //#region src/cli.ts
 async function runAgentDaemonCli(options) {