@themoltnet/agent-daemon 0.20.0 → 0.22.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
 {
@@ -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

@@ -12,7 +12,7 @@ import { parseArgs, promisify } from "node:util";
 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, readdirSync } 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";
@@ -21,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.
@@ -4571,7 +4572,7 @@ _Object_({
 			minLength: 1,
 			maxLength: 100
 		}),
-		daemonProfileId: Union([String$1({ format: "uuid" }), Null()]),
+		runtimeProfileId: Union([String$1({ format: "uuid" }), Null()]),
 		provider: String$1({
 			minLength: 1,
 			maxLength: 100
@@ -4602,7 +4603,7 @@ _Object_({
 		minLength: 1,
 		maxLength: 100
 	}),
-	daemonProfileId: Optional(String$1({ format: "uuid" })),
+	runtimeProfileId: String$1({ format: "uuid" }),
 	provider: String$1({
 		minLength: 1,
 		maxLength: 100
@@ -4633,6 +4634,7 @@ _Object_({
 		minLength: 1,
 		maxLength: 100
 	}),
+	runtimeProfileId: String$1({ format: "uuid" }),
 	provider: String$1({
 		minLength: 1,
 		maxLength: 100
@@ -9121,23 +9123,16 @@ _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 <agent-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.
+  --agent-root <path>         Directory that owns .moltnet/<agent>. Default:
+                              CWD, with git root fallback when available.
   --lease-ttl-sec <n>         Sliding liveness window. Silence longer than
                               this ends the attempt with lease_expired.
                               Default: 300.
@@ -9177,24 +9172,21 @@ Commands:
 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.
+  - <agent-root>/.moltnet/<agent>/moltnet.json — credentials (see --agent-root)
+  - --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:
@@ -9211,38 +9203,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
@@ -9251,7 +9243,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()}
@@ -9266,8 +9257,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");
 }
@@ -9290,18 +9280,34 @@ function activatePiCodingAgentDir(path) {
 /**
 * Resolve the agent's MoltNet credentials directory and connect via SDK.
 *
-* Looks under `<repo-root>/.moltnet/<agentName>/`. Fails fast if the dir
-* is missing — credentials are required, the daemon never falls back to
-* unauthenticated calls.
+* Looks under an explicit agent root first, then falls back to the git root
+* when available. Fails fast if the dir is missing — credentials are required,
+* the daemon never falls back to unauthenticated calls.
 */
-async function resolveAgentContext(agentName) {
+async function resolveAgentContext(agentName, options = {}) {
 	if (!/^[a-zA-Z0-9_-]+$/.test(agentName)) throw new Error(`Invalid agent name "${agentName}": must match /^[a-zA-Z0-9_-]+$/`);
-	const agentDir = join(execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim(), ".moltnet", agentName);
-	if (!existsSync(join(agentDir, "moltnet.json"))) throw new Error(`Missing credentials at ${agentDir}/moltnet.json. Run the agent onboarding flow first.`);
-	return {
-		agentDir,
-		agent: await connect({ configDir: agentDir })
-	};
+	const roots = resolveCredentialRoots(options.agentRootDir);
+	for (const rootDir of roots) {
+		const agentDir = join(rootDir, ".moltnet", agentName);
+		if (existsSync(join(agentDir, "moltnet.json"))) return {
+			agentDir,
+			agentRootDir: rootDir,
+			agent: await connect({ configDir: agentDir })
+		};
+	}
+	const tried = roots.map((root) => join(root, ".moltnet", agentName));
+	throw new Error(`Missing credentials for ${agentName}. Checked ${tried.join(", ")}. Run the agent onboarding flow first.`);
+}
+function resolveCredentialRoots(agentRootDir) {
+	const roots = agentRootDir ? [agentRootDir] : [];
+	try {
+		const gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+			encoding: "utf8",
+			stdio: "pipe"
+		}).trim();
+		if (!roots.includes(gitRoot)) roots.push(gitRoot);
+	} catch {}
+	return roots;
 }
 //#endregion
 //#region src/lib/correlation.ts
@@ -9472,10 +9478,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(":");
@@ -9790,7 +9794,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,
@@ -9798,13 +9801,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),
@@ -9833,14 +9832,7 @@ function commonOptionDefs() {
 			type: "string",
 			short: "a"
 		},
-		model: {
-			type: "string",
-			short: "m"
-		},
-		provider: {
-			type: "string",
-			short: "p"
-		},
+		"agent-root": { type: "string" },
 		"lease-ttl-sec": { type: "string" },
 		"heartbeat-interval-ms": { type: "string" },
 		"max-batch-size": { type: "string" },
@@ -9919,6 +9911,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) {
@@ -9952,6 +9950,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));
@@ -9986,12 +10000,12 @@ function isExecutable(path) {
 //#endregion
 //#region src/lib/runtime-slots.ts
 function createApiRuntimeSlotStore(args) {
-	const { agent, daemonProfileId } = args;
+	const { agent } = args;
 	return {
 		async beginSlot(input) {
 			await agent.runtimeSlots.begin({
 				agentName: input.agentName,
-				daemonProfileId: daemonProfileId ?? void 0,
+				runtimeProfileId: input.runtimeProfileId,
 				lastAttemptN: input.lastAttemptN,
 				lastTaskId: input.lastTaskId,
 				model: input.model,
@@ -10006,12 +10020,13 @@ function createApiRuntimeSlotStore(args) {
 				worktreePath: input.worktreePath ?? void 0
 			}, { teamId: input.teamId });
 		},
-		async finishSlot(teamId, taskId, attemptN, identity, slotKey, sessionPath) {
+		async finishSlot(teamId, taskId, attemptN, identity, slotKey, provider, model, sessionPath) {
 			await agent.runtimeSlots.finish({
 				agentName: identity.agentName,
 				attemptN,
-				model: identity.model,
-				provider: identity.provider,
+				runtimeProfileId: identity.runtimeProfileId,
+				model,
+				provider,
 				sessionPath: sessionPath ?? void 0,
 				slotKey,
 				taskId
@@ -10041,34 +10056,6 @@ function createApiRuntimeSlotStore(args) {
 	};
 }
 //#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)}`);
-	}
-	return {
-		config,
-		rootDir: dirname(path),
-		path
-	};
-}
-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) {
 	const proc = opts.proc ?? process;
@@ -10150,7 +10137,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) {
@@ -10159,6 +10149,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"]));
@@ -10168,9 +10164,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`);
@@ -10182,84 +10178,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 agentRootDir = resolve(process.cwd(), values["agent-root"] ?? process.cwd());
+	const ctx = await resolveAgentContext(baseCommon.agent, { agentRootDir });
+	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 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 = createApiRuntimeSlotStore({
-		agent: ctx.agent,
-		daemonProfileId: profile?.id ?? null
-	});
-	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;
@@ -10285,90 +10279,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 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
@@ -10392,7 +10387,7 @@ async function runPolling(opts) {
 					};
 				}
 				const sessionDescriptor = executionPlan.descriptor;
-				rootLogger.debug({
+				taskLogger.debug({
 					taskId: claimedTask.task.id,
 					taskType: claimedTask.task.taskType,
 					resumable: sessionDescriptor.policy.resumable,
@@ -10441,23 +10436,48 @@ 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,
 					sessionPath: resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir),
 					workspaceId: executionPlan.workspaceId,
-					worktreePath: resolveRecordedWorkspacePath$1(mainRepo, stateDirs.rootDir, executionPlan),
+					worktreePath: resolveRecordedWorkspacePath$1(stateDirs.rootDir, executionPlan),
 					worktreeBranch: executionPlan.worktreeBranch,
 					workspaceKind: executionPlan.workspaceKind,
 					lastTaskId: claimedTask.task.id,
 					lastAttemptN: claimedTask.attemptN
 				});
+				const rawExecuteTask = createPiTaskExecutor({
+					agentName: common.agent,
+					agentRootDir: ctx.agentRootDir,
+					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(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN, slotIdentity, executionPlan.slotKey, 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);
 				}
 			}
 		});
@@ -10472,9 +10492,21 @@ async function runPolling(opts) {
 		await shutdownLogger();
 	}
 }
-function resolveRecordedWorkspacePath$1(mainRepo, stateRootDir, executionPlan) {
+function resolveRecordedWorkspacePath$1(stateRootDir, executionPlan) {
 	if (!executionPlan.workspaceId) return null;
-	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(mainRepo, ".worktrees", executionPlan.workspaceId);
+	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(findMainWorktree(), ".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);
@@ -10511,6 +10543,7 @@ async function runOnce(argv) {
 				type: "string",
 				short: "t"
 			},
+			team: { type: "string" },
 			sandbox: { type: "string" },
 			profile: { type: "string" }
 		}
@@ -10521,9 +10554,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`);
@@ -10532,50 +10570,40 @@ 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 initialOpts = opts;
+	const agentRootDir = resolve(process.cwd(), values["agent-root"] ?? process.cwd());
+	const ctx = await resolveAgentContext(initialOpts.agent, { agentRootDir });
+	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 = createApiRuntimeSlotStore({
-		agent: ctx.agent,
-		daemonProfileId: profile?.id ?? null
-	});
+	const slotRegistry = createApiRuntimeSlotStore({ agent: ctx.agent });
 	const slotIdentity = {
 		agentName: opts.agent,
-		provider,
-		model
+		runtimeProfileId: profile.id
 	};
-	const mainRepo = findMainWorktree();
 	const executionPlans = createExecutionPlanCache({
 		stateDirs,
 		slotIdentity,
@@ -10589,9 +10617,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({
@@ -10601,12 +10629,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,
@@ -10614,11 +10640,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");
@@ -10651,9 +10675,10 @@ async function runOnce(argv) {
 	try {
 		const rawExecuteTask = createPiTaskExecutor({
 			agentName: opts.agent,
+			agentRootDir: ctx.agentRootDir,
 			mountPath: sandbox.rootDir,
-			provider,
-			model,
+			provider: profile.provider,
+			model: profile.model,
 			sandboxConfig: sandbox.config,
 			makeExecutionPlan: (claimedTask) => executionPlans.getOrCreate(claimedTask),
 			onTurnEvent: makeTurnEventHandler(rootLogger, { taskId }),
@@ -10691,13 +10716,16 @@ 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,
 				sessionPath: resolveLatestPiSessionPath(executionPlan.sessionPersistence.sessionDir),
 				workspaceId: executionPlan.workspaceId,
-				worktreePath: resolveRecordedWorkspacePath(mainRepo, stateDirs.rootDir, executionPlan),
+				worktreePath: resolveRecordedWorkspacePath(stateDirs.rootDir, executionPlan),
 				worktreeBranch: executionPlan.worktreeBranch,
 				workspaceKind: executionPlan.workspaceKind,
 				lastTaskId: claimedTask.task.id,
@@ -10705,11 +10733,16 @@ async function runOnce(argv) {
 			});
 			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(claimedTask.task.teamId, claimedTask.task.id, claimedTask.attemptN, slotIdentity, executionPlan.slotKey, 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({
@@ -10722,7 +10755,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,
@@ -10757,9 +10790,9 @@ async function runOnce(argv) {
 		await shutdownLogger();
 	}
 }
-function resolveRecordedWorkspacePath(mainRepo, stateRootDir, executionPlan) {
+function resolveRecordedWorkspacePath(stateRootDir, executionPlan) {
 	if (!executionPlan.workspaceId) return null;
-	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(mainRepo, ".worktrees", executionPlan.workspaceId);
+	return executionPlan.workspaceMode === "scratch_mount" ? join(stateRootDir, "task-workspaces", executionPlan.workspaceId) : join(findMainWorktree(), ".worktrees", executionPlan.workspaceId);
 }
 //#endregion
 //#region src/cli/poll.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/agent-daemon",
-  "version": "0.20.0",
+  "version": "0.22.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,9 +45,9 @@
     "@opentelemetry/semantic-conventions": "^1.39.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
-    "@themoltnet/agent-runtime": "0.27.0",
-    "@themoltnet/pi-extension": "0.26.1",
-    "@themoltnet/sdk": "0.109.0"
+    "@themoltnet/sdk": "0.109.0",
+    "@themoltnet/pi-extension": "0.26.3",
+    "@themoltnet/agent-runtime": "0.28.0"
   },
   "devDependencies": {
     "tsx": "^4.7.0",
@@ -56,8 +56,8 @@
     "vitest": "^3.0.0",
     "@moltnet/bootstrap": "0.1.0",
     "@moltnet/crypto-service": "0.1.0",
-    "@moltnet/observability": "0.1.0",
-    "@moltnet/tasks": "0.1.0"
+    "@moltnet/tasks": "0.1.0",
+    "@moltnet/observability": "0.1.0"
   },
   "nx": {
     "tags": [