@tangle-network/agent-runtime 0.320.1 → 0.322.1

package/dist/{runtime-B47V5Omi.js → runtime-EiTCboO2.js}

@@ -1,17 +1,17 @@
 import { a as graphRunsFor, d as recordGraphRun, i as graphRegistry, l as lookupGraph, p as taskShapeDigest, r as graphFromStored, t as digestOfGraph } from "./graph-registry-BuJbzTzF.js";
-import { Bn as InMemoryResultBlobStore, Cn as readPromptOptions, Hn as insideCursorNamespace, It as createWorktreeCliExecutor, Jn as readCommittedJsonLines, Mr as contentAddress, Nt as createExecutor, Ot as verdictFromJudgeScore, Pt as createExecutorRegistry, Qn as isTraceAnalysisStore, Sn as assertBoxlessPromptOptions, Tn as runBrainLoop, Vn as InMemorySpawnJournal, Yn as writeAllBytes, _n as runAgentRounds, aa as detachedSnapshot, ga as notifySandboxEventObserver, hn as defaultSelectWinner, ht as mapExecutorResult, ia as detachedFrozen, j as settledToIteration, mt as gateOnDeliverable, na as executableAgentProfileSnapshot, pt as rollingDispatch, qn as prepareJsonlAppend, r as createSupervisor, ra as executableAgentSpecSnapshot, v as withDriverExecutor, vn as createSandboxLineage, vt as CheckUnavailableError, wn as routerBrain } from "./supervisor-CCtmmmOz.js";
+import { Cn as readPromptOptions, Hn as InMemoryResultBlobStore, It as createWorktreeCliExecutor, Nt as createExecutor, Ot as verdictFromJudgeScore, Pr as contentAddress, Pt as createExecutorRegistry, Sn as assertBoxlessPromptOptions, Tn as runBrainLoop, Un as InMemorySpawnJournal, Wn as insideCursorNamespace, Xn as readCommittedJsonLines, Yn as prepareJsonlAppend, Zn as writeAllBytes, _n as runAgentRounds, aa as executableAgentSpecSnapshot, er as isTraceAnalysisStore, hn as defaultSelectWinner, ht as mapExecutorResult, ia as executableAgentProfileSnapshot, j as settledToIteration, mt as gateOnDeliverable, oa as detachedFrozen, pt as rollingDispatch, r as createSupervisor, rt as coordinationProfileToolPrefix, sa as detachedSnapshot, v as withDriverExecutor, va as notifySandboxEventObserver, vn as createSandboxLineage, vt as CheckUnavailableError, wn as routerBrain } from "./supervisor-BMMdI4T-.js";
 import { i as ConfigError, m as ValidationError, n as AnalystError, s as PlannerError } from "./errors-DodWX-cb.js";
-import { B as runAgentic, G as observe, K as renderReport, U as ObservationError, V as sample, X as strategyAuthorMethod, a as reconcileInterruptedSearchCalls, c as searchExecutor, q as profileChatClient, r as dedicatedLane, x as runtimeShipDecision, z as refine } from "./search-executor-DjKdQluM.js";
+import { B as runAgentic, G as observe, K as renderReport, U as ObservationError, V as sample, X as strategyAuthorMethod, a as reconcileInterruptedSearchCalls, c as searchExecutor, q as profileChatClient, r as dedicatedLane, x as runtimeShipDecision, z as refine } from "./search-executor-ECJ2TmC-.js";
 import { A as markPutStreamVerified, J as fnv1a32Hex, L as immutableCandidateValue, N as canonicalCandidateDigest$1, S as captureMaterializedWorkspace, U as chargedTokens, V as addSpend, W as cloneSpend, X as isAbortError, Y as hasCompleteCacheBreakdown, Z as isAsyncIterable, et as randomSuffix, it as stringifySafe, lt as zeroSpend, q as errorMessage, rt as sleep, xt as armDeadlineTimer, y as WorkspaceScanLimitError, z as sha256Bytes$1 } from "./workspace-streams-DFAhW7hF.js";
-import { c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, p as canonicalObservedModelParts, t as assertExecutableAgentProfile } from "./model-policy-CNe257pB.js";
+import { c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, p as canonicalObservedModelParts, t as assertExecutableAgentProfile, v as harnessRunsAgent } from "./model-policy-CNe257pB.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction-DylCC_ot.js";
-import { D as foldCoordinationRecords, w as createInMemoryRunContext } from "./coordination-driver-D85RWATT.js";
-import { r as supervise } from "./supervise-C2ThvLgZ.js";
+import { D as foldCoordinationRecords, w as createInMemoryRunContext } from "./coordination-driver-C2Zm5lU4.js";
+import { r as supervise } from "./supervise-BjrRk-AN.js";
 import "./run-layout-DSCWdbX2.js";
