@tangle-network/agent-runtime 0.320.1 → 0.321.0

package/dist/{runtime-B47V5Omi.js → runtime-wLgjMOaj.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-bkq2b8k-.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-TEKWC579.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-Bpn05N-Y.js";
+import { r as supervise } from "./supervise-C4bLIU7J.js";
 import "./run-layout-DSCWdbX2.js";
-import "./provision-supervisor-BUMhF1yb.js";
-import "./delegate-BHRR-4hh.js";
-import "./graph-BGMcJJP1.js";
+import "./provision-supervisor-DvgBNtoJ.js";
+import "./delegate-BHlcTOdK.js";
+import "./graph-DE2dLhDI.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";
@@ -7539,6 +7539,394 @@ async function bestProfileFor(reg, name) {
 	} : void 0;
 }
 //#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" && !callerOwnsLeaves) refuse(`comms 'messages' needs workers that can call peer mail: Runtime mounts it on 'bridge' 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 +9212,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 { createPrivateCasArtifactPort as $, connectStdioMcp as $t, bestProfileFor as A, loopCampaignDispatch as At, chatWorkerSeam as B, completionAuthorizes as Bt, analyzeTrace as C, inProcessSandboxClient as Ct, compileSearchSpec as D, resolveSandboxClient as Dt, assertSearchSpec as E, defineLeaderboard as Et, recordProfileRun as F, declaredCheckDeliverable as Ft, authorStrategy as G, pairwiseSignificance as Gt, runStrategyEvolution as H, sentinelCompletion as Ht, patchDelivered as I, declaredCheckDigest as It, SandboxRunAbortError as J, renderLeaderboardSvg as Jt, strategyAuthorContract as K, renderLeaderboardHtml as Kt, runCoderChecks as L, declaredCheckJudge as Lt, pickBestProfile as M, superviseDispatch as Mt, profileRegistry as N, assertDeclaredCheck as Nt, searchPresets as O, localSandboxClient as Ot, profileRunsForName as P, checkProgramDigest as Pt, runBenchmark as Q, McpSpawnFault as Qt, graphDesignerExtraTools as R, readDeclaredCheck as Rt, withUntrackedArtifacts as S, observationFromRegistry as St, SEARCH_SPEC_CORRELATION_KEY as T, harvestCorpus as Tt, strategyTournament as U, stopSentinel as Ut, createChatSessionStore as V, deterministicCompletion as Vt, assertStrategyContract as W, leaderboard as Wt, createS3PrivateCasStore as X, SqlRunOwnershipError as Xt, openSandboxRun as Y, renderPairwiseMarkdown as Yt, printBenchmarkReport as Z, openSqlRunStore as Zt, VERIFY_TAIL_CHARS as _, widen as _t, localShell as a, resolveMcpServerLaunch as an, createShapeRegistry as at, settledWorkerOut as b, createScopeAnalyst as bt, createVerifierEnvironment as c, createTangleSandboxExactProcessProvider as cn, InMemoryCorpus as ct, harvestSurfaceDiffs as d, flatWidenGate as dt, materializeLocalMcp as en, equalKOnCost as et, analystsFromRegistry as f, loopUntil as ft, NOTE_MAX_CHARS as g, verify as gt, EVIDENCE_MAX_CHARS as h, selectValidWinner as ht, jjWorkspace as i, mcpSecretEnvMetadataKey as in, builtinShapes as it, loadProfile as j, loopDispatch as jt, searchSpecDigest as k, inlineSandboxClient as kt, boxSurfaceReader as l, renderCorpusToInstructions as lt, worktreeFanout as m, pipeline as mt, makeFinding$1 as n, sanitizeMcpToolSchema as nn, definePersona as nt, runInWorkspace as o, resolveSecretEnv as on, registerShape as ot, failuresAnalyst as p, panel as pt, strategyAuthorSystemPrompt as q, renderLeaderboardMarkdown as qt, gitWorkspace as r, envKeyProvider as rn, runPersonified as rt, createWaterfallCollector as s, secretEnvOfMcpServer as sn, FileCorpus as st, computeFindingId$1 as t, createMcpEnvironment as tn, trajectoryReport as tt, fsSurfaceReader as u, fanout as ut, closingWorkerNote as v, assertTraceDerivedFindings as vt, createFencedSqlRunContext as w, HarvestError as wt, copyUntrackedIntoClone as x, registryScopeAnalyst as xt, composeWorkerEvidence as y, buildSteerContext as yt, chatTransportExecutor as z, runIsolatedCheck as zt };
 
-//# sourceMappingURL=runtime-B47V5Omi.js.map
+//# sourceMappingURL=runtime-wLgjMOaj.js.map