@tangle-network/agent-runtime 0.111.0 → 0.112.0

package/dist/{supervise-CeZtA1wu.js → supervise-6jSTe0kO.js}

@@ -1,7 +1,7 @@
 import { c as RuntimeRunStateError, i as ConfigError, o as NotFoundError, t as AgentEvalError$1, u as ValidationError } from "./errors-DEAvWQPy.js";
 import { a as mapWithConcurrency, c as sleep, d as throwIfAborted, f as withTimeout, l as stringifySafe, n as addTokenUsage, o as randomSuffix, p as zeroTokenUsage, r as deleteBoxSafe, s as randomUuid, t as abortError, u as throwAbort } from "./util-Cc9g9Y-o.js";
 import { a as contentAddress, i as InMemorySpawnJournal, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore } from "./spawn-journal-DLhnom3e.js";
-import { A as createWorktree, C as routerChatWithUsage, D as runWorktreeChecks, O as runWorktreeHarness, T as runBrainLoop, a as runFinalizer, i as pickBestDelivered, j as removeWorktree, k as captureWorktreeDiff, l as withDriverExecutor, n as bestDelivered, o as runTree, t as createSupervisor, x as routerBrain, y as createActivityLog } from "./supervisor-ByCPHcp9.js";
+import { A as createWorktree, C as routerChatWithUsage, D as runWorktreeChecks, O as runWorktreeHarness, T as runBrainLoop, a as runFinalizer, i as pickBestDelivered, j as removeWorktree, k as captureWorktreeDiff, l as withDriverExecutor, n as bestDelivered, o as runTree, t as createSupervisor, x as routerBrain, y as createActivityLog } from "./supervisor-B4hOPKJV.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
 import { a as notifySandboxEventObserver, n as extractLlmCallEvent } from "./sandbox-events-DeI5xX8P.js";
 import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, s as buildBackendOptions } from "./environment-provider-BsHpW4Dp.js";
@@ -9,6 +9,7 @@ import { r as buildLoopSpanNodes } from "./otel-export-D34IQW1C.js";
 import { t as createStdioToolServer } from "./tool-server-RcWgLIsL.js";
 import { n as UI_LENSES } from "./substrate-B0TYNrXn.js";
 import { argHash, computeFindingId, errorStreakDetector, estimateCost, isModelPriced, makeFinding, observeAll, repeatedActionDetector } from "@tangle-network/agent-eval";
+import { agentProfileSchema } from "@tangle-network/agent-interface";
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path, { dirname } from "node:path";
@@ -3956,6 +3957,15 @@ function createEventBus(now = Date.now) {
 }
 //#endregion
 //#region src/mcp/tools/coordination.ts
+/**
+*
+* MCP binding for a live `Scope`. A sandbox driver gets the same small verbs
+* the in-process driver has: spawn, observe, await, steer, ask/answer, analyze,
+* and stop. Settled outputs remain Scope artifacts; product code can project
+* them into any UI/report envelope it needs.
+*
+* @experimental
+*/
 /** Default ceiling for a single `await_event` block (ms). Chosen well under any reasonable remote
 *  MCP client request timeout so the call returns a `pending` liveness snapshot instead of erroring;
 *  the supervisor re-polls until the worker settles. */
@@ -3981,6 +3991,179 @@ const idArg = {
 	type: "string",
 	description: "The workerId returned by spawn_agent."
 };
