@themoltnet/agent-daemon 0.19.1 → 0.21.0

package/README.md

@@ -80,8 +80,8 @@ To force a non-repo Pi directory, set
 
 ### Host command auto-approval
 
-The daemon reads `sandbox.json` through `--sandbox` or by searching up from the
-current directory. Configure host-side auto-approval there, not in task data:
+The daemon reads host-side auto-approval from the selected remote runtime
+profile's sandbox policy. Configure it in the profile, not in task data:
 
 ```json
 {
@@ -143,12 +143,11 @@ registered task type; unknown task-type names remain invalid.
   gitignored. For API-key auth, keep `.pi/auth.json` absent and export the
   provider key referenced by `.pi/models.json`, for example `OLLAMA_API_KEY`.
 - `ssh-keygen` on `PATH`.
-- A `sandbox.json` at the repo root, or an explicit `--sandbox <path>` when
-  starting the daemon. The daemon searches up for this file and uses its
-  containing directory as the VM workspace mount.
+- A runtime profile in the target team. The profile supplies provider, model,
+  sandbox policy, and runtime defaults. The daemon mounts the current working
+  directory as the VM workspace root.
 
-For `themoltnet`, prefer the checked-in repo `sandbox.json` as-is — it carries
-the current pnpm/VFS workaround. A minimal `sandbox.json` for another repo:
+For `themoltnet`, prefer a profile sandbox equivalent to this minimal policy:
 
 ```json
 {
@@ -181,9 +180,9 @@ workspace shape in `input.execution.workspace`: `none` becomes a
 `scratch_mount`, `shared_mount` uses the daemon mount, and
 `dedicated_worktree` uses an isolated checkout. Downstream
 `judge_eval_attempt` tasks only resolve against a still-live producer
-session/workspace slot. If the producer slot has already expired and been
-reaped, the judge fails with `producer_context_missing`. When the judge does
-claim in time, it immediately forks the producer session and copies the
+session/workspace slot. If the producer slot or its local session/workspace
+files cannot be resolved, the judge fails with `producer_context_missing`.
+When the judge does claim in time, it immediately forks the producer session and copies the
 producer workspace into judge-owned scratch state so the running judge no
 longer depends on the producer slot after claim time. Repo-specific
 `resumeCommands` that should not run in scratch mode must still be guarded
@@ -251,18 +250,14 @@ pnpm --filter @themoltnet/agent-daemon dev poll \
   --agent local-dev \
   --team "$MOLTNET_TEAM_ID" \
   --task-types fulfill_brief \
-  --provider openai-codex \
-  --model gpt-5.4-codex \
+  --profile "$MOLTNET_AGENT_PROFILE" \
   --debug
 ```
 
-- If you're starting from a directory without `sandbox.json` at or above it,
-  pass `--sandbox <repo-root>/sandbox.json`.
 - `--task-types fulfill_brief` scopes the queue. Omit to accept any
   registered type.
-- Pick provider/model that matches your pi auth credits. Common choices:
-  `--provider openai-codex --model gpt-5.4-codex`, or
-  `--provider anthropic --model claude-sonnet-4-6`.
+- Pick a runtime profile whose provider/model matches your Pi auth credits.
+  Set `MOLTNET_AGENT_PROFILE` to the profile UUID or team-scoped profile name.
 - `dev` (= `tsx watch src/main.ts`) is fine for local. Use `cli` for a
   one-shot run without watch.
 
@@ -333,8 +328,7 @@ pnpm --filter @themoltnet/agent-daemon dev poll \
   --agent local-dev \
   --team "$MOLTNET_TEAM_ID" \
   --task-types pr_review \
-  --provider openai-codex \
-  --model gpt-5.4-codex \
+  --profile "$MOLTNET_AGENT_PROFILE" \
   --debug
 ```
 
@@ -396,7 +390,7 @@ snapshot. The cheap parts of the runtime contract (prompt assembly, tool-side
 tests in `libs/pi-extension`. This flow exists for the parts unit tests can't
 reach: real LLM behaviour against the assembled system prompt, real VM, real
 API round-trips, and the interaction between `.moltnet/<agent>/` identity
-material and the active `sandbox.json`.
+material and the selected runtime profile.
 
 ## License
 

package/dist/main.js

@@ -9,11 +9,10 @@ import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
 import crypto from "crypto";
 import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { parseArgs, promisify } from "node:util";
-import { DaemonSlotRegistry, resolveDaemonStateStorageConfig, resolveLatestPiSessionPath } from "@themoltnet/agent-daemon-state";
 import { AgentRuntime, ApiTaskReporter, ApiTaskSource, PollingApiTaskSource } from "@themoltnet/agent-runtime";
 import { createPiTaskExecutor, findMainWorktree } from "@themoltnet/pi-extension";
 import { execFile, execFileSync } from "node:child_process";
-import { accessSync, constants, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { accessSync, constants, existsSync, mkdirSync, readdirSync } from "node:fs";
 import { MoltNetError, connect } from "@themoltnet/sdk";
 import { once } from "node:events";
 import { pino, transport } from "pino";
@@ -22,6 +21,7 @@ import { resourceFromAttributes } from "@opentelemetry/resources";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region ../../libs/observability/src/instrumentation.ts
 /**
 * Register OTel auto-instrumentation for common Node.js modules.
@@ -4547,6 +4547,118 @@ _Object_({
 	additionalProperties: false
 });
 //#endregion
+//#region ../../libs/tasks/src/runtime-slots.ts
+var RuntimeWorkspaceKind = Union([
+	Literal("origin"),
+	Literal("fork"),
+	Literal("scratch")
+]);
+var RuntimeSlotState = Union([Literal("active"), Literal("idle")]);
+var RuntimeWorkspace = _Object_({
+	id: String$1({ format: "uuid" }),
+	teamId: String$1({ format: "uuid" }),
+	workspaceId: String$1({ minLength: 1 }),
+	worktreePath: String$1({ minLength: 1 }),
+	worktreeBranch: Union([String$1({ minLength: 1 }), Null()]),
+	kind: RuntimeWorkspaceKind,
+	createdAtMs: Integer({ minimum: 0 }),
+	lastUsedAtMs: Integer({ minimum: 0 })
+}, { $id: "RuntimeWorkspace" });
+_Object_({
+	slot: _Object_({
+		id: String$1({ format: "uuid" }),
+		teamId: String$1({ format: "uuid" }),
+		agentName: String$1({
+			minLength: 1,
+			maxLength: 100
+		}),
+		runtimeProfileId: Union([String$1({ format: "uuid" }), Null()]),
+		provider: String$1({
+			minLength: 1,
+			maxLength: 100
+		}),
+		model: String$1({
+			minLength: 1,
+			maxLength: 200
+		}),
+		slotKey: String$1({ minLength: 1 }),
+		taskType: String$1({
+			minLength: 1,
+			maxLength: 100
+		}),
+		state: RuntimeSlotState,
+		lastTaskId: String$1({ format: "uuid" }),
+		lastAttemptN: Integer({ minimum: 1 }),
+		sessionDir: Union([String$1({ minLength: 1 }), Null()]),
+		sessionPath: Union([String$1({ minLength: 1 }), Null()]),
+		workspaceRowId: Union([String$1({ format: "uuid" }), Null()]),
+		createdAtMs: Integer({ minimum: 0 }),
+		lastUsedAtMs: Integer({ minimum: 0 }),
+		expiresAtMs: Integer({ minimum: 0 })
+	}, { $id: "RuntimeSlot" }),
+	workspace: Union([RuntimeWorkspace, Null()])
+}, { $id: "ResolvedRuntimeSlot" });
+_Object_({
+	agentName: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	runtimeProfileId: String$1({ format: "uuid" }),
+	provider: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	model: String$1({
+		minLength: 1,
+		maxLength: 200
+	}),
+	slotKey: String$1({ minLength: 1 }),
+	taskType: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	sessionDir: Optional(String$1({ minLength: 1 })),
+	sessionPath: Optional(String$1({ minLength: 1 })),
+	workspaceId: Optional(String$1({ minLength: 1 })),
+	worktreePath: Optional(String$1({ minLength: 1 })),
+	worktreeBranch: Optional(String$1({ minLength: 1 })),
+	workspaceKind: Optional(RuntimeWorkspaceKind),
+	lastTaskId: String$1({ format: "uuid" }),
+	lastAttemptN: Integer({ minimum: 1 })
+}, {
+	$id: "BeginRuntimeSlotBody",
+	additionalProperties: false
+});
+_Object_({
+	agentName: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	runtimeProfileId: String$1({ format: "uuid" }),
+	provider: String$1({
+		minLength: 1,
+		maxLength: 100
+	}),
+	model: String$1({
+		minLength: 1,
+		maxLength: 200
+	}),
+	slotKey: String$1({ minLength: 1 }),
+	taskId: String$1({ format: "uuid" }),
+	attemptN: Integer({ minimum: 1 }),
+	sessionPath: Optional(String$1({ minLength: 1 }))
+}, {
+	$id: "FinishRuntimeSlotBody",
+	additionalProperties: false
+});
+_Object_({
+	taskId: String$1({ format: "uuid" }),
+	attemptN: Integer({ minimum: 1 })
+}, {
+	$id: "FindLatestRuntimeSlotForAttemptQuery",
+	additionalProperties: false
+});
+//#endregion
 //#region ../../libs/tasks/src/success-criteria.ts
 /**
 * SuccessCriteria — proposer-stated acceptance criteria, evaluated in two
@@ -9011,23 +9123,14 @@ _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.`;
-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). Required
-                              unless --profile is set.`;
+                              from <repo-root>/.moltnet/<name>/moltnet.json.
+  --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.`;
 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. 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.
+  --sandbox <path>            Deprecated. Remote runtime profiles define
+                              sandbox policy.
   --lease-ttl-sec <n>         Sliding liveness window. Silence longer than
                               this ends the attempt with lease_expired.
                               Default: 300.
@@ -9042,9 +9145,8 @@ var COMMON_OPTIONAL_FLAGS = `\
                               this, the pi session aborts and the attempt
                               fails with code 'max_bash_timeouts_exceeded'.
                               0 = disabled. Default: 3.
-  --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.
+  --warm-session-ttl-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.
   --debug                     Verbose logging: also log successful list/claim
@@ -9069,23 +9171,20 @@ Run \`agent-daemon <command> --help\` for command-specific flags.
 
 Prerequisites (all subcommands):
   - <repo-root>/.moltnet/<agent>/moltnet.json — credentials (see --agent)
-  - 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.
+  - --profile — remote runtime profile supplies provider/model/sandbox
+    policy and CWD is used as the VM mountPath.
 
 Registered task types: ${knownTaskTypesList()}`;
 var POLL_HELP = `\
 agent-daemon poll — long-running task worker.
 
 Usage:
-  agent-daemon poll --team <uuid> --agent <name> --provider <p> --model <m> [...]
+  agent-daemon poll --team <uuid> --agent <name> --profile <uuid|name> [...]
 
 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:
@@ -9102,38 +9201,38 @@ Example:
     --team 6743b4b1-6b93-46e2-a048-19490f04f91a \\
     --task-types curate_pack,fulfill_brief \\
     --agent legreffier \\
-    --provider anthropic \\
-    --model claude-sonnet-4-5
+    --profile github-linear \\
+    --profile local-fallback
 
 Stops cleanly on SIGINT/SIGTERM (drains the in-flight task before exit).`;
 var ONCE_HELP = `\
 agent-daemon once — execute one specific queued task by id, then exit.
 
 Usage:
-  agent-daemon once --task-id <uuid> --agent <name> --provider <p> --model <m> [...]
+  agent-daemon once --task-id <uuid> --agent <name> --profile <uuid|name> [...]
 
 Required:
   -t, --task-id <uuid>        Task to claim and execute. Must already be
                               in 'queued' status.
 ${COMMON_REQUIRED_FLAGS}
-${COMMON_MODEL_FLAGS}
 
 Optional:
+  --team <uuid>               Team scope for resolving --profile by name.
+                              Required only when --profile is a name.
 ${COMMON_OPTIONAL_FLAGS}
 
 Example:
   agent-daemon once \\
     --task-id 26004a77-bc10-43ef-a79f-c8e62faf59b1 \\
     --agent legreffier \\
-    --provider anthropic \\
-    --model claude-sonnet-4-5
+    --profile github-linear
 
 Exits 0 on completed, 1 on failed/cancelled/runtime-error.`;
 var DRAIN_HELP = `\
 agent-daemon drain — poll until the queue is empty, then exit.
 
 Usage:
-  agent-daemon drain --team <uuid> --agent <name> --provider <p> --model <m> [...]
+  agent-daemon drain --team <uuid> --agent <name> --profile <uuid|name> [...]
 
 Same flags as \`poll\`. The only behavioural difference: \`drain\` exits
 when a list call confirms no claimable tasks remain (vs \`poll\` which
@@ -9142,7 +9241,6 @@ 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()}
@@ -9157,8 +9255,7 @@ Example:
     --team 6743b4b1-6b93-46e2-a048-19490f04f91a \\
     --task-types judge_pack \\
     --agent legreffier \\
-    --provider anthropic \\
-    --model claude-sonnet-4-5`;
+    --profile eval-judge`;
 function isHelpFlag(args) {
 	return args.includes("--help") || args.includes("-h");
 }
@@ -9166,7 +9263,6 @@ function isHelpFlag(args) {
 //#region src/config.ts
 function loadConfig() {
 	return {
-		agentDaemonStateDatabaseUrl: process.env["MOLTNET_AGENT_DAEMON_STATE_DATABASE_URL"] ?? "",
 		otelEndpoint: process.env["MOLTNET_OTEL_ENDPOINT"] ?? "",
 		logLevel: process.env["LOG_LEVEL"] ?? "",
 		profilePrerequisiteEnv: process.env,
@@ -9265,6 +9361,16 @@ function createGhCliClient() {
 	};
 }
 //#endregion
+//#region src/lib/session-files.ts
+function resolveLatestPiSessionPath(sessionDir) {
+	try {
+		const latestEntry = readdirSync(sessionDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => entry.name).sort().at(-1);
+		return latestEntry ? join(sessionDir, latestEntry) : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/lib/slugify.ts
 function slugifyAsciiLower(input, maxLen, preserveChars = []) {
 	const preserved = new Set(preserveChars.map((char) => char.toLowerCase()));
@@ -9354,10 +9460,8 @@ function buildDaemonSlotId(identity, slotKey) {
 	return [
 		"agent",
 		slugSlotIdentityComponent(identity.agentName),
-		"provider",
-		slugSlotIdentityComponent(identity.provider),
-		"model",
-		slugSlotIdentityComponent(identity.model),
+		"profile",
+		slugSlotIdentityComponent(identity.runtimeProfileId),
 		"key",
 		slotKey
 	].join(":");
@@ -9419,8 +9523,8 @@ function createExecutionPlanCache(args) {
 function buildClaimedTaskKey(task) {
 	return `${task.task.id}:${task.attemptN}`;
 }
-async function resolveWarmSlot(slotRegistry, sourceTaskId, sourceAttemptN, stateDirs) {
-	const producerContext = await slotRegistry.findLatestProducerSlotByTaskAttempt(sourceTaskId, sourceAttemptN);
+async function resolveWarmSlot(slotRegistry, teamId, sourceTaskId, sourceAttemptN, stateDirs) {
+	const producerContext = await slotRegistry.findLatestSlotByTaskAttempt(teamId, sourceTaskId, sourceAttemptN);
 	if (!producerContext) return { kind: "missing" };
 	const sourceSessionPath = resolveProducerSessionPath(producerContext);
 	if (!sourceSessionPath) return { kind: "no-session-path" };
@@ -9435,8 +9539,8 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 	if (claimedTask.task.taskType === "freeform") {
 		const continueFrom = claimedTask.task.input.continueFrom;
 		if (!continueFrom) return basePlan;
-		const resolution = await resolveWarmSlot(slotRegistry, continueFrom.taskId, continueFrom.attemptN, stateDirs);
-		if (resolution.kind === "missing") throw new ProducerContextResolutionError(`Continuation source task ${continueFrom.taskId} attempt ${continueFrom.attemptN} has no live daemon slot on this daemon — claim affinity filter should have prevented this claim`);
+		const resolution = await resolveWarmSlot(slotRegistry, claimedTask.task.teamId, continueFrom.taskId, continueFrom.attemptN, stateDirs);
+		if (resolution.kind === "missing") throw new ProducerContextResolutionError(`Continuation source task ${continueFrom.taskId} attempt ${continueFrom.attemptN} has no live runtime slot on this daemon — claim affinity filter should have prevented this claim`);
 		if (resolution.kind === "no-session-path") throw new ProducerContextResolutionError(`Continuation source attempt ${continueFrom.taskId}/${continueFrom.attemptN} has no persisted Pi session path`);
 		const sessionDir = `${stateDirs.piSessionsDir}/continue-${claimedTask.task.id}-attempt-${claimedTask.attemptN}`;
 		const parentBranch = resolution.producerSlot.workspace?.worktreeBranch ?? null;
@@ -9472,8 +9576,8 @@ async function maybeAttachWarmSlotContext(claimedTask, basePlan, stateDirs, slot
 	const targetTaskId = typeof claimedTask.task.input.targetTaskId === "string" ? claimedTask.task.input.targetTaskId : null;
 	const targetAttemptN = typeof claimedTask.task.input.targetAttemptN === "number" ? claimedTask.task.input.targetAttemptN : null;
 	if (!targetTaskId || !targetAttemptN) throw new ProducerContextResolutionError("judge_eval_attempt is missing targetTaskId/targetAttemptN");
-	const resolution = await resolveWarmSlot(slotRegistry, targetTaskId, targetAttemptN, stateDirs);
-	if (resolution.kind === "missing") throw new ProducerContextResolutionError(`No live producer daemon slot found for task ${targetTaskId} attempt ${targetAttemptN}`);
+	const resolution = await resolveWarmSlot(slotRegistry, claimedTask.task.teamId, targetTaskId, targetAttemptN, stateDirs);
+	if (resolution.kind === "missing") throw new ProducerContextResolutionError(`No live producer runtime slot found for task ${targetTaskId} attempt ${targetAttemptN}`);
 	if (resolution.kind === "no-session-path") throw new ProducerContextResolutionError(`Producer task ${targetTaskId} attempt ${targetAttemptN} has no persisted Pi session path`);
 	return {
 		...basePlan,
@@ -9520,7 +9624,7 @@ function recoverScratchWorkspacePath(producer, stateDirs) {
 //#region src/lib/finalize.ts
 /**
 * Build the `daemonState` payload for a `/complete` call. Only freeform
-* attempts that ran with a warm slot are eligible for continuation
+* attempts that ran with a runtime slot are eligible for continuation
 * (`tasks_continue`, see issue #1287). Other task types and slot-less
 * freeform completions report `null` for `slotResumableUntil`, which
 * the server persists verbatim — continuations against such attempts
@@ -9672,7 +9776,6 @@ var MissingRequiredOptionError = class extends Error {
 	}
 };
 function parseCommonOptions(args, options = {}) {
-	const requireProviderModel = options.requireProviderModel ?? true;
 	const runtimeDefaults = {
 		leaseTtlSec: options.runtimeDefaults?.leaseTtlSec ?? DEFAULTS.leaseTtlSec,
 		heartbeatIntervalMs: options.runtimeDefaults?.heartbeatIntervalMs ?? DEFAULTS.heartbeatIntervalMs,
@@ -9680,13 +9783,9 @@ function parseCommonOptions(args, options = {}) {
 		warmSessionTtlSec: options.runtimeDefaults?.warmSessionTtlSec ?? DEFAULTS.warmSessionTtlSec
 	};
 	if (!args.agent) throw new MissingRequiredOptionError("agent");
-	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,
-		...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),
@@ -9715,14 +9814,6 @@ function commonOptionDefs() {
 			type: "string",
 			short: "a"
 		},
-		model: {
-			type: "string",
-			short: "m"
-		},
-		provider: {
-			type: "string",
-			short: "p"
-		},
 		"lease-ttl-sec": { type: "string" },
 		"heartbeat-interval-ms": { type: "string" },
 		"max-batch-size": { type: "string" },
@@ -9801,6 +9892,12 @@ function ensurePiAgentDir(repoRoot, explicitPath) {
 	};
 }
 //#endregion
+//#region src/lib/runtime-context.ts
+var storage = new AsyncLocalStorage();
+function runWithDaemonRuntimeContext(context, callback) {
+	return storage.run(context, callback);
+}
+//#endregion
 //#region src/lib/runtime-profile.ts
 var RuntimeProfilePrerequisiteError = class extends Error {
 	constructor(profileName, missingEnv, missingTools) {
@@ -9834,6 +9931,22 @@ async function resolveRuntimeProfile(options) {
 		source: `runtime-profile:${profile.id}`
 	};
 }
+async function resolveRuntimeProfiles(options) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const profile of options.profiles) {
+		const resolved = await resolveRuntimeProfile({
+			agent: options.agent,
+			profile,
+			teamId: options.teamId,
+			cwd: options.cwd
+		});
+		if (seen.has(resolved.id)) continue;
+		seen.add(resolved.id);
+		out.push(resolved);
+	}
+	return out;
+}
 function validateRuntimeProfilePrerequisites(profile, env, pathValue) {
 	const missingEnv = profile.requiredEnv.filter((name) => !env[name]);
 	const missingTools = profile.requiredTools.filter((tool) => !isExecutableOnPath(tool, pathValue));
@@ -9866,33 +9979,63 @@ function isExecutable(path) {
 	}
 }
 //#endregion
-//#region src/lib/sandbox.ts
-function resolveSandbox(startDir, explicitPath) {
-	const path = explicitPath ? isAbsolute(explicitPath) ? explicitPath : resolve(startDir, explicitPath) : findUp(startDir, "sandbox.json");
-	if (!path) throw new Error(`sandbox.json not found in ${startDir} or any parent directory. Pass --sandbox <path> or run the daemon from a directory with sandbox.json at or above it.`);
-	let config;
-	try {
-		config = JSON.parse(readFileSync(path, "utf8"));
-	} catch (err) {
-		const isEnoent = err instanceof Error && "code" in err && err.code === "ENOENT";
-		throw new Error(isEnoent ? `sandbox.json not found at ${path}.` : `Failed to read sandbox.json at ${path}: ${err instanceof Error ? err.message : String(err)}`);
-	}
+//#region src/lib/runtime-slots.ts
+function createApiRuntimeSlotStore(args) {
+	const { agent } = args;
 	return {
-		config,
-		rootDir: dirname(path),
-		path
+		async beginSlot(input) {
+			await agent.runtimeSlots.begin({
+				agentName: input.agentName,
+				runtimeProfileId: input.runtimeProfileId,
+				lastAttemptN: input.lastAttemptN,
+				lastTaskId: input.lastTaskId,
+				model: input.model,
+				provider: input.provider,
+				sessionDir: input.sessionDir ?? void 0,
+				sessionPath: input.sessionPath ?? void 0,
+				slotKey: input.slotKey,
+				taskType: input.taskType,
+				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) {
+			await agent.runtimeSlots.finish({
+				agentName: identity.agentName,
+				attemptN,
+				runtimeProfileId: identity.runtimeProfileId,
+				model,
+				provider,
+				sessionPath: sessionPath ?? void 0,
+				slotKey,
+				taskId
+			}, { teamId });
+		},
+		async findLatestSlotByTaskAttempt(teamId, taskId, attemptN) {
+			const resolved = await agent.runtimeSlots.findLatestForAttempt({
+				attemptN,
+				taskId
+			}, { teamId });
+			if (!resolved) return null;
+			return {
+				slot: { expiresAtMs: resolved.slot.expiresAtMs },
+				session: resolved.slot.sessionDir ? {
+					sessionDir: resolved.slot.sessionDir,
+					sessionPath: resolved.slot.sessionPath
+				} : null,
+				workspace: resolved.workspace ? {
+					kind: resolved.workspace.kind,
+					workspaceId: resolved.workspace.workspaceId,
+					worktreeBranch: resolved.workspace.worktreeBranch,
+					worktreePath: resolved.workspace.worktreePath
+				} : null
+			};
+		},
+		async close() {}
 	};
 }
-function findUp(startDir, filename) {
-	let dir = resolve(startDir);
-	while (true) {
-		const candidate = resolve(dir, filename);
-		if (existsSync(candidate)) return candidate;
-		const parent = dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-}
 //#endregion
 //#region src/lib/shutdown-signal.ts
 function installShutdownSignalHandlers(opts) {
@@ -9933,8 +10076,7 @@ function ensureDaemonStateDirs(mountPath) {
 	mkdirSync(piSessionsDir, { recursive: true });
 	return {
 		rootDir,
-		piSessionsDir,
-		registryDbPath: join(rootDir, "daemon-state.sqlite")
+		piSessionsDir
 	};
 }
 //#endregion
@@ -9976,7 +10118,10 @@ async function runPolling(opts) {
 			"max-poll-interval-ms": { type: "string" },
 			"list-limit": { type: "string" },
 			sandbox: { type: "string" },
-			profile: { type: "string" }
+			profile: {
+				type: "string",
+				multiple: true
+			}
 		}
 	});
 	if (!values.team) {
@@ -9985,6 +10130,12 @@ async function runPolling(opts) {
 		return 1;
 	}
 	const teamId = values.team;
+	const profileValues = parseProfileValues(values.profile);
+	if (profileValues.length === 0) {
+		console.error("Missing required flag: --profile\n");
+		console.error(opts.helpText);
+		return 1;
+	}
 	let taskTypes;
 	try {
 		taskTypes = validateTaskTypes(parseCsv(values["task-types"]));
@@ -9994,9 +10145,9 @@ async function runPolling(opts) {
 		return 1;
 	}
 	const diaryIds = parseCsv(values["diary-ids"]);
-	let common;
+	let baseCommon;
 	try {
-		common = parseCommonOptions(values, { requireProviderModel: !values.profile });
+		baseCommon = parseCommonOptions(values);
 	} catch (err) {
 		if (err instanceof MissingRequiredOptionError) {
 			console.error(`${err.message}\n`);
@@ -10008,81 +10159,82 @@ 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.`);
+	if (values.sandbox) {
+		console.error(`[${opts.modeLabel}] Cannot use --sandbox. 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 cfg = loadConfig();
-	const ctx = await resolveAgentContext(common.agent);
-	const profile = values.profile ? await resolveRuntimeProfile({
+	const ctx = await resolveAgentContext(baseCommon.agent);
+	const profiles = await resolveRuntimeProfiles({
 		agent: ctx.agent,
-		profile: values.profile,
+		profiles: profileValues,
 		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)
-			}
+	});
+	for (const profile of profiles) validateRuntimeProfilePrerequisites(profile, cfg.profilePrerequisiteEnv, cfg.profilePrerequisitePath);
+	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
+	const mainRepo = findMainWorktree();
+	const runtimes = /* @__PURE__ */ new Map();
+	for (const profile of profiles) {
+		const common = parseCommonOptions(values, { runtimeDefaults: {
+			leaseTtlSec: profile.leaseTtlSec,
+			heartbeatIntervalMs: profile.heartbeatIntervalMs,
+			maxBatchSize: profile.maxBatchSize,
+			warmSessionTtlSec: resolveProfileWarmSessionTtlSec(profile)
+		} });
+		const sandbox = {
+			config: profile.sandboxConfig,
+			rootDir: profile.mountPath,
+			path: profile.source
+		};
+		const piAgentDir = ensurePiAgentDir(sandbox.rootDir, cfg.piCodingAgentDir);
+		const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
+		const slotIdentity = {
+			agentName: common.agent,
+			runtimeProfileId: profile.id
+		};
+		const executionPlans = createExecutionPlanCache({
+			stateDirs,
+			slotIdentity,
+			warmSessionTtlSec: common.warmSessionTtlSec,
+			slotRegistry
+		});
+		runtimes.set(profile.id, {
+			common,
+			profile,
+			sandbox,
+			stateDirs,
+			piAgentDir,
+			slotIdentity,
+			executionPlans
 		});
 	}
-	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 piAgentDir = ensurePiAgentDir(sandbox.rootDir, cfg.piCodingAgentDir);
+	const firstRuntime = runtimes.get(profiles[0].id);
+	if (!firstRuntime) throw new Error("No runtime profiles resolved");
+	const piAgentDir = firstRuntime.piAgentDir;
 	activatePiCodingAgentDir(piAgentDir.path);
-	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
-	const slotRegistry = new DaemonSlotRegistry(resolveDaemonStateStorageConfig(stateDirs.registryDbPath, cfg.agentDaemonStateDatabaseUrl));
-	const slotIdentity = {
-		agentName: common.agent,
-		provider,
-		model
-	};
-	const mainRepo = findMainWorktree();
-	const executionPlans = createExecutionPlanCache({
-		stateDirs,
-		slotIdentity,
-		warmSessionTtlSec: common.warmSessionTtlSec,
-		slotRegistry
-	});
 	const otelShutdown = await initWorkerOtel({
 		serviceName: opts.serviceName,
 		agentDir: ctx.agentDir,
 		endpoint: cfg.otelEndpoint,
 		resourceAttributes: {
 			"moltnet.team.id": teamId,
-			"moltnet.agent.name": common.agent,
-			"moltnet.llm.provider": provider,
-			"moltnet.llm.model": model,
-			...profile ? { "moltnet.daemon_profile.id": profile.id } : {}
+			"moltnet.agent.name": baseCommon.agent,
+			"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 || (common.debug ? "debug" : "info")
+		level: cfg.logLevel || (baseCommon.debug ? "debug" : "info")
 	});
 	const rootLogger = logger.child({
 		mode: opts.modeLabel,
-		agent: common.agent,
+		agent: baseCommon.agent,
 		teamId,
-		provider,
-		model,
-		...profile ? {
-			daemonProfileId: profile.id,
-			daemonProfileName: profile.name
-		} : {}
+		runtimeProfileIds: profiles.map((p) => p.id),
+		runtimeProfileNames: profiles.map((p) => p.name)
 	});
 	const abort = new AbortController();
 	let runtime = null;
@@ -10108,90 +10260,91 @@ async function runPolling(opts) {
 		}
 	});
 	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,
-		...profile ? {
-			profileId: profile.id,
-			profileSessionTtlSec: profile.sessionTtlSec,
-			profileWorkspaceTtlSec: profile.workspaceTtlSec
-		} : {},
+		profiles: profiles.map((profile) => {
+			const runtime = requireRuntime(runtimes, profile.id);
+			return {
+				id: profile.id,
+				name: profile.name,
+				provider: profile.provider,
+				model: profile.model,
+				sandbox: runtime.sandbox.path,
+				leaseTtlSec: runtime.common.leaseTtlSec,
+				heartbeatIntervalMs: runtime.common.heartbeatIntervalMs,
+				warmSessionTtlSec: runtime.common.warmSessionTtlSec,
+				profileSessionTtlSec: profile.sessionTtlSec,
+				profileWorkspaceTtlSec: profile.workspaceTtlSec
+			};
+		}),
 		piAgentDir: piAgentDir.path,
 		piAgentDirSource: piAgentDir.source
 	}, "agent-daemon.starting");
 	const outputs = [];
 	try {
-		const rawExecuteTask = createPiTaskExecutor({
-			agentName: common.agent,
-			mountPath: sandbox.rootDir,
-			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,
-				...profile ? { profileId: profile.id } : {},
+				profiles: profiles.map((profile) => ({
+					profileId: profile.id,
+					leaseTtlSec: requireRuntime(runtimes, profile.id).common.leaseTtlSec
+				})),
 				diaryIds: diaryIds.length > 0 ? diaryIds : void 0,
-				leaseTtlSec: common.leaseTtlSec,
+				leaseTtlSec: firstRuntime.common.leaseTtlSec,
 				listLimit,
 				pollIntervalMs,
 				maxPollIntervalMs,
 				signal: abort.signal,
 				stopWhenEmpty: opts.stopWhenEmpty,
-				debug: common.debug,
+				debug: baseCommon.debug,
 				logger: rootLogger,
 				slotRegistry
 			}),
-			makeReporter: () => new ApiTaskReporter({
-				tasks: ctx.agent.tasks,
-				leaseTtlSec: common.leaseTtlSec,
-				heartbeatIntervalMs: common.heartbeatIntervalMs,
-				maxBatchSize: common.maxBatchSize,
-				flushIntervalMs: common.flushIntervalMs
-			}),
+			makeReporter: (claimedTask) => {
+				const selected = runtimeForClaimedTask(runtimes, claimedTask);
+				return new ApiTaskReporter({
+					tasks: ctx.agent.tasks,
+					leaseTtlSec: selected.common.leaseTtlSec,
+					heartbeatIntervalMs: selected.common.heartbeatIntervalMs,
+					maxBatchSize: selected.common.maxBatchSize,
+					flushIntervalMs: selected.common.flushIntervalMs
+				});
+			},
 			onTaskFinished: async (output, claimedTask) => {
-				const resolved = await slotRegistry.findLatestProducerSlotByTaskAttempt(claimedTask.task.id, claimedTask.attemptN);
+				const selected = runtimeForClaimedTask(runtimes, claimedTask);
+				const resolved = await slotRegistry.findLatestSlotByTaskAttempt(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN);
 				return finalizeTask(ctx.agent, output, {
 					task: claimedTask.task,
 					slot: resolved ? { expiresAtMs: resolved.slot.expiresAtMs } : null,
 					writeCorrelationAnchors: makePrBodyAnchorWriter({
 						gh: createGhCliClient(),
-						logger: rootLogger
+						logger: rootLogger.child({
+							runtimeProfileId: selected.profile.id,
+							runtimeProfileName: selected.profile.name
+						})
 					}),
 					log: (msg, err) => rootLogger.warn({ err }, msg)
 				});
 			},
 			executeTask: async (claimedTask, reporter) => {
+				const { common, executionPlans, profile, sandbox, slotIdentity, stateDirs } = runtimeForClaimedTask(runtimes, claimedTask);
+				const taskLogger = rootLogger.child({
+					runtimeProfileId: profile.id,
+					runtimeProfileName: profile.name,
+					provider: profile.provider,
+					model: profile.model
+				});
 				let executionPlan;
 				try {
 					executionPlan = await executionPlans.getOrCreate(claimedTask);
 				} catch (err) {
 					const message = err instanceof Error ? err.message : String(err);
-					rootLogger.warn({
+					taskLogger.warn({
 						taskId: claimedTask.task.id,
 						attemptN: claimedTask.attemptN,
 						err: message
@@ -10215,20 +10368,7 @@ async function runPolling(opts) {
 					};
 				}
 				const sessionDescriptor = executionPlan.descriptor;
-				let expired;
-				try {
-					expired = await slotRegistry.reapExpiredSlots();
-					if (expired.length > 0) rootLogger.info({
-						expiredCount: expired.length,
-						slotKeys: expired.map((item) => item.slot.slotKey)
-					}, "agent-daemon.daemon_slots_reaped");
-				} catch (err) {
-					rootLogger.error({
-						phase: "daemon_slot_reap",
-						err: err instanceof Error ? err.message : String(err)
-					}, "agent-daemon.daemon_slot_reap_failed");
-				}
-				rootLogger.debug({
+				taskLogger.debug({
 					taskId: claimedTask.task.id,
 					taskType: claimedTask.task.taskType,
 					resumable: sessionDescriptor.policy.resumable,
@@ -10277,6 +10417,10 @@ async function runPolling(opts) {
 				};
 				if (executionPlan.slotKey && executionPlan.sessionPersistence) await slotRegistry.beginSlot({
 					...slotIdentity,
+					runtimeProfileId: profile.id,
+					provider: profile.provider,
+					model: profile.model,
+					teamId: claimedTask.task.teamId,
 					slotKey: executionPlan.slotKey,
 					taskType: claimedTask.task.taskType,
 					sessionDir: executionPlan.sessionPersistence.sessionDir,
@@ -10286,14 +10430,34 @@ async function runPolling(opts) {
 					worktreeBranch: executionPlan.worktreeBranch,
 					workspaceKind: executionPlan.workspaceKind,
 					lastTaskId: claimedTask.task.id,
-					lastAttemptN: claimedTask.attemptN,
-					ttlSec: common.warmSessionTtlSec
+					lastAttemptN: claimedTask.attemptN
+				});
+				const rawExecuteTask = createPiTaskExecutor({
+					agentName: common.agent,
+					mountPath: sandbox.rootDir,
+					provider: profile.provider,
+					model: profile.model,
+					sandboxConfig: sandbox.config,
+					makeExecutionPlan: (task) => executionPlans.getOrCreate(task),
+					makeOnTurnEvent: makeTurnEventHandlerFactory(taskLogger),
+					maxTurns: common.maxTurns,
+					maxBashTimeouts: common.maxBashTimeouts
 				});
 				try {
-					return await executeTask(claimedTask, reporter);
+					active = {
+						taskId: claimedTask.task.id,
+						attemptN: claimedTask.attemptN
+					};
+					return await runWithDaemonRuntimeContext({
+						profileId: profile.id,
+						profileName: profile.name,
+						provider: profile.provider,
+						model: profile.model
+					}, () => rawExecuteTask(claimedTask, reporter));
 				} finally {
+					active = null;
 					executionPlans.delete(claimedTask);
-					if (executionPlan.slotKey) await slotRegistry.finishSlot(slotIdentity, executionPlan.slotKey, common.warmSessionTtlSec, 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);
 				}
 			}
 		});
@@ -10312,6 +10476,18 @@ function resolveRecordedWorkspacePath$1(mainRepo, stateRootDir, executionPlan) {
 	if (!executionPlan.workspaceId) return null;
 	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(mainRepo, ".worktrees", executionPlan.workspaceId);
 }
+function runtimeForClaimedTask(runtimes, claimedTask) {
+	if (!claimedTask.profileId) throw new Error(`Claimed task ${claimedTask.task.id} did not include a selected runtime profile`);
+	return requireRuntime(runtimes, claimedTask.profileId);
+}
+function requireRuntime(runtimes, profileId) {
+	const runtime = runtimes.get(profileId);
+	if (!runtime) throw new Error(`No runtime profile configured for ${profileId}`);
+	return runtime;
+}
+function parseProfileValues(raw) {
+	return (raw ?? []).map((s) => s.trim()).filter((s) => s.length > 0);
+}
 function parseCsv(raw) {
 	return (raw ?? "").split(",").map((s) => s.trim()).filter((s) => s.length > 0);
 }
@@ -10347,6 +10523,7 @@ async function runOnce(argv) {
 				type: "string",
 				short: "t"
 			},
+			team: { type: "string" },
 			sandbox: { type: "string" },
 			profile: { type: "string" }
 		}
@@ -10357,9 +10534,14 @@ async function runOnce(argv) {
 		return 1;
 	}
 	const taskId = values["task-id"];
+	if (!values.profile) {
+		console.error("Missing required flag: --profile\n");
+		console.error(ONCE_HELP);
+		return 1;
+	}
 	let opts;
 	try {
-		opts = parseCommonOptions(values, { requireProviderModel: !values.profile });
+		opts = parseCommonOptions(values);
 	} catch (err) {
 		if (err instanceof MissingRequiredOptionError) {
 			console.error(`${err.message}\n`);
@@ -10368,45 +10550,37 @@ async function runOnce(argv) {
 		}
 		throw err;
 	}
-	if (values.profile && values.sandbox) {
-		console.error("Cannot use --sandbox with --profile. Remote runtime profiles define sandbox policy.");
+	if (values.sandbox) {
+		console.error("Cannot use --sandbox. Remote runtime profiles define sandbox policy.");
 		return 1;
 	}
 	const cfg = loadConfig();
 	const ctx = await resolveAgentContext(opts.agent);
-	const profile = values.profile ? await resolveRuntimeProfile({
+	const profile = await resolveRuntimeProfile({
 		agent: ctx.agent,
 		profile: values.profile,
+		teamId: values.team,
 		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 ? {
+	});
+	validateRuntimeProfilePrerequisites(profile, cfg.profilePrerequisiteEnv, cfg.profilePrerequisitePath);
+	opts = parseCommonOptions(values, { runtimeDefaults: {
+		leaseTtlSec: profile.leaseTtlSec,
+		heartbeatIntervalMs: profile.heartbeatIntervalMs,
+		maxBatchSize: profile.maxBatchSize,
+		warmSessionTtlSec: resolveProfileWarmSessionTtlSec(profile)
+	} });
+	const sandbox = {
 		config: profile.sandboxConfig,
 		rootDir: profile.mountPath,
 		path: profile.source
-	} : resolveSandbox(process.cwd(), values.sandbox);
+	};
 	const piAgentDir = ensurePiAgentDir(sandbox.rootDir, cfg.piCodingAgentDir);
 	activatePiCodingAgentDir(piAgentDir.path);
 	const stateDirs = ensureDaemonStateDirs(sandbox.rootDir);
-	const slotRegistry = new DaemonSlotRegistry(resolveDaemonStateStorageConfig(stateDirs.registryDbPath, cfg.agentDaemonStateDatabaseUrl));
+	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
 	const slotIdentity = {
 		agentName: opts.agent,
-		provider,
-		model
+		runtimeProfileId: profile.id
 	};
 	const mainRepo = findMainWorktree();
 	const executionPlans = createExecutionPlanCache({
@@ -10422,9 +10596,9 @@ async function runOnce(argv) {
 		resourceAttributes: {
 			"moltnet.task.id": taskId,
 			"moltnet.agent.name": opts.agent,
-			"moltnet.llm.provider": provider,
-			"moltnet.llm.model": model,
-			...profile ? { "moltnet.daemon_profile.id": profile.id } : {}
+			"moltnet.llm.provider": profile.provider,
+			"moltnet.llm.model": profile.model,
+			"moltnet.runtime_profile.id": profile.id
 		}
 	});
 	const { logger, shutdown: shutdownLogger } = createRootLogger({
@@ -10434,12 +10608,10 @@ async function runOnce(argv) {
 	const rootLogger = logger.child({
 		mode: "once",
 		agent: opts.agent,
-		provider,
-		model,
-		...profile ? {
-			daemonProfileId: profile.id,
-			daemonProfileName: profile.name
-		} : {}
+		provider: profile.provider,
+		model: profile.model,
+		runtimeProfileId: profile.id,
+		runtimeProfileName: profile.name
 	});
 	rootLogger.info({
 		sandbox: sandbox.path,
@@ -10447,11 +10619,9 @@ async function runOnce(argv) {
 		leaseTtlSec: opts.leaseTtlSec,
 		heartbeatIntervalMs: opts.heartbeatIntervalMs,
 		warmSessionTtlSec: opts.warmSessionTtlSec,
-		...profile ? {
-			profileId: profile.id,
-			profileSessionTtlSec: profile.sessionTtlSec,
-			profileWorkspaceTtlSec: profile.workspaceTtlSec
-		} : {},
+		profileId: profile.id,
+		profileSessionTtlSec: profile.sessionTtlSec,
+		profileWorkspaceTtlSec: profile.workspaceTtlSec,
 		piAgentDir: piAgentDir.path,
 		piAgentDirSource: piAgentDir.source
 	}, "agent-daemon.starting");
@@ -10485,8 +10655,8 @@ async function runOnce(argv) {
 		const rawExecuteTask = createPiTaskExecutor({
 			agentName: opts.agent,
 			mountPath: sandbox.rootDir,
-			provider,
-			model,
+			provider: profile.provider,
+			model: profile.model,
 			sandboxConfig: sandbox.config,
 			makeExecutionPlan: (claimedTask) => executionPlans.getOrCreate(claimedTask),
 			onTurnEvent: makeTurnEventHandler(rootLogger, { taskId }),
@@ -10494,18 +10664,6 @@ async function runOnce(argv) {
 			maxBashTimeouts: opts.maxBashTimeouts
 		});
 		const executeTask = async (claimedTask, reporter) => {
-			try {
-				const expired = await slotRegistry.reapExpiredSlots();
-				if (expired.length > 0) rootLogger.info({
-					expiredCount: expired.length,
-					slotKeys: expired.map((item) => item.slot.slotKey)
-				}, "agent-daemon.daemon_slots_reaped");
-			} catch (err) {
-				rootLogger.error({
-					phase: "daemon_slot_reap",
-					err: err instanceof Error ? err.message : String(err)
-				}, "agent-daemon.daemon_slot_reap_failed");
-			}
 			let executionPlan;
 			try {
 				executionPlan = await executionPlans.getOrCreate(claimedTask);
@@ -10536,6 +10694,10 @@ async function runOnce(argv) {
 			}
 			if (executionPlan.slotKey && executionPlan.sessionPersistence) await slotRegistry.beginSlot({
 				...slotIdentity,
+				runtimeProfileId: profile.id,
+				provider: profile.provider,
+				model: profile.model,
+				teamId: claimedTask.task.teamId,
 				slotKey: executionPlan.slotKey,
 				taskType: claimedTask.task.taskType,
 				sessionDir: executionPlan.sessionPersistence.sessionDir,
@@ -10545,16 +10707,20 @@ async function runOnce(argv) {
 				worktreeBranch: executionPlan.worktreeBranch,
 				workspaceKind: executionPlan.workspaceKind,
 				lastTaskId: claimedTask.task.id,
-				lastAttemptN: claimedTask.attemptN,
-				ttlSec: opts.warmSessionTtlSec
+				lastAttemptN: claimedTask.attemptN
 			});
 			activeAttemptN = claimedTask.attemptN;
 			try {
-				return await rawExecuteTask(claimedTask, reporter);
+				return await runWithDaemonRuntimeContext({
+					profileId: profile.id,
+					profileName: profile.name,
+					provider: profile.provider,
+					model: profile.model
+				}, () => 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);
+				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);
 			}
 		};
 		const writeCorrelationAnchors = makePrBodyAnchorWriter({
@@ -10567,7 +10733,7 @@ async function runOnce(argv) {
 				agent: ctx.agent,
 				taskId,
 				leaseTtlSec: opts.leaseTtlSec,
-				...profile ? { profileId: profile.id } : {}
+				profileId: profile.id
 			}),
 			makeReporter: () => new ApiTaskReporter({
 				tasks: ctx.agent.tasks,
@@ -10577,7 +10743,7 @@ async function runOnce(argv) {
 				flushIntervalMs: opts.flushIntervalMs
 			}),
 			onTaskFinished: async (output, claimedTask) => {
-				const resolved = await slotRegistry.findLatestProducerSlotByTaskAttempt(claimedTask.task.id, claimedTask.attemptN);
+				const resolved = await slotRegistry.findLatestSlotByTaskAttempt(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN);
 				return finalizeTask(ctx.agent, output, {
 					task: claimedTask.task,
 					slot: resolved ? { expiresAtMs: resolved.slot.expiresAtMs } : null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/agent-daemon",
-  "version": "0.19.1",
+  "version": "0.21.0",
   "license": "AGPL-3.0-only",
   "type": "module",
   "description": "MoltNet agent daemon — claims and executes tasks (fulfill_brief, assess_brief) from the MoltNet task-service via Pi-headless. CLI: moltnet-agent.",
@@ -45,10 +45,9 @@
     "@opentelemetry/semantic-conventions": "^1.39.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
-    "@themoltnet/agent-daemon-state": "0.3.0",
-    "@themoltnet/sdk": "0.108.0",
-    "@themoltnet/agent-runtime": "0.26.0",
-    "@themoltnet/pi-extension": "0.26.0"
+    "@themoltnet/agent-runtime": "0.28.0",
+    "@themoltnet/pi-extension": "0.26.2",
+    "@themoltnet/sdk": "0.109.0"
   },
   "devDependencies": {
     "tsx": "^4.7.0",
@@ -57,8 +56,8 @@
     "vitest": "^3.0.0",
     "@moltnet/crypto-service": "0.1.0",
     "@moltnet/observability": "0.1.0",
-    "@moltnet/tasks": "0.1.0",
-    "@moltnet/bootstrap": "0.1.0"
+    "@moltnet/bootstrap": "0.1.0",
+    "@moltnet/tasks": "0.1.0"
   },
   "nx": {
     "tags": [
@@ -94,8 +93,7 @@
     "dev": "tsx watch src/main.ts",
     "start": "node dist/main.js",
     "build": "vite build",
-    "check:pack": "tsx ../../tools/src/check-pack.ts --package . && pnpm run smoke:pack && pnpm run smoke:pack:state",
-    "smoke:pack": "tsx ../../tools/src/smoke-pack.ts --package . --bin moltnet-agent --args --help --expect \"long-running task worker for MoltNet\"",
-    "smoke:pack:state": "tsx ../../tools/src/smoke-agent-daemon-state-pack.ts"
+    "check:pack": "tsx ../../tools/src/check-pack.ts --package . && pnpm run smoke:pack",
+    "smoke:pack": "tsx ../../tools/src/smoke-pack.ts --package . --bin moltnet-agent --args --help --expect \"long-running task worker for MoltNet\""
   }
 }