@themoltnet/agent-daemon 0.15.0 → 0.17.0

package/dist/main.js

@@ -9,10 +9,10 @@ import { PinoInstrumentation } from "@opentelemetry/instrumentation-pino";
 import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
 import crypto$1, { createHash } from "crypto";
 import { createHash as createHash$1 } from "node:crypto";
-import path, { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import path, { delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { parseArgs, parseEnv, promisify } from "node:util";
 import { execFile, execFileSync } from "node:child_process";
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { accessSync, constants, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
 import { DatabaseSync } from "node:sqlite";
 import { ROOT_CONTEXT, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
 import { pino, transport } from "pino";
@@ -836,8 +836,8 @@ Reset();
 *
 * Idempotent: registration is guarded by `Format.Has(...)`.
 */
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-if (!Has("uuid")) Set$1("uuid", (v) => UUID_RE.test(v));
+var UUID_RE$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+if (!Has("uuid")) Set$1("uuid", (v) => UUID_RE$1.test(v));
 if (!Has("date-time")) Set$1("date-time", (v) => !Number.isNaN(Date.parse(v)));
 //#endregion
 //#region ../../node_modules/.pnpm/typebox@1.2.8/node_modules/typebox/build/system/memory/metrics.mjs
@@ -4375,6 +4375,170 @@ function validateRubricWeights(rubric) {
 	return null;
 }
 //#endregion
+//#region ../../libs/tasks/src/runtime-profiles.ts
+var RuntimeProfileName = String$1({
+	minLength: 1,
+	maxLength: 100,
+	pattern: "^[a-zA-Z0-9][a-zA-Z0-9_-]{0,99}$"
+});
+var RuntimeProfileEnvName = String$1({
+	minLength: 1,
+	maxLength: 128,
+	pattern: "^[A-Z_][A-Z0-9_]*$"
+});
+var RuntimeProfileToolName = String$1({
+	minLength: 1,
+	maxLength: 128,
+	pattern: "^[a-zA-Z0-9._/-]+$"
+});
+var SandboxResumeCommandWhenSchema = _Object_({ workspaceMode: Optional(_Array_(Union([
+	Literal("shared_mount"),
+	Literal("dedicated_worktree"),
+	Literal("scratch_mount")
+]), {
+	minItems: 1,
+	maxItems: 3
+})) }, { additionalProperties: false });
+var RuntimeProfileSandboxResumeCommand = Union([String$1({
+	minLength: 1,
+	maxLength: 4096
+}), _Object_({
+	run: String$1({
+		minLength: 1,
+		maxLength: 4096
+	}),
+	when: Optional(SandboxResumeCommandWhenSchema),
+	retries: Optional(Integer({
+		minimum: 0,
+		maximum: 5
+	})),
+	retryBackoffMs: Optional(Integer({
+		minimum: 0,
+		maximum: 6e4
+	}))
+}, { additionalProperties: false })]);
+var RuntimeProfileSandbox = _Object_({
+	snapshot: Optional(_Object_({
+		setupCommands: Optional(_Array_(String$1({
+			minLength: 1,
+			maxLength: 4096
+		}), { maxItems: 20 })),
+		allowedHosts: Optional(_Array_(String$1({
+			minLength: 1,
+			maxLength: 255
+		}), { maxItems: 50 })),
+		overlaySize: Optional(String$1({
+			minLength: 2,
+			maxLength: 16,
+			pattern: "^[0-9]+[KMGTP]?$"
+		}))
+	}, { additionalProperties: false })),
+	resumeCommands: Optional(_Array_(RuntimeProfileSandboxResumeCommand, { maxItems: 30 })),
+	vfs: Optional(_Object_({
+		shadow: Optional(_Array_(String$1({
+			minLength: 1,
+			maxLength: 255
+		}), { maxItems: 100 })),
+		shadowMode: Optional(Union([Literal("deny"), Literal("tmpfs")]))
+	}, { additionalProperties: false })),
+	env: Optional(Record(RuntimeProfileEnvName, String$1({ maxLength: 4096 }))),
+	hostExec: Optional(_Object_({ autoApprove: Optional(Literal(false)) }, { additionalProperties: false })),
+	resources: Optional(_Object_({
+		memory: Optional(String$1({
+			minLength: 2,
+			maxLength: 16,
+			pattern: "^[0-9]+[KMG]?$"
+		})),
+		cpus: Optional(Integer({
+			minimum: 1,
+			maximum: 32
+		}))
+	}, { additionalProperties: false }))
+}, {
+	$id: "RuntimeProfileSandbox",
+	additionalProperties: false
+});
+var RuntimeProfileContext = _Object_({
+	slug: String$1({
+		minLength: 1,
+		maxLength: 64,
+		pattern: "^[a-zA-Z0-9_-]+$"
+	}),
+	binding: Union([
+		Literal("skill"),
+		Literal("context_inline"),
+		Literal("prompt_prefix"),
+		Literal("user_inline")
+	]),
+	content: String$1({
+		minLength: 1,
+		maxLength: 65536
+	})
+}, {
+	$id: "RuntimeProfileContext",
+	additionalProperties: false
+});
+var RuntimeProfileRef = _Object_({ profileId: String$1({ format: "uuid" }) }, {
+	$id: "RuntimeProfileRef",
+	additionalProperties: false
+});
+var RuntimeProfileLeaseTtlSec = Integer({
+	minimum: 1,
+	maximum: 86400
+});
+var RuntimeProfileHeartbeatIntervalMs = Integer({
+	minimum: 0,
+	maximum: 36e5
+});
+var RuntimeProfileMaxBatchSize = Integer({
+	minimum: 1,
+	maximum: 1e3
+});
+_Object_({
+	id: String$1({ format: "uuid" }),
+	teamId: String$1({ format: "uuid" }),
+	name: RuntimeProfileName,
+	description: Union([String$1({ maxLength: 4096 }), Null()]),
+	provider: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	model: String$1({
+		minLength: 1,
+		maxLength: 200
+	}),
+	runtimeKind: Literal("gondolin_pi"),
+	sandbox: RuntimeProfileSandbox,
+	sessionStorageMode: Literal("local"),
+	workspaceStorageMode: Literal("local"),
+	sessionTtlSec: Integer({
+		minimum: 1,
+		maximum: 86400
+	}),
+	workspaceTtlSec: Integer({
+		minimum: 1,
+		maximum: 86400
+	}),
+	leaseTtlSec: RuntimeProfileLeaseTtlSec,
+	heartbeatIntervalMs: RuntimeProfileHeartbeatIntervalMs,
+	maxBatchSize: RuntimeProfileMaxBatchSize,
+	requiredEnv: _Array_(RuntimeProfileEnvName, { maxItems: 100 }),
+	requiredTools: _Array_(RuntimeProfileToolName, { maxItems: 100 }),
+	context: _Array_(RuntimeProfileContext, { maxItems: 5 }),
+	revision: Integer({ minimum: 1 }),
+	definitionCid: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	createdByAgentId: Union([String$1({ format: "uuid" }), Null()]),
+	createdByHumanId: Union([String$1({ format: "uuid" }), Null()]),
+	createdAt: String$1({ format: "date-time" }),
+	updatedAt: String$1({ format: "date-time" })
+}, {
+	$id: "RuntimeProfile",
+	additionalProperties: false
+});
+//#endregion
 //#region ../../libs/tasks/src/success-criteria.ts
 /**
 * SuccessCriteria — proposer-stated acceptance criteria, evaluated in two
@@ -8967,6 +9131,7 @@ var TaskAttemptStatus = Union([
 	Literal("completed"),
 	Literal("failed"),
 	Literal("cancelled"),
+	Literal("aborted"),
 	Literal("timed_out")
 ], { $id: "TaskAttemptStatus" });
 var ExecutorTrustLevel = Union([
@@ -8975,14 +9140,6 @@ var ExecutorTrustLevel = Union([
 	Literal("releaseVerifiedTool"),
 	Literal("sandboxAttested")
 ], { $id: "ExecutorTrustLevel" });
-/** Identifies a (provider, model) daemon pair allowed to claim a task. */
-var ExecutorRef = _Object_({
-	provider: String$1({ minLength: 1 }),
-	model: String$1({ minLength: 1 })
-}, {
-	$id: "ExecutorRef",
-	additionalProperties: false
-});
 var OutputKind = Union([Literal("artifact"), Literal("judgment")], { $id: "OutputKind" });
 var TaskMessageKind = Union([
 	Literal("text_delta"),
@@ -9127,7 +9284,7 @@ _Object_({
 	acceptedAttemptN: Union([Number$1(), Null()]),
 	claimCondition: Union([Unsafe(Ref$2("ClaimCondition")), Null()]),
 	requiredExecutorTrustLevel: ExecutorTrustLevel,
-	allowedExecutors: _Array_(ExecutorRef, { maxItems: 16 }),
+	allowedProfiles: _Array_(RuntimeProfileRef, { maxItems: 16 }),
 	status: TaskStatus,
 	queuedAt: IsoTimestamp,
 	completedAt: Union([IsoTimestamp, Null()]),
@@ -9223,15 +9380,23 @@ _Object_({
 //#region src/lib/help.ts
 var COMMON_REQUIRED_FLAGS = `\
   -a, --agent <name>          MoltNet agent identity. Reads credentials
-                              from <repo-root>/.moltnet/<name>/moltnet.json.
+                              from <repo-root>/.moltnet/<name>/moltnet.json.`;
+var COMMON_MODEL_FLAGS = `\
   -p, --provider <id>         LLM provider id (e.g. anthropic, openai-codex).
   -m, --model <id>            LLM model id for the provider (e.g.
-                              claude-sonnet-4-5, gpt-5.3-codex).`;
+                              claude-sonnet-4-5, gpt-5.3-codex). Required
+                              unless --profile is set.`;
 var COMMON_OPTIONAL_FLAGS = `\
   --sandbox <path>            Path to sandbox.json. Default: search up from
                               the daemon's CWD until found. The directory
                               containing sandbox.json is also used as the
-                              VM mountPath.
+                              VM mountPath. Cannot be used with --profile.
+  --profile <uuid|name>       Remote runtime profile. When set, provider,
+                              model, and sandbox policy come from the
+                              profile; task listing/claiming is restricted
+                              to unrestricted tasks plus tasks allowing this
+                              profile. requiredEnv/requiredTools are checked
+                              before claiming. Name lookup is team-scoped.
   --lease-ttl-sec <n>         Sliding liveness window. Silence longer than
                               this ends the attempt with lease_expired.
                               Default: 300.
@@ -9249,7 +9414,8 @@ var COMMON_OPTIONAL_FLAGS = `\
   --warm-session-ttl-sec <n>  Retain resumable daemon slots (Pi sessions +
                               reusable worktrees) in local daemon state for
                               this many seconds after use. 0 = disable reuse.
-                              Default: 1800.
+                              Default: 1800, or min(profile session/workspace
+                              TTL) when --profile is set.
   --debug                     Verbose logging: also log successful list/claim
                               outcomes (candidate counts, claim attempts).`;
 var REGISTERED_TASK_TYPES = Object.keys(BUILT_IN_TASK_TYPES).sort();
@@ -9272,9 +9438,10 @@ Run \`agent-daemon <command> --help\` for command-specific flags.
 
 Prerequisites (all subcommands):
   - <repo-root>/.moltnet/<agent>/moltnet.json — credentials (see --agent)
-  - sandbox.json — Gondolin snapshot config; resolved by searching up
-    from CWD, or pass --sandbox <path>. Its containing directory is the
-    VM mountPath.
+  - sandbox.json or --profile — local sandbox config is resolved by
+    searching up from CWD, or pass --sandbox <path>. With --profile, the
+    remote runtime profile supplies provider/model/sandbox policy and CWD
+    is used as the VM mountPath.
 
 Registered task types: ${knownTaskTypesList()}`;
 var POLL_HELP = `\
@@ -9287,6 +9454,7 @@ Required:
   --team <uuid>               Team whose queue to serve. The daemon must be
                               a member of this team (canAccessTeam permit).
 ${COMMON_REQUIRED_FLAGS}
+${COMMON_MODEL_FLAGS}
 
 Optional:
   --task-types <csv>          Whitelist of task types to claim. Default:
@@ -9317,6 +9485,7 @@ Required:
   -t, --task-id <uuid>        Task to claim and execute. Must already be
                               in 'queued' status.
 ${COMMON_REQUIRED_FLAGS}
+${COMMON_MODEL_FLAGS}
 
 Optional:
 ${COMMON_OPTIONAL_FLAGS}
@@ -9342,6 +9511,7 @@ sleeps and retries forever).
 Required:
   --team <uuid>               Team whose queue to drain.
 ${COMMON_REQUIRED_FLAGS}
+${COMMON_MODEL_FLAGS}
 
 Optional:
   --task-types <csv>          Whitelist. Known types: ${knownTaskTypesList()}
@@ -24318,6 +24488,9 @@ var ApiTaskReporter = class {
 	get cancelReason() {
 		return this.observedCancelReason;
 	}
+	requestCancel(reason) {
+		this.abortForCancel(reason);
+	}
 	async open(ctx) {
 		if (this.heartbeatTimer) {
 			clearInterval(this.heartbeatTimer);
@@ -24500,13 +24673,15 @@ var ApiTaskReporter = class {
 	async sendHeartbeat() {
 		const body = this.opts.leaseTtlSec ? { leaseTtlSec: this.opts.leaseTtlSec } : {};
 		const response = await this.opts.tasks.heartbeat(this.taskId, this.attemptN, body);
-		if (response?.cancelled && !this.cancelController.signal.aborted) {
-			this.observedCancelReason = response.cancelReason ?? null;
-			this.cancelController.abort(/* @__PURE__ */ new Error(`Task cancelled by proposer${this.observedCancelReason ? `: ${this.observedCancelReason}` : ""}`));
-			if (this.heartbeatTimer) {
-				clearInterval(this.heartbeatTimer);
-				this.heartbeatTimer = null;
-			}
+		if (response?.cancelled) this.abortForCancel(response.cancelReason ?? null);
+	}
+	abortForCancel(reason) {
+		if (this.cancelController.signal.aborted) return;
+		this.observedCancelReason = reason;
+		this.cancelController.abort(/* @__PURE__ */ new Error(`Task cancelled${this.observedCancelReason ? `: ${this.observedCancelReason}` : ""}`));
+		if (this.heartbeatTimer) {
+			clearInterval(this.heartbeatTimer);
+			this.heartbeatTimer = null;
 		}
 	}
 };
@@ -24519,6 +24694,7 @@ var AgentRuntime = class {
 		currentTaskId: null
 	};
 	stopRequested = false;
+	currentReporter = null;
 	logger;
 	constructor(opts) {
 		this.opts = opts;
@@ -24547,6 +24723,7 @@ var AgentRuntime = class {
 				});
 				taskLogger.info({}, "agent-runtime.task_claimed");
 				const reporter = this.opts.makeReporter(claimedTask);
+				this.currentReporter = reporter;
 				const taskCtx = Object.keys(claimedTask.traceHeaders).length ? propagation.extract(ROOT_CONTEXT, claimedTask.traceHeaders) : context.active();
 				const taskStart = Date.now();
 				let output;
@@ -24604,16 +24781,19 @@ var AgentRuntime = class {
 				}
 				this.status.tasksProcessed += 1;
 				this.status.currentTaskId = null;
+				this.currentReporter = null;
 			}
 		} finally {
+			this.currentReporter = null;
 			await this.opts.source.close();
 			this.status.state = "stopped";
 		}
 		return outputs;
 	}
 	/** Request cooperative shutdown. Safe from signal handlers. */
-	stop() {
+	stop(reason) {
 		this.stopRequested = true;
+		if (reason !== void 0) this.currentReporter?.requestCancel?.(reason);
 	}
 };
 //#endregion
@@ -24625,8 +24805,11 @@ var ApiTaskSource = class {
 	}
 	async claim() {
 		if (this.claimed) return null;
-		const { agent, taskId, leaseTtlSec } = this.opts;
-		const result = await agent.tasks.claim(taskId, leaseTtlSec ? { leaseTtlSec } : {});
+		const { agent, taskId, leaseTtlSec, profileId } = this.opts;
+		const result = await agent.tasks.claim(taskId, {
+			...leaseTtlSec ? { leaseTtlSec } : {},
+			...profileId ? { profileId } : {}
+		});
 		this.claimed = true;
 		return {
 			task: result.task,
@@ -26271,6 +26454,124 @@ var updateRenderedPack = (options) => (options.client ?? client).patch({
 	}
 });
 /**
+* List runtime profiles for the active team context.
+*/
+var listRuntimeProfiles = (options) => (options?.client ?? client).get({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/runtime-profiles",
+	...options
+});
+/**
+* Create a runtime profile for the active team context.
+*/
+var createRuntimeProfile = (options) => (options?.client ?? client).post({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/runtime-profiles",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options?.headers
+	}
+});
+/**
+* Delete one runtime profile.
+*/
+var deleteRuntimeProfile = (options) => (options.client ?? client).delete({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/runtime-profiles/{profileId}",
+	...options
+});
+/**
+* Get one runtime profile.
+*/
+var getRuntimeProfile = (options) => (options.client ?? client).get({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/runtime-profiles/{profileId}",
+	...options
+});
+/**
+* Update one runtime profile.
+*/
+var updateRuntimeProfile = (options) => (options.client ?? client).patch({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/runtime-profiles/{profileId}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
 * List tasks for a team with optional filters.
 */
 var listTasks = (options) => (options.client ?? client).get({
@@ -26385,6 +26686,32 @@ var listTaskAttempts = (options) => (options.client ?? client).get({
 	...options
 });
 /**
+* Claimant intentionally abandons this attempt (e.g. daemon shutdown). The attempt becomes aborted and the task requeues for another claim (or fails when retries are exhausted). Does NOT cancel the task.
+*/
+var abortTaskAttempt = (options) => (options.client ?? client).post({
+	security: [
+		{
+			scheme: "bearer",
+			type: "http"
+		},
+		{
+			name: "X-Moltnet-Session-Token",
+			type: "apiKey"
+		},
+		{
+			in: "cookie",
+			name: "ory_kratos_session",
+			type: "apiKey"
+		}
+	],
+	url: "/tasks/{id}/attempts/{n}/abort",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
 * Mark an attempt as completed with output.
 */
 var completeTask = (options) => (options.client ?? client).post({
@@ -28517,6 +28844,54 @@ function createRecoveryNamespace(context) {
 	};
 }
 //#endregion
+//#region ../../libs/sdk/src/namespaces/runtime-profiles.ts
+function createRuntimeProfilesNamespace(context) {
+	const { client, auth } = context;
+	return {
+		async list(options) {
+			return unwrapResult(await listRuntimeProfiles({
+				client,
+				auth,
+				headers: teamHeaders(options)
+			}));
+		},
+		async create(body, options) {
+			return unwrapResult(await createRuntimeProfile({
+				client,
+				auth,
+				headers: teamHeaders(options),
+				body
+			}));
+		},
+		async get(profileId) {
+			return unwrapResult(await getRuntimeProfile({
+				client,
+				auth,
+				path: { profileId }
+			}));
+		},
+		async update(profileId, body) {
+			return unwrapResult(await updateRuntimeProfile({
+				client,
+				auth,
+				path: { profileId },
+				body
+			}));
+		},
+		async delete(profileId) {
+			const result = await deleteRuntimeProfile({
+				client,
+				auth,
+				path: { profileId }
+			});
+			if (result.error) unwrapResult(result);
+		}
+	};
+}
+function teamHeaders(options) {
+	return options?.teamId ? { "x-moltnet-team-id": options.teamId } : void 0;
+}
+//#endregion
 //#region ../../libs/sdk/src/namespaces/signing-requests.ts
 function createSigningRequestsNamespace(context) {
 	const { client, auth } = context;
@@ -28637,6 +29012,17 @@ function createTasksNamespace(context) {
 				body
 			}));
 		},
+		async abortAttempt(id, n, body) {
+			return unwrapResult(await abortTaskAttempt({
+				client,
+				auth,
+				path: {
+					id,
+					n
+				},
+				body
+			}));
+		},
 		async cancel(id, body) {
 			return unwrapResult(await cancelTask({
 				client,
@@ -28820,6 +29206,7 @@ function createAgent(options) {
 		legreffier: createLegreffierNamespace(context),
 		problems: createProblemsNamespace(context),
 		teams: createTeamsNamespace(context),
+		runtimeProfiles: createRuntimeProfilesNamespace(context),
 		tasks: createTasksNamespace(context),
 		client,
 		getToken: () => tokenManager.getToken()
@@ -30908,7 +31295,6 @@ var PollingApiTaskSource = class {
 		this.minBackoffMs = opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
 		this.maxBackoffMs = opts.maxPollIntervalMs ?? DEFAULT_MAX_POLL_INTERVAL_MS;
 		if (this.maxBackoffMs < this.minBackoffMs) throw new Error(`PollingApiTaskSource: maxPollIntervalMs (${this.maxBackoffMs}) must be >= pollIntervalMs (${this.minBackoffMs})`);
-		if (Boolean(opts.provider) !== Boolean(opts.model)) throw new Error("PollingApiTaskSource: provider and model must be set together");
 		this.listLimit = opts.listLimit ?? DEFAULT_LIST_LIMIT;
 		this.currentBackoffMs = this.minBackoffMs;
 		this.logger = (opts.logger ?? pino({ name: "polling-api-source" })).child({ teamId: opts.teamId });
@@ -30951,10 +31337,7 @@ var PollingApiTaskSource = class {
 				teamId: this.opts.teamId,
 				status: "queued",
 				...taskTypes ? { taskTypes } : {},
-				...this.opts.provider && this.opts.model ? {
-					provider: this.opts.provider,
-					model: this.opts.model
-				} : {},
+				...this.opts.profileId ? { profileId: this.opts.profileId } : {},
 				...cursor ? { cursor } : {},
 				limit: this.listLimit
 			});
@@ -30969,9 +31352,9 @@ var PollingApiTaskSource = class {
 				if (this.opts.taskTypes && this.opts.taskTypes.length > 0 && !this.opts.taskTypes.includes(item.taskType)) continue;
 				if (this.opts.diaryIds && this.opts.diaryIds.length > 0 && (item.diaryId === null || !this.opts.diaryIds.includes(item.diaryId))) continue;
 				if (this.opts.slotRegistry && !await isContinuationClaimableByThisDaemon(item, this.opts.slotRegistry)) continue;
-				if (this.opts.provider && this.opts.model) {
-					const allowed = item.allowedExecutors ?? [];
-					if (allowed.length > 0 && !allowed.some((e) => e.provider === this.opts.provider && e.model === this.opts.model)) continue;
+				if (this.opts.profileId) {
+					const allowed = item.allowedProfiles ?? [];
+					if (allowed.length > 0 && !allowed.some((p) => p.profileId === this.opts.profileId)) continue;
 				}
 				if (item.status !== "queued") continue;
 				seen.add(item.id);
@@ -30994,7 +31377,10 @@ var PollingApiTaskSource = class {
 		for (const task of candidates) {
 			if (this.aborted()) return null;
 			try {
-				const result = await this.opts.agent.tasks.claim(task.id, { leaseTtlSec: this.opts.leaseTtlSec });
+				const result = await this.opts.agent.tasks.claim(task.id, {
+					leaseTtlSec: this.opts.leaseTtlSec,
+					...this.opts.profileId ? { profileId: this.opts.profileId } : {}
+				});
 				if (this.opts.debug) this.logger.debug({
 					taskId: result.task.id,
 					taskType: result.task.taskType,
@@ -32128,6 +32514,63 @@ function pruneOldSnapshots(maxCached, currentDir) {
 	});
 }
 //#endregion
+//#region ../../libs/pi-extension/src/abort-utils.ts
+function throwIfAborted(signal, label) {
+	if (!signal?.aborted) return;
+	throw abortError(label, signal);
+}
+function abortError(label, signal) {
+	const reason = signal.reason;
+	const suffix = reason instanceof Error ? reason.message : reason === void 0 ? "aborted" : String(reason);
+	const err = /* @__PURE__ */ new Error(`${label} aborted: ${suffix}`);
+	err.name = "AbortError";
+	return err;
+}
+function cleanupLateResource(resourcePromise, opts) {
+	resourcePromise.then(async (resource) => {
+		try {
+			await opts.cleanup(resource);
+		} catch (err) {
+			opts.onCleanupError?.(err);
+		}
+	}, () => {});
+}
+async function abortableResource(opts) {
+	const { signal } = opts;
+	if (!signal) return opts.promise;
+	throwIfAborted(signal, opts.label);
+	const resourcePromise = Promise.resolve(opts.promise);
+	const abortPromise = new Promise((_, reject) => {
+		const abort = () => {
+			cleanupLateResource(resourcePromise, opts);
+			reject(abortError(opts.label, signal));
+		};
+		signal.addEventListener("abort", abort, { once: true });
+		resourcePromise.then(() => signal.removeEventListener("abort", abort), () => signal.removeEventListener("abort", abort));
+	});
+	return Promise.race([resourcePromise, abortPromise]);
+}
+async function delay(ms, signal, label) {
+	if (!signal) {
+		await new Promise((resolve) => {
+			setTimeout(resolve, ms);
+		});
+		return;
+	}
+	throwIfAborted(signal, label);
+	await new Promise((resolve, reject) => {
+		const listener = () => {
+			clearTimeout(timeout);
+			reject(abortError(label, signal));
+		};
+		const timeout = setTimeout(() => {
+			signal.removeEventListener("abort", listener);
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", listener, { once: true });
+	});
+}
+//#endregion
 //#region ../../libs/pi-extension/src/vm-manager.ts
 /**
 * Memory-backed VFS mount used by the daemon to inject task-context
@@ -32244,23 +32687,33 @@ var BASE_ALLOWED_HOSTS = [
 * surface immediately rather than fall through to cryptic agent
 * errors later.
 */
-async function vmRun(vm, label, command) {
+async function vmRun(vm, label, command, signal) {
 	const wrapped = `set -eu\nset -o pipefail\n${command}`;
+	throwIfAborted(signal, `resume step "${label}"`);
 	const r = await vm.exec([
 		"sh",
 		"-c",
 		wrapped
-	]);
+	], { signal });
 	if (r.exitCode !== 0) {
 		const tail = [r.stderr, r.stdout].filter(Boolean).join("\n").slice(-800);
 		throw new Error(`resume step "${label}" failed (exit ${r.exitCode}):\n${tail}`);
 	}
 }
+function nonErrorMessage(err) {
+	if (typeof err === "string") return err;
+	try {
+		return JSON.stringify(err) ?? "unknown error";
+	} catch {
+		return "unknown error";
+	}
+}
 /**
 * Resume a VM from a checkpoint, inject credentials, configure egress +
 * TLS. Returns the managed VM handle.
 */
 async function resumeVm(config) {
+	throwIfAborted(config.signal, "VM resume");
 	const mainRepo = findMainWorktree();
 	const agentDir = path.join(mainRepo, ".moltnet", config.agentName);
 	const guestWorkspace = path.resolve(config.mountPath);
@@ -32304,24 +32757,33 @@ async function resumeVm(config) {
 	};
 	const resources = config.sandboxConfig?.resources;
 	const workspaceMode = config.workspaceMode ?? "shared_mount";
-	const vm = await VmCheckpoint.load(config.checkpointPath).resume({
-		httpHooks,
-		env: vmEnv,
-		...resources?.memory && { memory: resources.memory },
-		...resources?.cpus && { cpus: resources.cpus },
-		vfs: { mounts: {
-			[guestWorkspace]: workspaceProvider,
-			[GUEST_TASK_SKILLS_MOUNT]: new MemoryProvider()
-		} }
+	const vm = await abortableResource({
+		promise: VmCheckpoint.load(config.checkpointPath).resume({
+			httpHooks,
+			env: vmEnv,
+			...resources?.memory && { memory: resources.memory },
+			...resources?.cpus && { cpus: resources.cpus },
+			vfs: { mounts: {
+				[guestWorkspace]: workspaceProvider,
+				[GUEST_TASK_SKILLS_MOUNT]: new MemoryProvider()
+			} }
+		}),
+		signal: config.signal,
+		label: "VM resume",
+		cleanup: (resumedVm) => resumedVm.close(),
+		onCleanupError: (err) => {
+			const message = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`[vm] aborted resume late vm.close() failed: ${message}\n`);
+		}
 	});
 	try {
-		await vm.exec(`sh -c '
+		await vmRun(vm, "TLS certificates", `
     cp /etc/gondolin/mitm/ca.crt /usr/local/share/ca-certificates/gondolin-mitm.crt
     update-ca-certificates 2>/dev/null
     cat /etc/gondolin/mitm/ca.crt >> /etc/ssl/certs/ca-certificates.crt
-  '`);
-		await vmRun(vm, "DNS resolvers", `printf 'nameserver 8.8.8.8\\nnameserver 1.1.1.1\\n' > /etc/resolv.conf`);
-		await vmRun(vm, "git safe.directory", `git config --system --add safe.directory '*'`);
+  `, config.signal);
+		await vmRun(vm, "DNS resolvers", `printf 'nameserver 8.8.8.8\\nnameserver 1.1.1.1\\n' > /etc/resolv.conf`, config.signal);
+		await vmRun(vm, "git safe.directory", `git config --system --add safe.directory '*'`, config.signal);
 		for (const [i, entry] of (config.sandboxConfig?.resumeCommands ?? []).entries()) {
 			if (!shouldRunResumeCommand(entry, { workspaceMode })) continue;
 			const { run, retries, backoffMs } = typeof entry === "string" ? {
@@ -32336,34 +32798,67 @@ async function resumeVm(config) {
 			const label = `resumeCommands[${i}]`;
 			let lastErr;
 			for (let attempt = 0; attempt <= retries; attempt++) try {
-				await vmRun(vm, label, run);
+				await vmRun(vm, label, run, config.signal);
 				lastErr = void 0;
 				break;
 			} catch (err) {
 				lastErr = err;
 				if (attempt === retries) break;
-				await new Promise((resolve) => {
-					setTimeout(resolve, (attempt + 1) * backoffMs);
-				});
+				await delay((attempt + 1) * backoffMs, config.signal, label);
 			}
-			if (lastErr) throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+			if (lastErr) throw lastErr instanceof Error ? lastErr : new Error(nonErrorMessage(lastErr));
 		}
 		const vmSshDir = `${vmAgentDir}/ssh`;
-		await vm.exec(`mkdir -p ${vmAgentDir}/ssh /home/agent/.pi/agent`);
-		if (creds.piAuthJson !== null) await vm.fs.writeFile("/home/agent/.pi/agent/auth.json", creds.piAuthJson, { mode: 384 });
+		await vm.exec(`mkdir -p ${vmAgentDir}/ssh /home/agent/.pi/agent`, { signal: config.signal });
+		if (creds.piAuthJson !== null) await vm.fs.writeFile("/home/agent/.pi/agent/auth.json", creds.piAuthJson, {
+			mode: 384,
+			signal: config.signal
+		});
 		const vmMoltnetJson = rewriteMoltnetJsonPaths(creds.moltnetJson, vmAgentDir, vmSshDir, creds.githubAppPemFilename);
-		await vm.fs.writeFile(`${vmAgentDir}/moltnet.json`, vmMoltnetJson, { mode: 384 });
-		await vm.fs.writeFile(`${vmAgentDir}/env`, creds.agentEnvRaw, { mode: 384 });
+		await vm.fs.writeFile(`${vmAgentDir}/moltnet.json`, vmMoltnetJson, {
+			mode: 384,
+			signal: config.signal
+		});
+		await vm.fs.writeFile(`${vmAgentDir}/env`, creds.agentEnvRaw, {
+			mode: 384,
+			signal: config.signal
+		});
 		if (creds.gitconfig) {
 			const vmSigningKey = `${vmSshDir}/id_ed25519`;
 			const vmGitconfig = creds.gitconfig.replace(/signingKey\s*=\s*.+/g, `signingKey = ${vmSigningKey}`);
-			await vm.fs.writeFile(`${vmAgentDir}/gitconfig`, vmGitconfig, { mode: 420 });
+			await vm.fs.writeFile(`${vmAgentDir}/gitconfig`, vmGitconfig, {
+				mode: 420,
+				signal: config.signal
+			});
 		}
-		if (creds.sshPrivateKey) await vm.fs.writeFile(`${vmSshDir}/id_ed25519`, creds.sshPrivateKey, { mode: 384 });
-		if (creds.sshPublicKey) await vm.fs.writeFile(`${vmSshDir}/id_ed25519.pub`, creds.sshPublicKey, { mode: 420 });
-		if (creds.allowedSigners) await vm.fs.writeFile(`${vmSshDir}/allowed_signers`, creds.allowedSigners, { mode: 420 });
-		if (creds.githubAppPem && creds.githubAppPemFilename) await vm.fs.writeFile(`${vmAgentDir}/${creds.githubAppPemFilename}`, creds.githubAppPem, { mode: 384 });
-		await vm.exec("chown -R agent:agent /home/agent/.pi /home/agent/.moltnet");
+		if (creds.sshPrivateKey) await vm.fs.writeFile(`${vmSshDir}/id_ed25519`, creds.sshPrivateKey, {
+			mode: 384,
+			signal: config.signal
+		});
+		if (creds.sshPublicKey) await vm.fs.writeFile(`${vmSshDir}/id_ed25519.pub`, creds.sshPublicKey, {
+			mode: 420,
+			signal: config.signal
+		});
+		if (creds.allowedSigners) await vm.fs.writeFile(`${vmSshDir}/allowed_signers`, creds.allowedSigners, {
+			mode: 420,
+			signal: config.signal
+		});
+		if (creds.githubAppPem && creds.githubAppPemFilename) await vm.fs.writeFile(`${vmAgentDir}/${creds.githubAppPemFilename}`, creds.githubAppPem, {
+			mode: 384,
+			signal: config.signal
+		});
+		await vm.exec("chown -R agent:agent /home/agent/.pi /home/agent/.moltnet", { signal: config.signal });
+		const gitCredHelperPath = `${vmSshDir}/git-credential-moltnet`;
+		const credHelperScript = `#!/bin/sh
+echo "username=x-access-token"
+echo "password=$(moltnet github token --credentials ${vmSshDir}/moltnet.json)"
+`;
+		await vm.fs.writeFile(gitCredHelperPath, credHelperScript, {
+			mode: 493,
+			signal: config.signal
+		});
+		await vmRun(vm, "git credential helper", `git config --global credential.helper ${gitCredHelperPath} && \
+       git config --global url."https://github.com/".insteadOf "git@github.com:"`, config.signal);
 		return {
 			vm,
 			credentials: creds,
@@ -33616,6 +34111,20 @@ async function executePiTask(claimedTask, reporter, opts) {
 			retryable: false
 		}
 	});
+	const makeCancelledOutput = (message) => ({
+		taskId: task.id,
+		attemptN,
+		status: "cancelled",
+		output: null,
+		outputCid: null,
+		usage: finalUsage,
+		durationMs: Date.now() - startTime,
+		error: {
+			code: "task_cancelled",
+			message,
+			retryable: false
+		}
+	});
 	let onTurnEvent;
 	if (opts.makeOnTurnEvent) try {
 		onTurnEvent = opts.makeOnTurnEvent(claimedTask);
@@ -33678,10 +34187,15 @@ async function executePiTask(claimedTask, reporter, opts) {
 				mountPath,
 				workspaceMode: workspace.mode,
 				extraAllowedHosts: opts.extraAllowedHosts,
-				sandboxConfig
+				sandboxConfig,
+				signal: reporter.cancelSignal
 			});
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
+			if (reporter.cancelSignal.aborted) {
+				await emitError("vm_resume", message, { cancelled: true });
+				return makeCancelledOutput(reporter.cancelReason ?? "Task cancelled during VM resume.");
+			}
 			await emitError("vm_resume", message);
 			return makeFailedOutput("vm_resume_failed", message);
 		}
@@ -34269,7 +34783,9 @@ function loadConfig() {
 	return {
 		agentDaemonStateDatabaseUrl: process.env["MOLTNET_AGENT_DAEMON_STATE_DATABASE_URL"] ?? "",
 		otelEndpoint: process.env["MOLTNET_OTEL_ENDPOINT"] ?? "",
-		logLevel: process.env["LOG_LEVEL"] ?? ""
+		logLevel: process.env["LOG_LEVEL"] ?? "",
+		profilePrerequisiteEnv: process.env,
+		profilePrerequisitePath: process.env.PATH ?? ""
 	};
 }
 //#endregion
@@ -34697,13 +35213,27 @@ function createRootLogger(options) {
 		target: "pino-pretty",
 		options: { colorize: true }
 	}) : null;
+	let transportClosed = prettyTransport === null;
+	let shutdownStarted = false;
+	prettyTransport?.on("close", () => {
+		transportClosed = true;
+	});
+	prettyTransport?.on("error", (err) => {
+		transportClosed = true;
+		process.stderr.write(`[pino] transport error: ` + (err instanceof Error ? err.message : String(err)) + "\n");
+	});
 	const logger = pino(options, prettyTransport ?? void 0);
 	const shutdown = async () => {
-		if (!prettyTransport) return;
-		logger.flush();
+		if (!prettyTransport || shutdownStarted || transportClosed) return;
+		shutdownStarted = true;
+		try {
+			logger.flush();
+		} catch (err) {
+			process.stderr.write(`[pino] logger flush failed: ` + (err instanceof Error ? err.message : String(err)) + "\n");
+		}
 		try {
 			prettyTransport.end();
-			await once(prettyTransport, "close");
+			if (!transportClosed) await once(prettyTransport, "close");
 		} catch (err) {
 			process.stderr.write(`[pino] transport teardown failed: ` + (err instanceof Error ? err.message : String(err)) + "\n");
 		}
@@ -34731,22 +35261,29 @@ var MissingRequiredOptionError = class extends Error {
 		this.name = "MissingRequiredOptionError";
 	}
 };
-function parseCommonOptions(args) {
+function parseCommonOptions(args, options = {}) {
+	const requireProviderModel = options.requireProviderModel ?? true;
+	const runtimeDefaults = {
+		leaseTtlSec: options.runtimeDefaults?.leaseTtlSec ?? DEFAULTS.leaseTtlSec,
+		heartbeatIntervalMs: options.runtimeDefaults?.heartbeatIntervalMs ?? DEFAULTS.heartbeatIntervalMs,
+		maxBatchSize: options.runtimeDefaults?.maxBatchSize ?? DEFAULTS.maxBatchSize,
+		warmSessionTtlSec: options.runtimeDefaults?.warmSessionTtlSec ?? DEFAULTS.warmSessionTtlSec
+	};
 	if (!args.agent) throw new MissingRequiredOptionError("agent");
-	if (!args.provider) throw new MissingRequiredOptionError("provider");
-	if (!args.model) throw new MissingRequiredOptionError("model");
+	if (requireProviderModel && !args.provider) throw new MissingRequiredOptionError("provider");
+	if (requireProviderModel && !args.model) throw new MissingRequiredOptionError("model");
 	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,
-		provider: args.provider,
-		model: args.model,
-		leaseTtlSec: parsePositiveInt(args["lease-ttl-sec"], "lease-ttl-sec", DEFAULTS.leaseTtlSec),
-		heartbeatIntervalMs: parseNonNegativeInt(args["heartbeat-interval-ms"], "heartbeat-interval-ms", DEFAULTS.heartbeatIntervalMs),
-		maxBatchSize: parsePositiveInt(args["max-batch-size"], "max-batch-size", DEFAULTS.maxBatchSize),
+		...args.provider ? { provider: args.provider } : {},
+		...args.model ? { model: args.model } : {},
+		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", DEFAULTS.maxTurns),
 		maxBashTimeouts: parseNonNegativeInt(args["max-bash-timeouts"], "max-bash-timeouts", DEFAULTS.maxBashTimeouts),
-		warmSessionTtlSec: parseNonNegativeInt(args["warm-session-ttl-sec"], "warm-session-ttl-sec", DEFAULTS.warmSessionTtlSec),
+		warmSessionTtlSec: parseNonNegativeInt(args["warm-session-ttl-sec"], "warm-session-ttl-sec", runtimeDefaults.warmSessionTtlSec),
 		debug: args.debug === true
 	};
 }
@@ -34837,6 +35374,71 @@ async function initWorkerOtel(options) {
 	};
 }
 //#endregion
+//#region src/lib/runtime-profile.ts
+var RuntimeProfilePrerequisiteError = class extends Error {
+	constructor(profileName, missingEnv, missingTools) {
+		const parts = [missingEnv.length > 0 ? `missing env: ${missingEnv.join(", ")}` : null, missingTools.length > 0 ? `missing tools: ${missingTools.join(", ")}` : null].filter(Boolean);
+		super(`Runtime profile "${profileName}" prerequisites are not satisfied: ${parts.join("; ")}`);
+		this.profileName = profileName;
+		this.missingEnv = missingEnv;
+		this.missingTools = missingTools;
+		this.name = "RuntimeProfilePrerequisiteError";
+	}
+};
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+async function resolveRuntimeProfile(options) {
+	const profile = UUID_RE.test(options.profile) ? await options.agent.runtimeProfiles.get(options.profile) : await resolveProfileByName(options);
+	if (options.teamId && profile.teamId !== options.teamId) throw new Error(`Runtime profile "${options.profile}" belongs to team ${profile.teamId}, not ${options.teamId}.`);
+	return {
+		id: profile.id,
+		name: profile.name,
+		teamId: profile.teamId,
+		provider: profile.provider,
+		model: profile.model,
+		leaseTtlSec: profile.leaseTtlSec,
+		heartbeatIntervalMs: profile.heartbeatIntervalMs,
+		maxBatchSize: profile.maxBatchSize,
+		sessionTtlSec: profile.sessionTtlSec,
+		workspaceTtlSec: profile.workspaceTtlSec,
+		requiredEnv: profile.requiredEnv,
+		requiredTools: profile.requiredTools,
+		sandboxConfig: profile.sandbox,
+		mountPath: resolve(options.cwd),
+		source: `runtime-profile:${profile.id}`
+	};
+}
+function validateRuntimeProfilePrerequisites(profile, env, pathValue) {
+	const missingEnv = profile.requiredEnv.filter((name) => !env[name]);
+	const missingTools = profile.requiredTools.filter((tool) => !isExecutableOnPath(tool, pathValue));
+	if (missingEnv.length > 0 || missingTools.length > 0) throw new RuntimeProfilePrerequisiteError(profile.name, missingEnv, missingTools);
+}
+function resolveProfileWarmSessionTtlSec(profile) {
+	return Math.min(profile.sessionTtlSec, profile.workspaceTtlSec);
+}
+async function resolveProfileByName(options) {
+	if (!options.teamId) throw new Error(`Runtime profile name "${options.profile}" requires --team. Use a profile UUID when running without a team-scoped list.`);
+	const matches = (await options.agent.runtimeProfiles.list({ teamId: options.teamId })).items.filter((item) => item.name === options.profile);
+	if (matches.length === 0) throw new Error(`Runtime profile "${options.profile}" was not found in team ${options.teamId}.`);
+	if (matches.length > 1) throw new Error(`Runtime profile name "${options.profile}" is ambiguous in team ${options.teamId}. Use the profile UUID instead.`);
+	return matches[0];
+}
+function isExecutableOnPath(tool, pathValue) {
+	if (tool.includes("/")) return isExecutable(isAbsolute(tool) ? tool : resolve(process.cwd(), tool));
+	for (const dir of (pathValue ?? "").split(delimiter)) {
+		if (!dir) continue;
+		if (isExecutable(resolve(dir, tool))) return true;
+	}
+	return false;
+}
+function isExecutable(path) {
+	try {
+		accessSync(path, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/lib/sandbox.ts
 function resolveSandbox(startDir, explicitPath) {
 	const path = explicitPath ? isAbsolute(explicitPath) ? explicitPath : resolve(startDir, explicitPath) : findUp(startDir, "sandbox.json");
@@ -34865,6 +35467,38 @@ function findUp(startDir, filename) {
 	}
 }
 //#endregion
+//#region src/lib/shutdown-signal.ts
+function installShutdownSignalHandlers(opts) {
+	const proc = opts.proc ?? process;
+	let drainingSignal = null;
+	const onSignal = (signal) => {
+		if (drainingSignal) {
+			proc.stderr.write(`[agent-daemon] ${signal} received while already draining from ${drainingSignal}; waiting for cleanup.\n`);
+			proc.exitCode = signalExitCode(signal);
+			return;
+		}
+		drainingSignal = signal;
+		proc.exitCode = signalExitCode(signal);
+		try {
+			opts.logDrain(signal);
+		} catch (err) {
+			proc.stderr.write(`[agent-daemon] failed to log ${signal}: ` + (err instanceof Error ? err.message : String(err)) + "\n");
+		}
+		opts.drain(signal);
+	};
+	const handleSigint = () => onSignal("SIGINT");
+	const handleSigterm = () => onSignal("SIGTERM");
+	proc.on("SIGINT", handleSigint);
+	proc.on("SIGTERM", handleSigterm);
+	return { dispose: () => {
+		proc.off("SIGINT", handleSigint);
+		proc.off("SIGTERM", handleSigterm);
+	} };
+}
+function signalExitCode(signal) {
+	return signal === "SIGINT" ? 130 : 143;
+}
+//#endregion
 //#region src/lib/state-dir.ts
 function ensureDaemonStateDirs(mountPath) {
 	const rootDir = join(mountPath, ".moltnet", "d");
@@ -34914,7 +35548,8 @@ async function runPolling(opts) {
 			"poll-interval-ms": { type: "string" },
 			"max-poll-interval-ms": { type: "string" },
 			"list-limit": { type: "string" },
-			sandbox: { type: "string" }
+			sandbox: { type: "string" },
+			profile: { type: "string" }
 		}
 	});
 	if (!values.team) {
@@ -34934,7 +35569,7 @@ async function runPolling(opts) {
 	const diaryIds = parseCsv(values["diary-ids"]);
 	let common;
 	try {
-		common = parseCommonOptions(values);
+		common = parseCommonOptions(values, { requireProviderModel: !values.profile });
 	} catch (err) {
 		if (err instanceof MissingRequiredOptionError) {
 			console.error(`${err.message}\n`);
@@ -34946,15 +35581,45 @@ async function runPolling(opts) {
 	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);
+	if (values.profile && values.sandbox) {
+		console.error(`[${opts.modeLabel}] Cannot use --sandbox with --profile. Remote runtime profiles define sandbox policy.`);
+		return 1;
+	}
 	if (taskTypes.length === 0) console.error(`[${opts.modeLabel}] --task-types is empty — daemon will accept any registered type. Pass an explicit list to limit scope (e.g. --task-types fulfill_brief).`);
-	const sandbox = resolveSandbox(process.cwd(), values.sandbox);
 	const cfg = loadConfig();
+	const ctx = await resolveAgentContext(common.agent);
+	const profile = values.profile ? await resolveRuntimeProfile({
+		agent: ctx.agent,
+		profile: values.profile,
+		teamId,
+		cwd: process.cwd()
+	}) : null;
+	if (profile) {
+		validateRuntimeProfilePrerequisites(profile, cfg.profilePrerequisiteEnv, cfg.profilePrerequisitePath);
+		common = parseCommonOptions(values, {
+			requireProviderModel: false,
+			runtimeDefaults: {
+				leaseTtlSec: profile.leaseTtlSec,
+				heartbeatIntervalMs: profile.heartbeatIntervalMs,
+				maxBatchSize: profile.maxBatchSize,
+				warmSessionTtlSec: resolveProfileWarmSessionTtlSec(profile)
+			}
+		});
+	}
+	const provider = profile?.provider ?? common.provider;
+	const model = profile?.model ?? common.model;
+	if (!provider || !model) throw new Error("provider/model missing after runtime profile resolution");
+	const sandbox = profile ? {
+		config: profile.sandboxConfig,
+		rootDir: profile.mountPath,
+		path: profile.source
+	} : resolveSandbox(process.cwd(), values.sandbox);
 	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
 	const slotRegistry = new DaemonSlotRegistry(resolveDaemonStateStorageConfig(stateDirs.registryDbPath, cfg.agentDaemonStateDatabaseUrl));
 	const slotIdentity = {
 		agentName: common.agent,
-		provider: common.provider,
-		model: common.model
+		provider,
+		model
 	};
 	const mainRepo = findMainWorktree();
 	const executionPlans = createExecutionPlanCache({
@@ -34963,7 +35628,6 @@ async function runPolling(opts) {
 		warmSessionTtlSec: common.warmSessionTtlSec,
 		slotRegistry
 	});
-	const ctx = await resolveAgentContext(common.agent);
 	const otelShutdown = await initWorkerOtel({
 		serviceName: opts.serviceName,
 		agentDir: ctx.agentDir,
@@ -34971,8 +35635,9 @@ async function runPolling(opts) {
 		resourceAttributes: {
 			"moltnet.team.id": teamId,
 			"moltnet.agent.name": common.agent,
-			"moltnet.llm.provider": common.provider,
-			"moltnet.llm.model": common.model
+			"moltnet.llm.provider": provider,
+			"moltnet.llm.model": model,
+			...profile ? { "moltnet.daemon_profile.id": profile.id } : {}
 		}
 	});
 	const { logger, shutdown: shutdownLogger } = createRootLogger({
@@ -34983,48 +35648,82 @@ async function runPolling(opts) {
 		mode: opts.modeLabel,
 		agent: common.agent,
 		teamId,
-		provider: common.provider,
-		model: common.model
+		provider,
+		model,
+		...profile ? {
+			daemonProfileId: profile.id,
+			daemonProfileName: profile.name
+		} : {}
 	});
 	const abort = new AbortController();
 	let runtime = null;
-	const onSignal = (sig) => {
-		rootLogger.warn({ signal: sig }, "agent-daemon.draining");
-		abort.abort();
-		runtime?.stop();
-	};
-	process.on("SIGINT", () => onSignal("SIGINT"));
-	process.on("SIGTERM", () => onSignal("SIGTERM"));
+	let active = null;
+	const signalHandlers = installShutdownSignalHandlers({
+		logDrain: (signal) => {
+			rootLogger.warn({ signal }, "agent-daemon.draining");
+		},
+		drain: (signal) => {
+			abort.abort();
+			runtime?.stop(`agent-daemon received ${signal}`);
+			if (active === null) return;
+			const { taskId, attemptN } = active;
+			ctx.agent.tasks.abortAttempt(taskId, attemptN, { reason: `runner_${signal.toLowerCase()}` }).catch((err) => {
+				try {
+					rootLogger.warn({
+						err: err instanceof Error ? err.message : String(err),
+						taskId,
+						attemptN
+					}, "agent-daemon.abort_on_signal_failed");
+				} catch {}
+			});
+		}
+	});
 	rootLogger.info({
 		sandbox: sandbox.path,
 		taskTypes: taskTypes.length > 0 ? taskTypes : ["*"],
 		diaryIds: diaryIds.length > 0 ? diaryIds : ["*"],
 		leaseTtlSec: common.leaseTtlSec,
 		heartbeatIntervalMs: common.heartbeatIntervalMs,
+		warmSessionTtlSec: common.warmSessionTtlSec,
 		pollIntervalMs,
-		maxPollIntervalMs
+		maxPollIntervalMs,
+		...profile ? {
+			profileId: profile.id,
+			profileSessionTtlSec: profile.sessionTtlSec,
+			profileWorkspaceTtlSec: profile.workspaceTtlSec
+		} : {}
 	}, "agent-daemon.starting");
 	const outputs = [];
 	try {
-		const executeTask = createPiTaskExecutor({
+		const rawExecuteTask = createPiTaskExecutor({
 			agentName: common.agent,
 			mountPath: sandbox.rootDir,
-			provider: common.provider,
-			model: common.model,
+			provider,
+			model,
 			sandboxConfig: sandbox.config,
 			makeExecutionPlan: (claimedTask) => executionPlans.getOrCreate(claimedTask),
 			makeOnTurnEvent: makeTurnEventHandlerFactory(rootLogger),
 			maxTurns: common.maxTurns,
 			maxBashTimeouts: common.maxBashTimeouts
 		});
+		const executeTask = async (claimedTask, reporter) => {
+			active = {
+				taskId: claimedTask.task.id,
+				attemptN: claimedTask.attemptN
+			};
+			try {
+				return await rawExecuteTask(claimedTask, reporter);
+			} finally {
+				active = null;
+			}
+		};
 		runtime = new AgentRuntime({
 			logger: rootLogger,
 			source: new PollingApiTaskSource({
 				agent: ctx.agent,
 				teamId,
 				taskTypes: taskTypes.length > 0 ? taskTypes : void 0,
-				provider: common.provider.toLowerCase(),
-				model: common.model.toLowerCase(),
+				...profile ? { profileId: profile.id } : {},
 				diaryIds: diaryIds.length > 0 ? diaryIds : void 0,
 				leaseTtlSec: common.leaseTtlSec,
 				listLimit,
@@ -35171,6 +35870,7 @@ async function runPolling(opts) {
 		rootLogger.info({ processed: drained.length }, "agent-daemon.drained");
 		return drained.some((o) => o.status !== "completed") ? 1 : 0;
 	} finally {
+		signalHandlers.dispose();
 		await slotRegistry.close();
 		await otelShutdown();
 		await shutdownLogger();
@@ -35215,7 +35915,8 @@ async function runOnce(argv) {
 				type: "string",
 				short: "t"
 			},
-			sandbox: { type: "string" }
+			sandbox: { type: "string" },
+			profile: { type: "string" }
 		}
 	});
 	if (!values["task-id"]) {
@@ -35226,7 +35927,7 @@ async function runOnce(argv) {
 	const taskId = values["task-id"];
 	let opts;
 	try {
-		opts = parseCommonOptions(values);
+		opts = parseCommonOptions(values, { requireProviderModel: !values.profile });
 	} catch (err) {
 		if (err instanceof MissingRequiredOptionError) {
 			console.error(`${err.message}\n`);
@@ -35235,14 +35936,43 @@ async function runOnce(argv) {
 		}
 		throw err;
 	}
-	const sandbox = resolveSandbox(process.cwd(), values.sandbox);
+	if (values.profile && values.sandbox) {
+		console.error("Cannot use --sandbox with --profile. Remote runtime profiles define sandbox policy.");
+		return 1;
+	}
 	const cfg = loadConfig();
+	const ctx = await resolveAgentContext(opts.agent);
+	const profile = values.profile ? await resolveRuntimeProfile({
+		agent: ctx.agent,
+		profile: values.profile,
+		cwd: process.cwd()
+	}) : null;
+	if (profile) {
+		validateRuntimeProfilePrerequisites(profile, cfg.profilePrerequisiteEnv, cfg.profilePrerequisitePath);
+		opts = parseCommonOptions(values, {
+			requireProviderModel: false,
+			runtimeDefaults: {
+				leaseTtlSec: profile.leaseTtlSec,
+				heartbeatIntervalMs: profile.heartbeatIntervalMs,
+				maxBatchSize: profile.maxBatchSize,
+				warmSessionTtlSec: resolveProfileWarmSessionTtlSec(profile)
+			}
+		});
+	}
+	const provider = profile?.provider ?? opts.provider;
+	const model = profile?.model ?? opts.model;
+	if (!provider || !model) throw new Error("provider/model missing after runtime profile resolution");
+	const sandbox = profile ? {
+		config: profile.sandboxConfig,
+		rootDir: profile.mountPath,
+		path: profile.source
+	} : resolveSandbox(process.cwd(), values.sandbox);
 	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
 	const slotRegistry = new DaemonSlotRegistry(resolveDaemonStateStorageConfig(stateDirs.registryDbPath, cfg.agentDaemonStateDatabaseUrl));
 	const slotIdentity = {
 		agentName: opts.agent,
-		provider: opts.provider,
-		model: opts.model
+		provider,
+		model
 	};
 	const mainRepo = findMainWorktree();
 	const executionPlans = createExecutionPlanCache({
@@ -35251,7 +35981,6 @@ async function runOnce(argv) {
 		warmSessionTtlSec: opts.warmSessionTtlSec,
 		slotRegistry
 	});
-	const ctx = await resolveAgentContext(opts.agent);
 	const otelShutdown = await initWorkerOtel({
 		serviceName: "moltnet.agent-daemon.once",
 		agentDir: ctx.agentDir,
@@ -35259,8 +35988,9 @@ async function runOnce(argv) {
 		resourceAttributes: {
 			"moltnet.task.id": taskId,
 			"moltnet.agent.name": opts.agent,
-			"moltnet.llm.provider": opts.provider,
-			"moltnet.llm.model": opts.model
+			"moltnet.llm.provider": provider,
+			"moltnet.llm.model": model,
+			...profile ? { "moltnet.daemon_profile.id": profile.id } : {}
 		}
 	});
 	const { logger, shutdown: shutdownLogger } = createRootLogger({
@@ -35270,39 +36000,57 @@ async function runOnce(argv) {
 	const rootLogger = logger.child({
 		mode: "once",
 		agent: opts.agent,
-		provider: opts.provider,
-		model: opts.model
+		provider,
+		model,
+		...profile ? {
+			daemonProfileId: profile.id,
+			daemonProfileName: profile.name
+		} : {}
 	});
 	rootLogger.info({
 		sandbox: sandbox.path,
-		taskId
+		taskId,
+		leaseTtlSec: opts.leaseTtlSec,
+		heartbeatIntervalMs: opts.heartbeatIntervalMs,
+		warmSessionTtlSec: opts.warmSessionTtlSec,
+		...profile ? {
+			profileId: profile.id,
+			profileSessionTtlSec: profile.sessionTtlSec,
+			profileWorkspaceTtlSec: profile.workspaceTtlSec
+		} : {}
 	}, "agent-daemon.starting");
 	let runtime = null;
-	const onSignal = (sig) => {
-		rootLogger.warn({
-			signal: sig,
-			taskId
-		}, "agent-daemon.draining");
-		runtime?.stop();
-		ctx.agent.tasks.cancel(taskId, { reason: `runner_${sig.toLowerCase()}` }).catch((err) => {
+	let activeAttemptN = null;
+	const signalHandlers = installShutdownSignalHandlers({
+		logDrain: (signal) => {
 			rootLogger.warn({
-				err: err instanceof Error ? err.message : String(err),
+				signal,
 				taskId
-			}, "agent-daemon.cancel_on_signal_failed");
-		});
-	};
-	process.on("SIGINT", () => {
-		onSignal("SIGINT");
-	});
-	process.on("SIGTERM", () => {
-		onSignal("SIGTERM");
+			}, "agent-daemon.draining");
+		},
+		drain: (signal) => {
+			runtime?.stop(`agent-daemon received ${signal}`);
+			if (activeAttemptN === null) return;
+			const attemptN = activeAttemptN;
+			ctx.agent.tasks.abortAttempt(taskId, attemptN, { reason: `runner_${signal.toLowerCase()}` }).catch((err) => {
+				try {
+					rootLogger.warn({
+						err: err instanceof Error ? err.message : String(err),
+						taskId,
+						attemptN
+					}, "agent-daemon.abort_on_signal_failed");
+				} catch (logErr) {
+					process.stderr.write(`[agent-daemon] failed to log abort error: ` + (logErr instanceof Error ? logErr.message : String(logErr)) + "\n");
+				}
+			});
+		}
 	});
 	try {
 		const rawExecuteTask = createPiTaskExecutor({
 			agentName: opts.agent,
 			mountPath: sandbox.rootDir,
-			provider: opts.provider,
-			model: opts.model,
+			provider,
+			model,
 			sandboxConfig: sandbox.config,
 			makeExecutionPlan: (claimedTask) => executionPlans.getOrCreate(claimedTask),
 			onTurnEvent: makeTurnEventHandler(rootLogger, { taskId }),
@@ -35363,9 +36111,11 @@ async function runOnce(argv) {
 				lastAttemptN: claimedTask.attemptN,
 				ttlSec: opts.warmSessionTtlSec
 			});
+			activeAttemptN = claimedTask.attemptN;
 			try {
 				return await rawExecuteTask(claimedTask, reporter);
 			} finally {
+				activeAttemptN = null;
 				executionPlans.delete(claimedTask);
 				if (executionPlan.slotKey) await slotRegistry.finishSlot(slotIdentity, executionPlan.slotKey, opts.warmSessionTtlSec, executionPlan.sessionPersistence ? resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir) : null);
 			}
@@ -35379,7 +36129,8 @@ async function runOnce(argv) {
 			source: new ApiTaskSource({
 				agent: ctx.agent,
 				taskId,
-				leaseTtlSec: opts.leaseTtlSec
+				leaseTtlSec: opts.leaseTtlSec,
+				...profile ? { profileId: profile.id } : {}
 			}),
 			makeReporter: () => new ApiTaskReporter({
 				tasks: ctx.agent.tasks,
@@ -35408,6 +36159,7 @@ async function runOnce(argv) {
 		console.log(JSON.stringify(output, null, 2));
 		return output.status === "completed" ? 0 : 1;
 	} finally {
+		signalHandlers.dispose();
 		await slotRegistry.close();
 		await otelShutdown();
 		await shutdownLogger();