-import "./provision-supervisor-BUMhF1yb.js";
-import "./delegate-BHRR-4hh.js";
-import "./graph-BGMcJJP1.js";
+import "./provision-supervisor-ftJZhqBU.js";
+import "./delegate-BV7AVmbB.js";
+import "./graph-CH3YiPog.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, sha256Bytes, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { CODING_HARNESSES, DEFAULT_TRACE_ANALYST_KINDS, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, createTraceAnalyst, expandProfileAxes, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
@@ -23,6 +23,7 @@ import { chmod, link, lstat, mkdir, mkdtemp, open, opendir, readFile, readdir, r
 import { tmpdir } from "node:os";
 import { isDeepStrictEqual, promisify } from "node:util";
 import { redact } from "@tangle-network/agent-eval/traces";
+import { z } from "zod";
 import { Readable } from "node:stream";
 import { collectAgentResponseText } from "@tangle-network/sandbox";
 import { SearchRecorder, asha, beam, createRunCostLedger, estimateNode, fsCampaignStorage, openSearchLedger, renderSearchSummary, runProfileMatrix, runSearch, searchClaimReserveUsd, searchModelIdentity, surfaceDiff } from "@tangle-network/agent-eval/campaign";
@@ -456,8 +457,9 @@ async function connectHttpMcp(spec) {
 	let sessionId;
 	let nextId = 1;
 	let closed = false;
-	const post = async (path, body, method = "POST") => fetchImpl(`${endpoint.origin}${endpoint.pathname}${endpoint.search}${path}`, {
+	const post = async (path, body, method = "POST", signal) => fetchImpl(`${endpoint.origin}${endpoint.pathname}${endpoint.search}${path}`, {
 		method,
+		...signal ? { signal } : {},
 		headers: {
 			accept: "application/json, text/event-stream",
 			...body !== void 0 ? { "content-type": "application/json" } : {},
@@ -479,7 +481,7 @@ async function connectHttpMcp(spec) {
 				id,
 				method,
 				params
-			}, "POST");
+			}, "POST", controller.signal);
 			const sessionHeader = res.headers.get("mcp-session-id");
 			if (sessionHeader) sessionId = sessionHeader;
 			if (!res.ok) {
@@ -7539,6 +7541,457 @@ async function bestProfileFor(reg, name) {
 	} : void 0;
 }
 //#endregion
+//#region src/runtime/supervise/remote-supervisor.ts
+const agentSchema = z.object({
+	id: z.string(),
+	parent: z.string().optional(),
+	label: z.string(),
+	status: z.string(),
+	runtime: z.string()
+}).passthrough();
+const treeSchema = z.object({
+	root: z.string(),
+	nodes: z.array(agentSchema),
+	inFlight: z.number().int().nonnegative()
+});
+const eventPageSchema = z.discriminatedUnion("status", [z.object({
+	status: z.literal("unavailable"),
+	reason: z.enum(["unknown-worker", "not-captured"])
+}), z.object({
+	status: z.literal("available"),
+	entries: z.array(z.object({
+		sequence: z.number().int().nonnegative(),
+		at: z.number(),
+		event: z.unknown(),
+		omitted: z.enum(["event-too-large", "event-not-serializable"]).optional()
+	})),
+	cursor: z.object({
+		epoch: z.string(),
+		next: z.number().int().nonnegative()
+	}),
+	reset: z.boolean(),
+	historyExpired: z.boolean(),
+	remaining: z.number().int().nonnegative()
+})]);
+/** Connect with the server's readOnly URL and protected headers; credentials never enter a profile. */
+async function connectRemoteSupervisor(spec) {
+	const connection = await connectHttpMcp(spec);
+	if (!connection.tools.some((tool) => tool.name === "observe_agent")) {
+		await connection.close();
+		throw new ValidationError("remote supervisor does not expose observe_agent");
+	}
+	const call = async (args) => {
+		const text = await connection.callTool("observe_agent", args);
+		if (text.startsWith("ERROR:")) throw new ValidationError(text);
+		const result = z.record(z.string(), z.unknown()).parse(JSON.parse(text));
+		if (result.error) throw new ValidationError(`remote supervisor refused observation: ${String(result.error)}`);
+		return result;
+	};
+	return {
+		tree: async () => treeSchema.parse((await call({ tree: true })).tree),
+		observe: async (workerId, cursor) => {
+			const agent = await call({
+				workerId,
+				events: true,
+				...cursor ? { eventCursor: cursor } : {}
+			});
+			return {
+				agent,
+				events: eventPageSchema.parse(agent.events)
+			};
+		},
+		close: () => connection.close()
+	};
+}
+//#endregion
+//#region src/runtime/supervise/search-spec.ts
+/**
+* SearchSpec: one data value for a multi-agent research configuration, and the compiler that maps
+* it onto exactly one existing call, `supervise(profile, task, options)` or `runGraph(graph,
+* options)`. The design record is `docs/design/search-spec.md`.
+*
+* Nothing here runs anything. The compiler only chooses options those two calls already take, so
+* the control loop, the budget, the check, the continuation and the journal stay theirs. A spec is
+* plain data with a canonical digest; the compiled call records that digest on the run's root as
+* `execution.correlation.searchSpecDigest`, which the journal's root registration and the settle
+* record's tree both carry, so two runs can be compared as the same design on two problems.
+*
+* Every axis value compiles to an option, or to a refusal before any compute. An axis value the
+* compiled call would not read is refused rather than recorded, because a digest that names a knob
+* which changes nothing would make two different runs look like one design.
+*/
+/** The correlation key the compiled call records the spec's digest under. Runtime writes it; a
+*  caller that supplies it is refused. */
+const SEARCH_SPEC_CORRELATION_KEY = "searchSpecDigest";
+const SPAWN_GRANT = `${coordinationProfileToolPrefix}spawn_worker`;
+function refuse(message) {
+	throw new ValidationError(`SearchSpec: ${message}`);
+}
+const quoted = (values) => values.map((v) => `'${v}'`).join(", ");
+function record(value, where, required, optional = []) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) refuse(`${where} must be an object`);
+	const fields = value;
+	const known = /* @__PURE__ */ new Set([...required, ...optional]);
+	const unknown = Object.keys(fields).filter((key) => !known.has(key));
+	if (unknown.length > 0) refuse(`${where} has unknown ${unknown.length === 1 ? "key" : "keys"} ${quoted(unknown)}; it takes ${quoted([...required, ...optional])}`);
+	const missing = required.filter((key) => fields[key] === void 0);
+	if (missing.length > 0) refuse(`${where} is missing ${quoted(missing)}`);
+	return fields;
+}
+function oneOf(value, where, values) {
+	if (typeof value === "string" && values.includes(value)) return value;
+	return refuse(`${where} is ${JSON.stringify(value)}; it must be one of ${quoted(values)}`);
+}
+function names(value, where) {
+	if (!Array.isArray(value) || value.length === 0 || !value.every((item) => typeof item === "string" && item.trim() !== "")) refuse(`${where} must be a non-empty list of non-empty strings`);
+	const list = value;
+	if (new Set(list).size !== list.length) refuse(`${where} lists a name twice`);
+	return Object.freeze([...list].sort());
+}
+function integer(value, where, min) {
+	if (!Number.isSafeInteger(value) || value < min) refuse(`${where} must be an integer >= ${min}`);
+	return value;
+}
+/**
+* Check a spec and return its canonical frozen form: every axis present, no unknown key, no
+* contradictory pair of values. Lists are sorted, so two specs that mean the same digest the same.
+*/
+function assertSearchSpec(spec) {
+	const axes = [
+		"state",
+		"context",
+		"select",
+		"workers",
+		"comms",
+		"evaluate",
+		"stop"
+	];
+	if (typeof spec !== "object" || spec === null || Array.isArray(spec)) refuse("a spec must be an object with the axes state, context, select, workers, comms, evaluate and stop");
+	const top = spec;
+	const unknownAxes = Object.keys(top).filter((key) => !axes.includes(key));
+	if (unknownAxes.length > 0) refuse(`unknown axis ${quoted(unknownAxes)}; the axes are ${quoted(axes)}`);
+	const missingAxes = axes.filter((axis) => top[axis] === void 0);
+	if (missingAxes.length > 0) refuse(`axis ${quoted(missingAxes)} is missing`);
+	if (top.state === "conversation") refuse("state 'conversation' is not a value: research memory that lives only in a harness conversation cannot be checkpointed, inspected or ablated; it is always harness");
+	const state = oneOf(top.state, "state", ["harness"]);
+	const context = oneOf(top.context, "context", ["fresh", "native"]);
+	const select = oneOf(top.select, "select", [
+		"lead",
+		"advisor",
+		"code",
+		"self",
+		"fixed"
+	]);
+	const workersIn = record(top.workers, "workers", ["count", "isolation"], ["models"]);
+	const count = integer(workersIn.count, "workers.count", 0);
+	const isolation = oneOf(workersIn.isolation, "workers.isolation", ["isolated", "shared"]);
+	const models = workersIn.models === void 0 ? void 0 : names(workersIn.models, "workers.models");
+	const comms = oneOf(top.comms, "comms", [
+		"none",
+		"assignments",
+		"messages"
+	]);
+	const evaluateIn = record(top.evaluate, "evaluate", ["feedback", "bar"], ["analysts"]);
+	const feedback = oneOf(evaluateIn.feedback, "evaluate.feedback", ["verbatim", "off"]);
+	const bar = oneOf(evaluateIn.bar, "evaluate.bar", ["on", "off"]);
+	const analysts = evaluateIn.analysts === void 0 ? void 0 : names(evaluateIn.analysts, "evaluate.analysts");
+	const stopIn = record(top.stop, "stop", ["maxBarren"], ["plateau"]);
+	const maxBarren = integer(stopIn.maxBarren, "stop.maxBarren", 1);
+	let plateau;
+	if (stopIn.plateau !== void 0) {
+		const plateauIn = record(stopIn.plateau, "stop.plateau", ["window", "minDelta"]);
+		const minDelta = plateauIn.minDelta;
+		if (typeof minDelta !== "number" || !Number.isFinite(minDelta) || minDelta < 0) refuse("stop.plateau.minDelta must be a finite number >= 0");
+		plateau = Object.freeze({
+			window: integer(plateauIn.window, "stop.plateau.window", 1),
+			minDelta
+		});
+	}
+	if (select === "advisor" && context === "native") refuse("select 'advisor' sees each epoch only through the coordinator's projection, so it needs context 'fresh'; with 'native' its earlier turns would stay in its context");
+	if (select === "code" && context === "fresh") refuse("select 'code' runs the root in your brain, in process; it has no harness session for context 'fresh' to renew");
+	if (select === "advisor" && count === 0) refuse("select 'advisor' only assigns work, so workers.count must be at least 1");
+	if (count === 0 && comms !== "none") refuse(`workers.count 0 runs the root alone, so comms must be 'none', not '${comms}'`);
+	if (count > 0 && comms === "none") refuse(`comms 'none' leaves ${count} worker(s) with no channel; use 'assignments' or 'messages'`);
+	if (comms === "messages" && count < 2) refuse(`comms 'messages' needs at least two peers to message each other; workers.count is ${count}`);
+	if (select === "self" && comms !== "messages") refuse("select 'self' lets the peers divide the work by messages, so comms must be 'messages'; use select 'fixed' for independent attempts");
+	if (count === 0 && isolation === "shared") refuse("workers.isolation 'shared' places workers in shared boxes, and workers.count is 0");
+	if (count === 0 && models !== void 0) refuse("workers.models lists the models workers may use, and workers.count is 0");
+	return Object.freeze({
+		state,
+		context,
+		select,
+		workers: Object.freeze({
+			count,
+			...models === void 0 ? {} : { models },
+			isolation
+		}),
+		comms,
+		evaluate: Object.freeze({
+			feedback,
+			bar,
+			...analysts === void 0 ? {} : { analysts }
+		}),
+		stop: Object.freeze({
+			maxBarren,
+			...plateau === void 0 ? {} : { plateau }
+		})
+	});
+}
+/** The canonical digest of a spec: equal for two specs that mean the same, different otherwise. */
+function searchSpecDigest(spec) {
+	return canonicalCandidateDigest({
+		kind: "agent-runtime.search-spec.v1",
+		spec: assertSearchSpec(spec)
+	});
+}
+const presetEvaluate = Object.freeze({
+	feedback: "verbatim",
+	bar: "off"
+});
+const presetStop = Object.freeze({ maxBarren: 2 });
+/**
+* The five configurations Runtime ships, as specs. Each is an ordinary spec: its digest is its
+* value's, and a consumer that changes any axis passes an inline spec with its own digest.
+*/
+const searchPresets = Object.freeze({
+	/** One root alone in one session. */
+	solo: () => assertSearchSpec({
+		state: "harness",
+		context: "native",
+		select: "lead",
+		workers: {
+			count: 0,
+			isolation: "isolated"
+		},
+		comms: "none",
+		evaluate: presetEvaluate,
+		stop: presetStop
+	}),
+	/** A doing lead with up to `width` workers at once, each in its own environment; any of them
+	*  may lead its own team within the same bound. */
+	tree: (width) => assertSearchSpec({
+		state: "harness",
+		context: "native",
+		select: "lead",
+		workers: {
+			count: width,
+			isolation: "isolated"
+		},
+		comms: "assignments",
+		evaluate: presetEvaluate,
+		stop: presetStop
+	}),
+	/** A doing lead with up to `width` workers at once that may share boxes. */
+	swarm: (width) => assertSearchSpec({
+		state: "harness",
+		context: "native",
+		select: "lead",
+		workers: {
+			count: width,
+			isolation: "shared"
+		},
+		comms: "assignments",
+		evaluate: presetEvaluate,
+		stop: presetStop
+	}),
+	/** `count` peers started by a convener, dividing the work by peer mail. */
+	peers: (count) => assertSearchSpec({
+		state: "harness",
+		context: "native",
+		select: "self",
+		workers: {
+			count,
+			isolation: "isolated"
+		},
+		comms: "messages",
+		evaluate: presetEvaluate,
+		stop: presetStop
+	}),
+	/** Stateless Language Agents (arXiv 2610.07625): an assign-only advisor re-entered fresh every
+	*  epoch from the coordinator's projection, over `width` isolated leaf workers. */
+	sla: (width) => assertSearchSpec({
+		state: "harness",
+		context: "fresh",
+		select: "advisor",
+		workers: {
+			count: width,
+			isolation: "isolated"
+		},
+		comms: "assignments",
+		evaluate: presetEvaluate,
+		stop: presetStop
+	})
+});
+/** The `SuperviseOptions` an axis decides. A caller value for one is refused, naming the axis. */
+const ownedBy = Object.freeze({
+	budget: "inputs.budget",
+	deliverable: "inputs.deliverable",
+	continuation: "context, evaluate, stop and inputs.continuation",
+	workerSlots: "workers.count",
+	allowedModels: "workers.models",
+	peerMail: "comms 'messages'",
+	analysts: "inputs.analysts",
+	analyzeOnSettle: "evaluate.analysts",
+	stopRule: "stop.plateau",
+	maxDepth: "select 'advisor'",
+	inheritSpawnRights: "select 'advisor'"
+});
+function grantsSpawn(profile) {
+	return profile.tools?.[SPAWN_GRANT] === true;
+}
+function profileTable(entries) {
+	const table = /* @__PURE__ */ new Map();
+	for (const item of entries) {
+		const entry = "profile" in item ? item : { profile: item };
+		const name = entry.profile.name;
+		if (typeof name !== "string" || name.trim() === "") refuse("every profile in inputs.workers needs a name, which the root spawns it by");
+		if (table.has(name)) refuse(`inputs.workers names profile '${name}' twice`);
+		table.set(name, entry);
+	}
+	const listed = Object.freeze([...table.keys()]);
+	return Object.freeze({
+		resolve: (name) => table.get(name),
+		names: () => listed
+	});
+}
+/** The worker backend with the spec's placement, refusing a placement the spec contradicts. */
+function placedBackend(spec, inputs) {
+	const backend = inputs.options?.backend;
+	const sharedAlready = backend?.backend === "provider" && backend.shared !== void 0;
+	if (spec.workers.isolation === "isolated") {
+		if (inputs.sharedPlacement !== void 0 || sharedAlready) refuse("workers.isolation 'isolated' gives every worker its own environment; drop the shared placement or use isolation 'shared'");
+		return backend;
+	}
+	if (inputs.sharedPlacement === void 0) return backend;
+	if (backend?.backend !== "provider") refuse(`inputs.sharedPlacement places workers through a 'provider' backend; options.backend is ${backend === void 0 ? "absent" : `'${backend.backend}'`}`);
+	if (sharedAlready) refuse("options.backend already carries a shared placement; pass it once");
+	return Object.freeze({
+		...backend,
+		shared: inputs.sharedPlacement
+	});
+}
+/** The one root of a graph: the node that delegates and is never delegated to. */
+function graphRoot(graph) {
+	const delegates = graph.edges.filter((edge) => edge.kind === "delegates");
+	const targets = new Set(delegates.map((edge) => edge.to));
+	const roots = [...new Set(delegates.map((edge) => edge.from))].filter((id) => !targets.has(id));
+	return roots.length === 1 ? graph.nodes.find((node) => node.id === roots[0])?.profile : void 0;
+}
+/**
+* Compile a spec onto exactly one existing call. Every refusal names the axis or input and what
+* would have gone wrong, and happens before any compute.
+*
+* ```ts
+* const compiled = compileSearchSpec(searchPresets.sla(3), { profile, task, budget, deliverable,
+*   deadline, continuation: { profile: words }, workers, options: { backend, coordination, runDir } })
+* const result = compiled.call === 'supervise'
+*   ? await supervise(compiled.profile, compiled.task, compiled.options)
+*   : (await runGraph(compiled.graph, compiled.options)).result
+* ```
+*/
+function compileSearchSpec(raw, inputs) {
+	const spec = assertSearchSpec(raw);
+	const digest = searchSpecDigest(spec);
+	const passed = inputs.options ?? {};
+	for (const [key, axis] of Object.entries(ownedBy)) if (passed[key] !== void 0) refuse(`options.${key} is decided by ${axis}; change the spec or that input instead`);
+	if (inputs.deliverable === void 0) refuse("inputs.deliverable is required: a spec run is sent back by its check");
+	const correlation = passed.execution?.correlation ?? {};
+	if (Object.hasOwn(correlation, "searchSpecDigest")) refuse(`options.execution.correlation cannot set ${SEARCH_SPEC_CORRELATION_KEY}; Runtime records it`);
+	const execution = Object.freeze({
+		...passed.execution,
+		correlation: Object.freeze({
+			...correlation,
+			[SEARCH_SPEC_CORRELATION_KEY]: digest
+		})
+	});
+	const continuation = {
+		deadline: inputs.deadline,
+		maxBarren: spec.stop.maxBarren,
+		profile: inputs.continuation.profile,
+		failures: spec.evaluate.feedback,
+		panel: "off",
+		bar: spec.evaluate.bar,
+		session: spec.context,
+		...inputs.continuation.reference === void 0 ? {} : { reference: inputs.continuation.reference },
+		...inputs.continuation.append === void 0 ? {} : { append: inputs.continuation.append }
+	};
+	const backend = placedBackend(spec, inputs);
+	const callerOwnsLeaves = passed.makeLeafAgent !== void 0 || passed.makeWorkerAgent !== void 0;
+	if (spec.comms === "messages" && backend !== void 0 && backend.backend !== "bridge" && backend.backend !== "provider" && !callerOwnsLeaves) refuse(`comms 'messages' needs workers that can call peer mail: Runtime mounts it on 'bridge' or capable 'provider' workers, and '${backend.backend}' workers run no client for it. Run the workers on a bridge, or mount WorkerSpawnContext.peerMailUrl through makeLeafAgent`);
+	const analystKinds = spec.evaluate.analysts ?? [];
+	if (analystKinds.length > 0 && inputs.analysts === void 0) refuse("evaluate.analysts names analyst kinds, and inputs.analysts holds no registry to run them");
+	const axisOptions = {
+		continuation,
+		execution,
+		...spec.workers.count > 0 ? { workerSlots: spec.workers.count } : {},
+		...spec.workers.models === void 0 ? {} : { allowedModels: spec.workers.models },
+		...spec.comms === "messages" ? { peerMail: true } : {},
+		...spec.stop.plateau === void 0 ? {} : { stopRule: { plateau: spec.stop.plateau } },
+		...backend === void 0 ? {} : { backend }
+	};
+	if (spec.select === "code" || spec.select === "fixed") {
+		const graph = inputs.graph ?? refuse(`select '${spec.select}' needs inputs.graph`);
+		if (inputs.profile !== void 0 || inputs.task !== void 0) refuse(`select '${spec.select}' runs inputs.graph, whose root is its own node and whose task is the deliverable's description; drop inputs.profile and inputs.task`);
+		if (inputs.workers !== void 0) refuse(`select '${spec.select}' spawns the graph's nodes; drop inputs.workers`);
+		if (analystKinds.length > 0) refuse(`select '${spec.select}' declares a graph's analysts as analyzes edges, not evaluate.analysts`);
+		if (spec.workers.count === 0) refuse(`select '${spec.select}' runs a graph's worker nodes, so workers.count must be at least 1`);
+		if (spec.select === "code" && inputs.brain === void 0) refuse("select 'code' needs inputs.brain, the caller's brain that drives the root");
+		if (spec.select === "fixed" && inputs.brain !== void 0) refuse("select 'fixed' runs the graph's root profile; a brain is select 'code'");
+		if (passed.registry !== void 0) refuse("options.registry is supervise's name table, which a graph cannot read; pass the graph's directive registry as inputs.directives");
+		if (spec.context === "fresh" && !harnessRunsAgent(graphRoot(graph)?.harness)) refuse("context 'fresh' renews an external harness root's session at each re-entry, and the graph's root runs on the router brain");
+		return Object.freeze({
+			call: "runGraph",
+			spec,
+			digest,
+			graph: Object.freeze({
+				nodes: graph.nodes,
+				edges: graph.edges,
+				deliverable: inputs.deliverable,
+				budget: inputs.budget
+			}),
+			options: Object.freeze({
+				...passed,
+				...axisOptions,
+				...inputs.brain === void 0 ? {} : { brain: inputs.brain },
+				...inputs.analysts === void 0 ? {} : { analysts: inputs.analysts },
+				...inputs.directives === void 0 ? {} : { registry: inputs.directives }
+			})
+		});
+	}
+	const profile = inputs.profile ?? refuse(`select '${spec.select}' needs inputs.profile, the root`);
+	if (inputs.task === void 0) refuse(`select '${spec.select}' needs inputs.task`);
+	if (inputs.graph !== void 0 || inputs.brain !== void 0 || inputs.directives !== void 0) refuse(`select '${spec.select}' runs inputs.profile; a graph, brain or directives is select 'code' or 'fixed'`);
+	if (!harnessRunsAgent(profile.harness)) refuse(`select '${spec.select}' runs the root under Runtime's continuation (context, evaluate and stop), which drives an external harness; profile '${profile.name}' runs on the router brain. Give it a harness such as claude-code or codex, or use select 'code'`);
+	if (spec.workers.count === 0 && grantsSpawn(profile)) refuse(`workers.count 0 runs the root alone, but profile '${profile.name}' grants ${SPAWN_GRANT}`);
+	if (spec.workers.count > 0 && !grantsSpawn(profile)) refuse(`workers.count ${spec.workers.count} needs a root that spawns, and profile '${profile.name}' does not grant ${SPAWN_GRANT}`);
+	if (spec.select === "self" && inputs.workers?.length !== spec.workers.count) refuse(`select 'self' starts exactly workers.count peers; inputs.workers holds ${inputs.workers?.length ?? 0}, and workers.count is ${spec.workers.count}`);
+	if (inputs.workers !== void 0 && passed.registry?.profiles !== void 0) refuse("inputs.workers and options.registry.profiles both name spawnable profiles; pass them once");
+	const registry = inputs.workers === void 0 ? passed.registry : Object.freeze({
+		...passed.registry,
+		profiles: profileTable(inputs.workers)
+	});
+	return Object.freeze({
+		call: "supervise",
+		spec,
+		digest,
+		profile,
+		task: inputs.task,
+		options: Object.freeze({
+			...passed,
+			...axisOptions,
+			budget: inputs.budget,
+			deliverable: inputs.deliverable,
+			...registry === void 0 ? {} : { registry },
+			...inputs.analysts === void 0 ? {} : { analysts: inputs.analysts },
+			...analystKinds.length > 0 ? { analyzeOnSettle: analystKinds } : {},
+			...spec.select === "advisor" ? {
+				maxDepth: 1,
+				inheritSpawnRights: false
+			} : {}
+		})
+	});
+}
+//#endregion
 //#region src/runtime/supervise/sql-run-context.ts
 /**
 * A cross-machine run context on the existing autocommit SqlAdapter. Reuse the same database,
@@ -8824,6 +9277,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { builtinShapes as $, mcpSecretEnvMetadataKey as $t, recordProfileRun as A, declaredCheckDeliverable as At, authorStrategy as B, pairwiseSignificance as Bt, analyzeTrace as C, localSandboxClient as Ct, pickBestProfile as D, superviseDispatch as Dt, loadProfile as E, loopDispatch as Et, chatWorkerSeam as F, completionAuthorizes as Ft, createS3PrivateCasStore as G, SqlRunOwnershipError as Gt, strategyAuthorSystemPrompt as H, renderLeaderboardMarkdown as Ht, createChatSessionStore as I, deterministicCompletion as It, createPrivateCasArtifactPort as J, connectStdioMcp as Jt, printBenchmarkReport as K, openSqlRunStore as Kt, runStrategyEvolution as L, sentinelCompletion as Lt, runCoderChecks as M, declaredCheckJudge as Mt, graphDesignerExtraTools as N, readDeclaredCheck as Nt, profileRegistry as O, assertDeclaredCheck as Ot, chatTransportExecutor as P, runIsolatedCheck as Pt, runPersonified as Q, envKeyProvider as Qt, strategyTournament as R, stopSentinel as Rt, withUntrackedArtifacts as S, resolveSandboxClient as St, bestProfileFor as T, loopCampaignDispatch as Tt, SandboxRunAbortError as U, renderLeaderboardSvg as Ut, strategyAuthorContract as V, renderLeaderboardHtml as Vt, openSandboxRun as W, renderPairwiseMarkdown as Wt, trajectoryReport as X, createMcpEnvironment as Xt, equalKOnCost as Y, materializeLocalMcp as Yt, definePersona as Z, sanitizeMcpToolSchema as Zt, VERIFY_TAIL_CHARS as _, observationFromRegistry as _t, localShell as a, fanout as at, settledWorkerOut as b, harvestCorpus as bt, createVerifierEnvironment as c, panel as ct, harvestSurfaceDiffs as d, verify as dt, resolveMcpServerLaunch as en, createShapeRegistry as et, analystsFromRegistry as f, widen as ft, NOTE_MAX_CHARS as g, registryScopeAnalyst as gt, EVIDENCE_MAX_CHARS as h, createScopeAnalyst as ht, jjWorkspace as i, renderCorpusToInstructions as it, patchDelivered as j, declaredCheckDigest as jt, profileRunsForName as k, checkProgramDigest as kt, boxSurfaceReader as l, pipeline as lt, worktreeFanout as m, buildSteerContext as mt, makeFinding$1 as n, secretEnvOfMcpServer as nn, FileCorpus as nt, runInWorkspace as o, flatWidenGate as ot, failuresAnalyst as p, assertTraceDerivedFindings as pt, runBenchmark as q, McpSpawnFault as qt, gitWorkspace as r, createTangleSandboxExactProcessProvider as rn, InMemoryCorpus as rt, createWaterfallCollector as s, loopUntil as st, computeFindingId$1 as t, resolveSecretEnv as tn, registerShape as tt, fsSurfaceReader as u, selectValidWinner as ut, closingWorkerNote as v, inProcessSandboxClient as vt, createFencedSqlRunContext as w, inlineSandboxClient as wt, copyUntrackedIntoClone as x, defineLeaderboard as xt, composeWorkerEvidence as y, HarvestError as yt, assertStrategyContract as z, leaderboard as zt };
+export { runBenchmark as $, McpSpawnFault as $t, connectRemoteSupervisor as A, inlineSandboxClient as At, chatTransportExecutor as B, runIsolatedCheck as Bt, analyzeTrace as C, observationFromRegistry as Ct, compileSearchSpec as D, defineLeaderboard as Dt, assertSearchSpec as E, harvestCorpus as Et, profileRunsForName as F, checkProgramDigest as Ft, assertStrategyContract as G, leaderboard as Gt, createChatSessionStore as H, deterministicCompletion as Ht, recordProfileRun as I, declaredCheckDeliverable as It, strategyAuthorSystemPrompt as J, renderLeaderboardMarkdown as Jt, authorStrategy as K, pairwiseSignificance as Kt, patchDelivered as L, declaredCheckDigest as Lt, loadProfile as M, loopDispatch as Mt, pickBestProfile as N, superviseDispatch as Nt, searchPresets as O, resolveSandboxClient as Ot, profileRegistry as P, assertDeclaredCheck as Pt, printBenchmarkReport as Q, openSqlRunStore as Qt, runCoderChecks as R, declaredCheckJudge as Rt, withUntrackedArtifacts as S, registryScopeAnalyst as St, SEARCH_SPEC_CORRELATION_KEY as T, HarvestError as Tt, runStrategyEvolution as U, sentinelCompletion as Ut, chatWorkerSeam as V, completionAuthorizes as Vt, strategyTournament as W, stopSentinel as Wt, openSandboxRun as X, renderPairwiseMarkdown as Xt, SandboxRunAbortError as Y, renderLeaderboardSvg as Yt, createS3PrivateCasStore as Z, SqlRunOwnershipError as Zt, VERIFY_TAIL_CHARS as _, verify as _t, localShell as a, mcpSecretEnvMetadataKey as an, builtinShapes as at, settledWorkerOut as b, buildSteerContext as bt, createVerifierEnvironment as c, secretEnvOfMcpServer as cn, FileCorpus as ct, harvestSurfaceDiffs as d, fanout as dt, connectStdioMcp as en, createPrivateCasArtifactPort as et, analystsFromRegistry as f, flatWidenGate as ft, NOTE_MAX_CHARS as g, selectValidWinner as gt, EVIDENCE_MAX_CHARS as h, pipeline as ht, jjWorkspace as i, envKeyProvider as in, runPersonified as it, bestProfileFor as j, loopCampaignDispatch as jt, searchSpecDigest as k, localSandboxClient as kt, boxSurfaceReader as l, createTangleSandboxExactProcessProvider as ln, InMemoryCorpus as lt, worktreeFanout as m, panel as mt, makeFinding$1 as n, createMcpEnvironment as nn, trajectoryReport as nt, runInWorkspace as o, resolveMcpServerLaunch as on, createShapeRegistry as ot, failuresAnalyst as p, loopUntil as pt, strategyAuthorContract as q, renderLeaderboardHtml as qt, gitWorkspace as r, sanitizeMcpToolSchema as rn, definePersona as rt, createWaterfallCollector as s, resolveSecretEnv as sn, registerShape as st, computeFindingId$1 as t, materializeLocalMcp as tn, equalKOnCost as tt, fsSurfaceReader as u, renderCorpusToInstructions as ut, closingWorkerNote as v, widen as vt, createFencedSqlRunContext as w, inProcessSandboxClient as wt, copyUntrackedIntoClone as x, createScopeAnalyst as xt, composeWorkerEvidence as y, assertTraceDerivedFindings as yt, graphDesignerExtraTools as z, readDeclaredCheck as zt };
 
-//# sourceMappingURL=runtime-B47V5Omi.js.map
+//# sourceMappingURL=runtime-EiTCboO2.js.map