+/**
+* Strip zod's object-KEY CODEC artifact from a derived JSON Schema, at every depth.
+*
+* `z.record(z.string(), …)` converts to `propertyNames: { type: 'string', pattern:
+* '^u(?:[0-9a-f]{4})*$' }` — a marker of the lossy key round-trip, not a constraint anything
+* enforces: `agentProfileSchema.safeParse({ name: 'r', tools: { bash: true, Read: false } })`
+* succeeds with those plain keys. Published verbatim it reads to a model as "every key must be a
+* run of hex quads", and the model either emits hex-encoded garbage keys or drops the field —
+* on `tools`, `permissions`, `metadata`, `mcp`, `mcp.*.env`, and `model.metadata`, which is most
+* of what a parent actually configures.
+*
+* Every `propertyNames` in the canonical profile schema is this artifact (25 of 25 at Interface
+* 0.40), and the canonical schema constrains no key by pattern, so dropping the keyword outright
+* loses nothing real and cannot be defeated by zod changing the encoding's exact regex.
+*
+* Rebuilds rather than mutates: the canonical conversion output must stay untouched for callers
+* that compare against it.
+*/
+const stripKeyCodecArtifacts = (node) => {
+	if (Array.isArray(node)) return node.map(stripKeyCodecArtifacts);
+	if (!node || typeof node !== "object") return node;
+	return Object.fromEntries(Object.entries(node).filter(([key]) => key !== "propertyNames").map(([key, value]) => [key, stripKeyCodecArtifacts(value)]));
+};
+/** The canonical profile fields a spawning parent actually sets on a child, in the order a reader
+*  needs them, each with the description published alongside it. Everything else stays legal to
+*  pass — see {@link deriveSpawnProfileArg}.
+*
+*  Why these eleven, with the measured numbers (serialized JSON bytes, Interface 0.40). The
+*  canonical `properties` map is 10629 bytes, against 2424 bytes for every argument of every other
+*  coordination tool COMBINED — publishing it whole makes one parameter four times the rest of the
+*  surface a driver re-reads each turn. Of the seven omitted fields (tags, connections, subagents,
+*  hooks, modes, confidential, extensions) none is something a parent hands a worker; `permissions`
+*  (321 bytes) IS, so it is published — a child that must not touch the network or the filesystem
+*  is fenced there and nowhere else. `mcp` (2663 bytes) and `resources` (3122 bytes) are the two a
+*  parent is least likely to author inline and were together 85% of the published cost, so they
+*  carry a brief shape plus a description naming the full form instead of the canonical sub-tree. */
+const spawnProfileFields = [
+	{
+		name: "name",
+		description: "Short identifier for this child, e.g. \"researcher\" or \"patch-writer\". A child normally sets it to its role; it shows up in traces and worker labels."
+	},
+	{
+		name: "description",
+		description: "One line saying what this child is for. Read by humans and by a parent listing its workers."
+	},
+	{
+		name: "version",
+		description: "Optional version string for this profile, so two revisions of the same role are distinguishable in evidence. A child usually omits it."
+	},
+	{
+		name: "harness",
+		description: "Which coding backend runs the child. Omit to inherit the run default; set it only when this child needs a specific backend (e.g. a long refactor on \"claude-code\")."
+	},
+	{
+		name: "model",
+		description: "Model routing: `default` model id, optional `small` for cheap sub-calls, `provider`, and `reasoningEffort`. A child typically sets `default` and `reasoningEffort` — raise effort for a hard reasoning task, lower it for bulk mechanical work."
+	},
+	{
+		name: "prompt",
+		description: "The child's standing instructions: `systemPrompt` (who it is and how it works) and `instructions` (durable rules). This is the role; the separate `task` argument carries what to do right now. A child with no systemPrompt has no role — always set one."
+	},
+	{
+		name: "tools",
+		description: "Per-tool on/off map keyed by tool name, e.g. `{ \"bash\": true, \"webfetch\": false }`. Omit to inherit the backend's default tool set; set it to narrow a child to the tools its task needs. Keys are plain tool names."
+	},
+	{
+		name: "permissions",
+		description: "Per-tool permission decisions: each tool name maps to \"allow\", \"deny\", or \"ask\", or to a nested map of finer-grained rules. This is where a parent fences a child it does not fully trust — a read-only child denies write and network tools here, not in `tools`."
+	},
+	{
+		name: "mcp",
+		description: "MCP tool servers to mount for the child, keyed by server name. Brief form: each value is either `{ transport: \"stdio\", command, args?, env?, cwd? }` or `{ transport: \"sse\" | \"http\", url, headers? }`. A child normally sets this only when it needs a tool server the task requires; the canonical AgentProfile schema carries the full form (secret-ref values for env/headers, per-server metadata) and governs validation.",
+		brief: {
+			type: "object",
+			additionalProperties: { type: "object" }
+		}
+	},
+	{
+		name: "resources",
+		description: "Files, tools, skills, and agents materialized into the child workspace before it starts. Brief form: `{ files?, tools?, skills?, agents? }`, each an array whose entries are `{ kind: \"inline\", name, content }` or `{ kind: \"github\", repository?, path, ref? }` (`files` entries wrap that as `{ path, resource, executable? }`). A child typically gets `files` for seed inputs and `skills` for a procedure it must follow; the canonical AgentProfile schema carries the full form and governs validation.",
+		brief: {
+			type: "object",
+			properties: {
+				files: {
+					type: "array",
+					items: { type: "object" }
+				},
+				tools: {
+					type: "array",
+					items: { type: "object" }
+				},
+				skills: {
+					type: "array",
+					items: { type: "object" }
+				},
+				agents: {
+					type: "array",
+					items: { type: "object" }
+				}
+			},
+			additionalProperties: true
+		}
+	},
+	{
+		name: "metadata",
+		description: "Free-form key/value bag carried with the profile (plain string keys). Use it for run bookkeeping a reader will want later; it does not change how the child executes."
+	}
+];
+/**
+* Build the published shape of `spawn_agent`'s `profile` argument from the canonical
+* `agentProfileSchema` conversion's `properties` map, so it cannot drift from the profile the
+* runtime materializes.
+*
+* DEGRADES, never throws. A canonical field that is absent — renamed or removed upstream — is
+* simply omitted from the published shape, and a canonical schema that is no longer an object
+* publishes no properties at all. This function is reached from a statically-imported module, so a
+* throw here bricks `import '@tangle-network/agent-runtime/kernel'` for every consumer over an
+* upstream rename that costs them, at worst, one advisory field. The drift itself is still caught
+* loudly — as a test assertion in `tests/kernel/coordination.test.ts`, in CI, where it is our
+* problem rather than at a consumer's import, where it is theirs.
+*
+* Permissive on purpose: `additionalProperties: true` with no `required` list, so every canonical
+* field this shape omits stays legal to pass. This tool layer performs no profile validation.
+*
+* @internal exported for the drift and degradation tests; not part of the package's public API.
+*/
+function deriveSpawnProfileArg(canonicalProperties) {
+	const published = [];
+	for (const field of spawnProfileFields) {
+		const canonical = canonicalProperties?.[field.name];
+		if (canonical === void 0) continue;
+		const shape = field.brief ?? stripKeyCodecArtifacts(canonical);
+		published.push([field.name, {
+			...shape,
+			description: field.description
+		}]);
+	}
+	return {
+		type: "object",
+		description: "The child agent profile to run — this is the shape the DEFAULT worker seam accepts; a run wired with a custom makeWorkerAgent may accept a different one. The properties below are derived from the canonical AgentProfile schema and reduced to what a spawning parent sets (`mcp` and `resources` in a brief form); every other canonical field — tags, connections, subagents, hooks, modes, confidential, extensions — may still be passed. This tool does not validate the profile: the canonical AgentProfile schema governs validation downstream.",
+		properties: Object.fromEntries(published),
+		additionalProperties: true
+	};
+}
+spawnProfileFields.map((f) => f.name);
+let spawnProfileArgCache;
+/** The published `profile` shape, computed on FIRST tool-definition access and memoized — not at
+*  module load. The conversion walks the whole canonical profile tree, and the strip walk rebuilds
+*  it: 3.5ms on the first `createCoordinationTools`, 0.017ms on every later one (measured, Interface
+*  0.40, node 24). `src/runtime/index.ts` imports this module statically, so paying that at import
+*  taxes every consumer of the kernel entrypoint — including the ones that never build a
+*  coordination toolbox. The memo keeps it at once per process for the ones that do.
+*
+*  Conversion choices. `io: 'input'` is the CALLER's view — pre-default, pre-transform — which is
+*  what a spawning parent may pass, not what the runtime ends up holding. `unrepresentable: 'any'`
+*  keeps the conversion total: the canonical schema contains transforms with no JSON Schema form,
+*  and zod's default is to throw on them, which would leave the tool with no published shape. */
+function spawnProfileArg() {
+	if (!spawnProfileArgCache) spawnProfileArgCache = deepFreeze(deriveSpawnProfileArg(agentProfileSchema.toJSONSchema({
+		io: "input",
+		target: "draft-07",
+		unrepresentable: "any"
+	}).properties));
+	return spawnProfileArgCache;
+}
+/** Freeze a JSON-Schema tree. The derived schema is plain JSON data with no cycles. */
+function deepFreeze(value) {
+	if (value && typeof value === "object" && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const nested of Object.values(value)) deepFreeze(nested);
+	}
+	return value;
+}
 /** Build the driver's MCP tools over a live scope. */
 function createCoordinationTools(opts) {
 	const deliverable = opts.deliverable;
@@ -4311,7 +4494,7 @@ function createCoordinationTools(opts) {
 			inputSchema: {
 				type: "object",
 				properties: {
-					profile: { description: "The worker/driver profile to run." },
+					profile: spawnProfileArg(),
 					task: { description: "The task the worker should perform." },
 					label: {
 						type: "string",
@@ -7340,9 +7523,21 @@ function createInProcessTransport() {
 *
 * @experimental
 */
+/** Hosts that reach only this machine, including the IPv4-mapped and bracketed IPv6 spellings a
+*  caller may pass through from config. A name that is not recognizably loopback counts as REMOTE:
+*  whether it resolves to a loopback interface is not knowable here, and the safe direction of that
+*  doubt is "exposed". */
+function isLoopbackHost(host) {
+	const h = host.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
+	if (h === "localhost" || h === "::1" || h === "0:0:0:0:0:0:0:1" || h === "::ffff:127.0.0.1") return true;
+	return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h);
+}
 /** Stand up the coordination MCP over a live scope. The HOST address is `127.0.0.1` (the bridge runs
-*  opencode locally, same host); pass `host` to bind elsewhere when the harness is remote. */
+*  opencode locally, same host); pass `host` to bind elsewhere when the harness is remote — a
+*  non-loopback host additionally requires `allowUnauthenticatedRemote`. */
 async function serveCoordinationMcp(opts) {
+	const host = opts.host ?? "127.0.0.1";
+	if (!isLoopbackHost(host) && opts.allowUnauthenticatedRemote !== true) throw new ConfigError(`coordination host=${JSON.stringify(host)} is not a loopback address and the coordination MCP has no authentication: any client that can reach the port could call spawn_agent/steer_agent and spend this run's budget. Bind a loopback host ("127.0.0.1", "localhost", "::1"), or set allowUnauthenticatedRemote: true to accept that exposure explicitly.`);
 	const coord = createCoordinationTools({
 		scope: opts.scope,
 		blobs: opts.blobs,
@@ -7363,7 +7558,6 @@ async function serveCoordinationMcp(opts) {
 		extraTools: coord.tools,
 		serverName: "coordination"
 	});
-	const host = opts.host ?? "127.0.0.1";
 	const server = createServer((req, res) => {
 		if (req.method !== "POST") {
 			res.writeHead(405, { allow: "POST" });
@@ -7423,21 +7617,6 @@ async function serveCoordinationMcp(opts) {
 }
 //#endregion
 //#region src/runtime/supervise/supervisor-agent.ts
-/**
-* `supervisorAgent` — build a supervisor `Agent` FROM its profile. The brain is resolved from
-* `profile.harness` exactly as `createExecutor({ backend })` resolves a worker: backend-as-data,
-* no hand-built brain. The supervisor stops being special — it's one profile, materialized by the
-* same resolution rule as every other agent.
-*
-*  - `harness` null/undefined → the in-process router tool-loop: `driverAgent` over the
-*    canonical `ToolLoopChat`, built by `routerBrain` from the profile's model + the router seam.
-*  - `harness` a coding CLI (`claude-code`/`opencode`/`codex`/…) → a SANDBOXED harness drives the
-*    coordination verbs: `serveCoordinationMcp` exposes spawn/await/steer/stop over the live scope,
-*    and the caller's `driveHarness` runs the harness with that MCP mounted. The harness IS the brain.
-*
-* Both arms spawn children through the SAME `makeWorkerAgent` seam and apply the SAME independent
-* deliverable check to direct submissions. Raw driver prose is never eligible.
-*/
 /** The standing strategy a router-brained supervisor runs with when its profile names no
 *  `systemPrompt`. The brain's competence IS this prompt: without it the brain has the coordination
 *  verbs but no policy for WHEN to use them, and either over-spawns or stalls. A profile may override
@@ -7459,11 +7638,101 @@ const defaultSupervisorPrompt = [
 	"Wait on real signals (await a settle, answer a blocking question), integrate the result, and stop",
 	"as soon as the deliverable is met."
 ].join("\n");
+/** Longest prompt excerpt an error message may carry. A supervisor system prompt is routinely
+*  thousands of characters; two of them interpolated whole turn a configuration fault into an
+*  unreadable wall, so a fault reports each prompt's LENGTH plus a leading excerpt instead. */
+const PROMPT_EXCERPT_CHARS = 60;
+/** `<n> chars starting "<first 60>…"` — enough to tell two prompts apart without printing either. */
+function describePrompt(value) {
+	const head = value.slice(0, PROMPT_EXCERPT_CHARS);
+	return `${value.length} chars starting ${JSON.stringify(head)}${value.length > PROMPT_EXCERPT_CHARS ? "…" : ""}`;
+}
+/**
+* The instruction lines a canonical `resources.instructions` contributes. A plain string and an
+* `inline` resource are their own text; a `github` reference names bytes that live elsewhere and
+* cannot be fetched while building a supervisor synchronously — that fails loud rather than
+* dropping instructions the profile says the agent runs under (the same rule
+* `improve()`'s memory surface applies to the same field).
+*/
+function resourceInstructionLines(instructions) {
+	if (instructions === void 0) return [];
+	if (typeof instructions === "string") return instructions.length > 0 ? [instructions] : [];
+	if (instructions.kind === "inline") return instructions.content.length > 0 ? [instructions.content] : [];
+	throw new ConfigError(`supervisorAgent: profile.resources.instructions is a github resource reference (${JSON.stringify(instructions.path)}), which cannot be fetched while the supervisor is built — pass the instruction text as a string or an inline resource`);
+}
+/**
+* The standing instruction both arms run under, assembled from every canonical spelling that
+* carries one: the system prompt (`prompt.systemPrompt` or the top-level `systemPrompt`), then the
+* `prompt.instructions` lines, then `resources.instructions` — each on its own line, in that order.
+* `undefined` only when the profile names none at all.
+*
+* Two disagreeing system prompts throw: they are the same standing instruction in two spellings, so
+* picking one silently changes what the supervisor runs and there is no defensible winner.
+*/
+function resolveSupervisorSystemPrompt(profile, activePrompt) {
+	const promptSystem = profile.prompt?.systemPrompt;
+	const topSystem = profile.systemPrompt;
+	if (promptSystem !== void 0 && topSystem !== void 0 && promptSystem !== topSystem) throw new ValidationError(`supervisorAgent: profile.prompt.systemPrompt and profile.systemPrompt are both set and differ — they are the same standing instruction, so keep exactly one (prompt.systemPrompt: ${describePrompt(promptSystem)}; systemPrompt: ${describePrompt(topSystem)})`);
+	const base = promptSystem ?? topSystem ?? activePrompt;
+	const lines = [...profile.prompt?.instructions ?? [], ...resourceInstructionLines(profile.resources?.instructions)];
+	if (lines.length === 0) return base;
+	return (base !== void 0 ? [base, ...lines] : lines).join("\n");
+}
+/**
+* The router model id, or `undefined` when the profile names none. A string `model` IS the id; an
+* object `model` is canonical model hints and `default` is the id. `AgentProfileModelHints.default`
+* is OPTIONAL upstream (`{ provider: 'anthropic' }` is a valid canonical profile), so hints without
+* a resolvable id are the documented "profile names no model" case: the router config's own model
+* applies, exactly as when `model` is absent.
+*/
+function resolveSupervisorModelId(profile) {
+	if (typeof profile.model === "string") return profile.model;
+	const fromHints = profile.model?.default;
+	return typeof fromHints === "string" && fromHints.length > 0 ? fromHints : void 0;
+}
+/**
+* Reduce either profile spelling — a hand-written `SupervisorProfile` or a canonical `AgentProfile`
+* — to the scalars the brain arms consume:
+*
+*  - `modelId`: a string `model` verbatim, else `model.default`. Absent or unresolvable → the
+*    router config's own model applies unchanged.
+*  - `systemPrompt`: the system prompt plus the `prompt.instructions` and `resources.instructions`
+*    lines, one per line.
+*
+* `supervisorAgent` resolves each piece only where it is consumed (the model id on the router arm
+* only); this whole-profile reduction is the caller-facing view of the same rules.
+*/
+function resolveSupervisorProfile(profile) {
+	const systemPrompt = resolveSupervisorSystemPrompt(profile);
+	const modelId = resolveSupervisorModelId(profile);
+	return {
+		name: profile.name ?? "supervisor",
+		harness: profile.harness ?? null,
+		...modelId !== void 0 ? { modelId } : {},
+		...systemPrompt !== void 0 ? { systemPrompt } : {}
+	};
+}
+/**
+* Fail closed on a non-loopback coordination bind. `serveCoordinationMcp` mounts spawn_agent /
+* steer_agent / stop with NO authentication of any kind (it is a bare JSON-RPC-over-HTTP handler),
+* so a non-loopback bind lets anyone who can reach the port spawn agents and spend the run's
+* conserved budget. There is no token to require yet, so the only honest options are loopback or an
+* explicit, recorded acknowledgment — never a silent bind.
+*/
+function assertCoordinationBinding(binding) {
+	const host = binding?.host;
+	if (host === void 0 || isLoopbackHost(host)) return;
+	if (binding?.allowUnauthenticatedRemote === true) return;
+	throw new ConfigError(`supervisorAgent: coordination.host=${JSON.stringify(host)} is not a loopback address and the coordination MCP has no authentication: any client that can reach the port could call spawn_agent/steer_agent and spend this run's budget. Bind a loopback host ("127.0.0.1", "localhost", "::1"), or set coordination.allowUnauthenticatedRemote: true to accept that exposure explicitly.`);
+}
 /** Build a supervisor `Agent` from its profile: the brain resolves from `profile.harness` (backend-as-data), the same resolution rule as every worker. */
 function supervisorAgent(profile, deps) {
 	const name = profile.name ?? "supervisor";
-	const systemPrompt = profile.systemPrompt ?? defaultSupervisorPrompt;
 	const harness = profile.harness ?? null;
+	const profilePrompt = resolveSupervisorSystemPrompt(profile);
+	const coordination = deps.coordination ? { ...deps.coordination } : void 0;
+	assertCoordinationBinding(coordination);
+	if (harness === null && coordination !== void 0) throw new ConfigError("supervisorAgent: coordination binding is only meaningful for a harness-brained supervisor (profile.harness set). A router-brained supervisor calls the coordination verbs in process and serves no MCP, so this binding would be silently ignored.");
 	if (harness !== null && deps.compaction) throw new ValidationError("supervisorAgent: compaction is only supported for router-brained supervisors (profile.harness null)");
 	if (harness === null) return driverAgent({
 		name,
@@ -7471,7 +7740,7 @@ function supervisorAgent(profile, deps) {
 		blobs: deps.blobs,
 		makeWorkerAgent: deps.makeWorkerAgent,
 		perWorker: deps.perWorker,
-		systemPrompt,
+		systemPrompt: resolveSupervisorSystemPrompt(profile, defaultSupervisorPrompt) ?? defaultSupervisorPrompt,
 		...deps.deliverable ? { deliverable: deps.deliverable } : {},
 		...deps.maxLiveWorkers !== void 0 ? { maxLiveWorkers: deps.maxLiveWorkers } : {},
 		...deps.extraTools ? { extraTools: deps.extraTools } : {},
@@ -7498,6 +7767,9 @@ function supervisorAgent(profile, deps) {
 				blobs: deps.blobs,
 				makeWorkerAgent: deps.makeWorkerAgent,
 				perWorker: deps.perWorker,
+				...coordination?.host !== void 0 ? { host: coordination.host } : {},
+				...coordination?.port !== void 0 ? { port: coordination.port } : {},
+				...coordination?.allowUnauthenticatedRemote === true ? { allowUnauthenticatedRemote: true } : {},
 				...deps.deliverable ? { deliverable: deps.deliverable } : {},
 				...deps.maxLiveWorkers !== void 0 ? { maxLiveWorkers: deps.maxLiveWorkers } : {},
 				...deps.analysts ? { analysts: deps.analysts } : {},
@@ -7511,6 +7783,7 @@ function supervisorAgent(profile, deps) {
 				try {
 					await driveHarness({
 						profile,
+						...profilePrompt !== void 0 ? { systemPrompt: profilePrompt } : {},
 						task,
 						scope,
 						coordinationMcpUrl: mcp.url
@@ -7535,9 +7808,10 @@ function supervisorAgent(profile, deps) {
 }
 function routerBrainFromProfile(profile, deps) {
 	if (!deps.router) throw new ValidationError("supervisorAgent: a router-brained supervisor (harness null) needs deps.router (or deps.brain)");
+	const modelId = resolveSupervisorModelId(profile);
 	return routerBrain({
 		...deps.router,
-		model: profile.model ?? deps.router.model
+		...modelId !== void 0 ? { model: modelId } : {}
 	});
 }
 //#endregion
@@ -7569,6 +7843,18 @@ function workerFromBackend(backend, deliverable) {
 		};
 	};
 }
+/** Resolve one option that may be given as a value OR as a name into `opts.registry`. Both failure
+*  modes name the option, the requested name, and the table it was looked up in — a typo must not
+*  degrade into a silently unconfigured run (which for `deliverable` means "no run can ever
+*  deliver"). A resolver port cannot enumerate its names, so the message names the table instead of
+*  listing what was in it. */
+function resolveNamed(option, table, value, registry) {
+	if (typeof value !== "string") return value;
+	if (!registry) throw new ConfigError(`supervise: opts.${option} = ${JSON.stringify(value)} names a registry entry, but no opts.registry.${table} was provided to resolve it against`);
+	const entry = registry.resolve(value);
+	if (entry === void 0) throw new ConfigError(`supervise: opts.${option} = ${JSON.stringify(value)} is not in opts.registry.${table} — the table resolved no entry under that name`);
+	return entry;
+}
 /** A quarter of the token pool per worker → ~4 workers fit before `poolStarved` halts spawning. */
 function defaultPerWorker(budget) {
 	return {
@@ -7580,15 +7866,20 @@ function defaultPerWorker(budget) {
 function supervise(profile, task, opts) {
 	const backendModel = opts.backend?.model;
 	assertModelAllowed(opts.router?.model, opts.allowedModels);
-	assertModelAllowed(profile.model, opts.allowedModels);
+	assertModelAllowed(resolveSupervisorModelId(profile), opts.allowedModels);
 	assertModelAllowed(typeof backendModel === "string" ? backendModel : void 0, opts.allowedModels);
+	const deliverable = resolveNamed("deliverable", "deliverables", opts.deliverable, opts.registry?.deliverables);
+	const finalizer = resolveNamed("finalizer", "finalizers", opts.finalizer, opts.registry?.finalizers);
+	const analysts = resolveNamed("analysts", "analysts", opts.analysts, opts.registry?.analysts);
+	const probes = resolveNamed("probes", "probes", opts.probes, opts.registry?.probes);
+	assertCoordinationBinding(opts.coordination);
 	const ctx = opts.runDir !== void 0 ? createFileRunContext(opts.runDir, { withDriver: true }) : createInMemoryRunContext({ withDriver: true });
 	const blobs = opts.blobs ?? ctx.blobs;
 	const perWorker = opts.perWorker ?? defaultPerWorker(opts.budget);
 	let makeWorkerAgent = opts.makeWorkerAgent;
 	if (!makeWorkerAgent) {
 		if (!opts.backend) throw new ValidationError("supervise: provide opts.backend (where workers run) or opts.makeWorkerAgent");
-		makeWorkerAgent = workerFromBackend(opts.backend, opts.deliverable);
+		makeWorkerAgent = workerFromBackend(opts.backend, deliverable);
 	}
 	const workerFactory = makeWorkerAgent;
 	const runId = opts.runId ?? "supervise";
@@ -7600,17 +7891,18 @@ function supervise(profile, task, opts) {
 			blobs,
 			makeWorkerAgent: workerFactory,
 			perWorker,
-			...opts.deliverable ? { deliverable: opts.deliverable } : {},
+			...deliverable ? { deliverable } : {},
 			...log ? { onEvent: (ev) => log.append(runId, ev, new Date(now()).toISOString()) } : {},
 			...priorCoordination && (priorCoordination.questions.length > 0 || priorCoordination.findings.length > 0) ? { priorCoordination } : {},
-			...opts.finalizer ? { finalizer: opts.finalizer } : {},
+			...finalizer ? { finalizer } : {},
+			...opts.coordination ? { coordination: opts.coordination } : {},
 			...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
 			...opts.router ? { router: opts.router } : {},
 			...opts.brain ? { brain: opts.brain } : {},
 			...opts.driveHarness ? { driveHarness: opts.driveHarness } : {},
 			...opts.extraTools ? { extraTools: opts.extraTools } : {},
 			...opts.executeExtraTool ? { executeExtraTool: opts.executeExtraTool } : {},
-			...opts.analysts ? { analysts: opts.analysts } : {},
+			...analysts ? { analysts } : {},
 			...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
 			...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
 			...opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {},
@@ -7626,7 +7918,7 @@ function supervise(profile, task, opts) {
 			blobs,
 			executors: ctx.executors,
 			maxDepth: opts.maxDepth ?? 8,
-			...opts.probes ? { probes: opts.probes } : {},
+			...probes ? { probes } : {},
 			...ctx.resume === true ? { resume: true } : {},
 			...opts.now ? { now: opts.now } : {}
 		});
@@ -7634,6 +7926,6 @@ function supervise(profile, task, opts) {
 	return start();
 }
 //#endregion
-export { eventToSnapshot as $, createDelegateHandler as A, createSteerableSandboxSession as At, DelegationTaskQueue as B, runAgentRounds as Bt, DELEGATE_FEEDBACK_INPUT_SCHEMA as C, createFileRunContext as Ct, DELEGATE_DESCRIPTION as D, createExecutorRegistry as Dt, validateDelegateFeedbackArgs as E, createExecutor as Et, assessAuthoredProfile as F, decodeToolPart as Ft, capDelegationTrace as G, FileCoordinationLog as Gt, DELEGATION_TRACE_MAX_BYTES as H, createSandboxLineage as Ht, authoredWorker as I, sandboxSessionTraceSource as It, DelegationPersistenceError as J, composeLoopTraceEmitters as K, assertModelAllowed as Kt, defaultProfileRichnessThresholds as L, createInbox as Lt, defaultDelegateBudget as M, piExecutor as Mt, delegate as N, piSeamKey as Nt, DELEGATE_INPUT_SCHEMA as O, createWorktreeCliExecutor as Ot, asAuthoredProfile as P, createPushTraceSource as Pt, InMemoryFeedbackStore as Q, profileRichnessFinding as R, createSandboxForSpec as Rt, DELEGATE_FEEDBACK_DESCRIPTION as S, watchTrace as St, createDelegateFeedbackHandler as T, cliWorktreeExecutor as Tt, DELEGATION_TRACE_MAX_SPANS as U, probeSandboxCapabilities as Ut, hashIdempotencyInput as V, runLoop as Vt, buildDelegationTraceSpans as W, acquireSandbox as Wt, FileDelegationStore as X, DelegationStateCorruptError as Y, InMemoryDelegationStore as Z, DELEGATE_UI_AUDIT_DESCRIPTION as _, effectiveConcurrency as _t, createInProcessTransport as a, createProgressTracker as at, createDelegateUiAuditHandler as b, rollingDispatch as bt, DELEGATION_STATUS_INPUT_SCHEMA as c, sampleFromSettled as ct, validateDelegationStatusArgs as d, bestSoFar as dt, driverAgent as et, DELEGATION_HISTORY_DESCRIPTION as f, plateauLength as ft, validateDelegationHistoryArgs as g, createEventBus as gt, createDelegationHistoryHandler as h, createCoordinationTools as ht, serveCoordinationMcp as i, anyOf as it, validateDelegateArgs as j, PI_RUNTIME as jt, DELEGATE_TOOL_NAME as k, DEFAULT_SANDBOX_STEERING_MAX_TURNS as kt, DELEGATION_STATUS_TOOL_NAME as l, anytimeReport as lt, DELEGATION_HISTORY_TOOL_NAME as m, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as mt, workerFromBackend as n, allOf as nt, createMcpServer as o, noProgressFor as ot, DELEGATION_HISTORY_INPUT_SCHEMA as p, renderAnytimeTable as pt, createDelegationTraceCollector as q, gateOnDeliverable as qt, supervisorAgent as r, allWorkersStalled as rt, DELEGATION_STATUS_DESCRIPTION as s, plateau as st, supervise as t, finalizeBestDelivered as tt, createDelegationStatusHandler as u, areaUnderCurve as ut, DELEGATE_UI_AUDIT_INPUT_SCHEMA as v, freeSlots as vt, DELEGATE_FEEDBACK_TOOL_NAME as w, createInMemoryRunContext as wt, validateDelegateUiAuditArgs as x, defaultToolDetectors as xt, DELEGATE_UI_AUDIT_TOOL_NAME as y, queueOf as yt, supervisorInstructions as z, defaultSelectWinner as zt };
+export { InMemoryDelegationStore as $, DELEGATE_INPUT_SCHEMA as A, createWorktreeCliExecutor as At, profileRichnessFinding as B, createSandboxForSpec as Bt, validateDelegateUiAuditArgs as C, defaultToolDetectors as Ct, createDelegateFeedbackHandler as D, cliWorktreeExecutor as Dt, DELEGATE_FEEDBACK_TOOL_NAME as E, createInMemoryRunContext as Et, delegate as F, piSeamKey as Ft, DELEGATION_TRACE_MAX_SPANS as G, probeSandboxCapabilities as Gt, DelegationTaskQueue as H, runAgentRounds as Ht, asAuthoredProfile as I, createPushTraceSource as It, composeLoopTraceEmitters as J, assertModelAllowed as Jt, buildDelegationTraceSpans as K, acquireSandbox as Kt, assessAuthoredProfile as L, decodeToolPart as Lt, createDelegateHandler as M, createSteerableSandboxSession as Mt, validateDelegateArgs as N, PI_RUNTIME as Nt, validateDelegateFeedbackArgs as O, createExecutor as Ot, defaultDelegateBudget as P, piExecutor as Pt, FileDelegationStore as Q, authoredWorker as R, sandboxSessionTraceSource as Rt, createDelegateUiAuditHandler as S, rollingDispatch as St, DELEGATE_FEEDBACK_INPUT_SCHEMA as T, createFileRunContext as Tt, hashIdempotencyInput as U, runLoop as Ut, supervisorInstructions as V, defaultSelectWinner as Vt, DELEGATION_TRACE_MAX_BYTES as W, createSandboxLineage as Wt, DelegationPersistenceError as X, createDelegationTraceCollector as Y, gateOnDeliverable as Yt, DelegationStateCorruptError as Z, createDelegationHistoryHandler as _, createCoordinationTools as _t, supervisorAgent as a, allWorkersStalled as at, DELEGATE_UI_AUDIT_INPUT_SCHEMA as b, freeSlots as bt, createMcpServer as c, noProgressFor as ct, DELEGATION_STATUS_TOOL_NAME as d, anytimeReport as dt, InMemoryFeedbackStore as et, createDelegationStatusHandler as f, areaUnderCurve as ft, DELEGATION_HISTORY_TOOL_NAME as g, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as gt, DELEGATION_HISTORY_INPUT_SCHEMA as h, renderAnytimeTable as ht, resolveSupervisorProfile as i, allOf as it, DELEGATE_TOOL_NAME as j, DEFAULT_SANDBOX_STEERING_MAX_TURNS as jt, DELEGATE_DESCRIPTION as k, createExecutorRegistry as kt, DELEGATION_STATUS_DESCRIPTION as l, plateau as lt, DELEGATION_HISTORY_DESCRIPTION as m, plateauLength as mt, workerFromBackend as n, driverAgent as nt, serveCoordinationMcp as o, anyOf as ot, validateDelegationStatusArgs as p, bestSoFar as pt, capDelegationTrace as q, FileCoordinationLog as qt, assertCoordinationBinding as r, finalizeBestDelivered as rt, createInProcessTransport as s, createProgressTracker as st, supervise as t, eventToSnapshot as tt, DELEGATION_STATUS_INPUT_SCHEMA as u, sampleFromSettled as ut, validateDelegationHistoryArgs as v, createEventBus as vt, DELEGATE_FEEDBACK_DESCRIPTION as w, watchTrace as wt, DELEGATE_UI_AUDIT_TOOL_NAME as x, queueOf as xt, DELEGATE_UI_AUDIT_DESCRIPTION as y, effectiveConcurrency as yt, defaultProfileRichnessThresholds as z, createInbox as zt };
 
-//# sourceMappingURL=supervise-CeZtA1wu.js.map
+//# sourceMappingURL=supervise-6jSTe0kO.js.map