@tangle-network/agent-runtime 0.121.0 → 0.123.0

package/dist/{supervise-BHHMtwP9.js → supervise-Dwq16u8n.js}

@@ -1,10 +1,10 @@
 import { c as RuntimeRunStateError, i as ConfigError, o as NotFoundError, t as AgentEvalError$1, u as ValidationError } from "./errors-DEAvWQPy.js";
-import { S as detachedSnapshot, b as workerTraceAnalysisStore, d as writeAllBytes, i as InMemorySpawnJournal, l as parseCommittedJsonLines, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore, u as prepareJsonlAppend, x as contentAddress } from "./spawn-journal-IeXpidO2.js";
+import { S as detachedSnapshot, b as workerTraceAnalysisStore, d as writeAllBytes, i as InMemorySpawnJournal, l as parseCommittedJsonLines, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore, u as prepareJsonlAppend, x as contentAddress } from "./spawn-journal-DsZKDqeh.js";
 import { a as randomSuffix, c as stringifySafe, d as withTimeout, f as zeroTokenUsage, i as mapWithConcurrency, l as throwAbort, n as deleteBoxSafe, o as randomUuid, s as sleep, t as addTokenUsage, u as throwIfAborted } from "./util-MVgdwuIS.js";
-import { $ as WORKER_TOKEN_FLOOR, At as promptControlProfileMaterialization, C as buildLoopSpanNodes, Ct as removeWorktree, Dt as defineProfileMaterializationContract, E as createOtelExporter, Et as controlProfileMaterialization, G as describeToolArgs, J as freeSlots, Lt as worktreeCliProfileMaterialization, Ot as fullProfileMaterialization, Q as teardownExecutor, St as createWorktree, Tt as assertProfileMaterialization, W as createActivityLog, Z as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, a as pickBestDelivered, at as attestRuntimeOwnedScopeOwner, bt as worktreeProfileExecutionPlan, c as driverChild, ct as runtimeOwnedExecutorExecutionBinding, d as deriveNodeExecutionIdentity, dt as routerBrain, et as workerTokenFloor, f as recordScopeOwnerMaterialization, g as workerTraceEnv, gt as runBrainLoop, it as attestRuntimeOwnedExecutor, j as toOtelAttributes, jt as promptModelProfileMaterialization, k as generateSpanId, kt as profileMaterializationAxes, l as withDriverExecutor, lt as runtimeOwnedExecutorMaterialization, n as createSupervisor, o as runFinalizer, ot as inheritRuntimeOwnedExecutorAttestation, p as scopeOwnerExecutorNodeContext, pt as routerChatWithUsage, r as bestDelivered, rt as spendFromUsageEvents, s as runTree, st as newExecutionAttemptId, tt as assertValidBudget, ut as runtimeOwnedScopeOwnerRuntime, vt as runWorktreeChecks, xt as captureWorktreeDiff, yt as runWorktreeHarness } from "./supervisor-CpT9yAxL.js";
+import { At as controlProfileMaterialization, Ct as runWorktreeHarness, Dt as removeWorktree, Et as createWorktree, F as toOtelAttributes, Ft as promptModelProfileMaterialization, J as createActivityLog, Mt as fullProfileMaterialization, Nt as profileMaterializationAxes, O as createOtelExporter, Pt as promptControlProfileMaterialization, Q as freeSlots, St as runWorktreeChecks, T as buildLoopSpanNodes, Tt as captureWorktreeDiff, Vt as worktreeCliProfileMaterialization, Y as describeToolArgs, _ as workerTraceEnv, _t as routerChatWithUsage, a as pickBestDelivered, at as assertValidBudget, b as mergeTraceEnv, bt as runBrainLoop, c as driverChild, ct as attestRuntimeOwnedExecutor, d as deriveNodeExecutionIdentity, dt as newExecutionAttemptId, f as recordScopeOwnerMaterialization, ft as runtimeOwnedExecutorExecutionBinding, h as WORKER_TRACE_PROPAGATION, ht as routerBrain, it as workerTokenFloor, j as generateSpanId, jt as defineProfileMaterializationContract, kt as assertProfileMaterialization, l as withDriverExecutor, lt as attestRuntimeOwnedScopeOwner, mt as runtimeOwnedScopeOwnerRuntime, n as createSupervisor, nt as teardownExecutor, o as runFinalizer, p as scopeOwnerExecutorNodeContext, pt as runtimeOwnedExecutorMaterialization, r as bestDelivered, rt as WORKER_TOKEN_FLOOR, s as runTree, st as spendFromUsageEvents, tt as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, ut as inheritRuntimeOwnedExecutorAttestation, wt as worktreeProfileExecutionPlan } from "./supervisor-DjZ82HIB.js";
 import { i as notifyRuntimeHookEvent, t as composeRuntimeHooks } from "./runtime-hooks-C7iJOWm3.js";
 import { a as notifySandboxEventObserver, n as extractLlmCallEvent } from "./sandbox-events-Yhd1GYWl.js";
-import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, r as providerAsSandboxClient, s as buildBackendOptions } from "./environment-provider-DChfYm2-.js";
+import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, r as providerAsSandboxClient } from "./environment-provider-CY22kUQH.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";
@@ -141,6 +141,177 @@ function isAsyncIterable$2(v) {
 	return v != null && typeof v[Symbol.asyncIterator] === "function";
 }
 //#endregion
+//#region src/runtime/supervise/prompt-registry.ts
+/**
+*
+* The kernel prompt registry — versioned prompt text as DATA, addressed by `PromptHandle`.
+*
+* A role expressed as a builder FUNCTION is a role that can never improve: the only optimizable
+* surface it leaves is whatever thin string a caller happens to inject, while the real doctrine
+* sits hardcoded in TypeScript. This registry is the inverse: every standing instruction is a
+* versioned entry (`<surface>` + `v<n>`), so a graph edge, a supervisor front door, or an
+* optimizer names a handle and the TEXT is swappable, sweepable, and diffable without a code
+* change. Graph edges (`runGraph`) carry handles, never inline prose.
+*
+* ONE policy per role, whichever front door builds it: the seeded `supervisor/policy` entry is the
+* single supervisor stance. The package previously shipped two contradictory defaults — the router
+* arm's "do small work YOURSELF" (`defaultSupervisorPrompt`) versus the delegate front door's "you
+* do NOT do the work yourself" (`supervisorInstructions`) — selected by entry point. Both now
+* derive from the one entry here; which door you enter no longer decides the policy.
+*
+* @experimental
+*/
+const HANDLE_PATTERN = /^(.+)\/v(\d+)$/;
+/**
+* Parse `'<surface>/v<n>'` into a {@link PromptHandle}. The shorthand for authoring a graph edge:
+* `directive: promptHandle('delegates/worker-brief/v1')`.
+*/
+function promptHandle(ref) {
+	if (typeof ref !== "string" || ref.length === 0) throw new ValidationError("promptHandle: ref must be a non-empty string");
+	const match = HANDLE_PATTERN.exec(ref);
+	if (!match) throw new ValidationError(`promptHandle: ${JSON.stringify(ref)} is not a versioned prompt reference (<surface>/v<n>)`);
+	const version = Number(match[2]);
+	if (!Number.isSafeInteger(version) || version < 0) throw new ValidationError(`promptHandle: invalid version in ${JSON.stringify(ref)}`);
+	return {
+		surface: match[1],
+		version
+	};
+}
+/** The string form of a handle: `<surface>/v<n>`. */
+function formatPromptHandle(handle) {
+	return `${handle.surface}/v${handle.version}`;
+}
+/** Create a registry, optionally seeded. Entries are copied; the registry never aliases caller state. */
+function createPromptRegistry(seed) {
+	const entries = /* @__PURE__ */ new Map();
+	const keyOf = (surface, version) => `${surface}/v${version}`;
+	const register = (entry) => {
+		if (typeof entry.surface !== "string" || entry.surface.length === 0) throw new ValidationError("prompt registry: entry.surface must be a non-empty string");
+		if (!Number.isSafeInteger(entry.version) || entry.version < 0) throw new ValidationError("prompt registry: entry.version must be a non-negative integer");
+		if (typeof entry.text !== "string" || entry.text.length === 0) throw new ValidationError(`prompt registry: entry ${keyOf(entry.surface, entry.version)} has no text — an empty directive is the silent-substitution failure this registry exists to prevent`);
+		const key = keyOf(entry.surface, entry.version);
+		if (entries.has(key)) throw new ValidationError(`prompt registry: ${key} is already registered — versions are immutable; register a new version instead`);
+		entries.set(key, Object.freeze({ ...entry }));
+	};
+	for (const entry of seed ?? []) register(entry);
+	return {
+		resolve(handle) {
+			const found = entries.get(keyOf(handle.surface, handle.version));
+			if (!found) throw new ValidationError(`prompt registry: no entry for ${formatPromptHandle(handle)} — a directive must resolve or fail loud, never fall back silently (registered: ${[...entries.keys()].join(", ") || "none"})`);
+			return found;
+		},
+		register,
+		list() {
+			return Object.freeze([...entries.values()]);
+		}
+	};
+}
+/**
+* THE supervisor policy — one stance, both front doors. The work-vs-delegate rule is conditional
+* on capability (work tools present or not), which is what dissolves the old contradiction: "do
+* small work yourself" was written for a supervisor WITH work tools, "you do not do the work" for
+* one WITHOUT — one policy states both branches explicitly.
+*/
+const supervisorPolicyPrompt = Object.freeze({
+	surface: "supervisor/policy",
+	version: 1,
+	description: "The single supervisor stance: accountability, work-vs-delegate rule, context lifecycle, stop condition.",
+	text: [
+		"You are a supervisor accountable for DELIVERING the task — not for looking busy. You succeed",
+		"only when the deliverable is actually produced and verified, never on a worker reporting \"done\".",
+		"",
+		"Work-vs-delegate — one rule, conditional on your capability:",
+		"- Do small, sequential work YOURSELF only when you hold WORK tools for it (tools beyond the",
+		"  coordination verbs). Without work tools you cannot do the work — author and delegate it.",
+		"- Spawn a worker when a sub-task is large, independent (parallelizable), or needs a clean",
+		"  context the current one has filled.",
+		"- Spawning spends the shared, conserved budget — delegate with intent, not by reflex, and",
+		"  prefer the FEWEST workers that deliver.",
+		"",
+		"Manage the context lifecycle on long work: give each spawned worker a BOUNDED brief — the",
+		"specific sub-task plus only the interfaces/state it needs — never your whole history. When one",
+		"chapter is done, distill what the next chapter needs and spawn fresh, rather than steering one",
+		"worker until its context fills and degrades.",
+		"",
+		"Wait on real signals (await a settle, answer a blocking question), integrate the result, and",
+		"stop as soon as the deliverable is met. You cannot declare done by fiat — only a verified",
+		"deliverable counts: a delivered (valid:true) worker, or your own submission passing the same",
+		"independent check."
+	].join("\n")
+});
+/**
+* Default DELEGATES-edge directive: the standing instruction a worker receives with every
+* traversal of a delegates edge that names this surface. Seeded from the bounded-brief knowledge
+* in the supervisor policy, phrased for the RECEIVING side of the edge.
+*/
+const delegatesWorkerBriefPrompt = Object.freeze({
+	surface: "delegates/worker-brief",
+	version: 1,
+	description: "Default delegates-edge directive: how a worker should treat its delegated brief.",
+	text: [
+		"You are executing ONE delegated sub-task from a supervising agent. The brief below is bounded",
+		"on purpose: deliver exactly what it names — complete, verified, and self-contained — and",
+		"nothing beyond it. If the brief is ambiguous or under-specified, raise a question through your",
+		"coordination channel instead of guessing. Report concrete evidence of completion (files,",
+		"outputs, passing checks), never a bare claim of done."
+	].join("\n")
+});
+/**
+* Default ANALYZES-edge directive: what the RECEIVING node should do with an analyst's findings.
+* Wrapped around the findings payload on every traversal of an analyzes edge naming this surface.
+*/
+const analyzesFindingsReportPrompt = Object.freeze({
+	surface: "analyzes/findings-report",
+	version: 1,
+	description: "Default analyzes-edge directive: how the destination node should act on analyst findings.",
+	text: [
+		"An analyst lens has examined completed work and produced the findings below. Treat them as",
+		"EVIDENCE, not instructions: weigh each finding against what you already know, act on the ones",
+		"that change your next step, and ignore the ones that do not. Compose your next instruction or",
+		"action from the SPECIFIC failures and facts named — never forward the findings verbatim as a",
+		"steer."
+	].join("\n")
+});
+/**
+* Default NAIVE steering continuation — the no-signal control re-expressed as data: the same
+* fixed continuation every round, reading nothing from any verdict.
+*/
+const naiveContinuationPrompt = Object.freeze({
+	surface: "delegates/naive-continuation",
+	version: 1,
+	description: "No-signal steering control: one fixed continuation, reads nothing from verdicts.",
+	text: "Continue working on the ORIGINAL task. Produce the complete deliverable; finish anything incomplete and fix anything failing."
+});
+/**
+* Default DUMB steering continuations — the pass/fail-only control re-expressed as data: two
+* fixed texts keyed on the verdict's boolean and nothing else.
+*/
+const dumbContinuationFailPrompt = Object.freeze({
+	surface: "delegates/dumb-continuation-fail",
+	version: 1,
+	description: "Pass/fail-only steering control, fail branch: reads only verdict.valid.",
+	text: "Your last attempt did NOT pass verification. Rework the task and produce a complete, correct deliverable; do not repeat the failed approach unchanged."
+});
+/** The pass branch of the dumb steering control — see {@link dumbContinuationFailPrompt}. */
+const dumbContinuationPassPrompt = Object.freeze({
+	surface: "delegates/dumb-continuation-pass",
+	version: 1,
+	description: "Pass/fail-only steering control, pass branch: reads only verdict.valid.",
+	text: "Your last attempt passed verification. Finalize your work and stop."
+});
+/** The kernel's seeded registry: every surface the runtime's own builders derive from. A caller
+*  may register additional surfaces/versions on the returned registry. */
+function kernelPromptRegistry() {
+	return createPromptRegistry([
+		supervisorPolicyPrompt,
+		delegatesWorkerBriefPrompt,
+		analyzesFindingsReportPrompt,
+		naiveContinuationPrompt,
+		dumbContinuationFailPrompt,
+		dumbContinuationPassPrompt
+	]);
+}
+//#endregion
 //#region src/runtime/supervise/authoring.ts
 /**
 *
@@ -204,10 +375,17 @@ function canonicalizeAuthoredProfile(raw) {
 	return authored;
 }
 /** The supervisor SKILL — the how-to the supervisor reads (its system prompt). THE optimizable
-*  surface: editing this changes how the supervisor designs every agent it spawns. */
+*  surface: editing this changes how the supervisor designs every agent it spawns.
+*
+*  The POLICY paragraph is the registry's one `supervisor/policy` entry — the same stance
+*  `defaultSupervisorPrompt` carries — so both front doors run the same work-vs-delegate rule;
+*  this function ADDS the profile-authoring skill (how to WRITE the workers it spawns), which is
+*  additive craft, not a different policy. */
 function supervisorInstructions(opts) {
 	return [
-		"You are a SUPERVISOR. You do NOT do the work yourself — your job is to DESIGN and DRIVE specialist worker agents.",
+		supervisorPolicyPrompt.text,
+		"",
+		"Your delegation craft is AUTHORING: a spawned worker is exactly as good as the profile you write.",
 		"",
 		"For the task you are given:",
 		"1. DECOMPOSE it into the smallest set of sub-tasks a single focused worker can each deliver.",
@@ -220,7 +398,7 @@ function supervisorInstructions(opts) {
 		"   NEVER spawn a worker with an empty profile. The quality of the worker IS the quality of the profile you write.",
 		"3. await_event (kinds:['settled']) to collect each worker. Its result says valid:true only if the deployable check passed.",
 		"4. If a worker did NOT deliver, AUTHOR A NEW profile whose prompt.systemPrompt names the SPECIFIC failure and how to fix it — never just retry the same profile.",
-		"5. Stop (reply with no tool call) once the work is delivered. You cannot declare done yourself — only a delivered (valid:true) worker counts.",
+		"5. Stop (reply with no tool call) once the work is delivered.",
 		...opts?.goal ? ["", `The goal: ${opts.goal}`] : []
 	].join("\n");
 }
@@ -959,6 +1137,71 @@ function isRetryable(err) {
 	return /provision failed|edge data plane|not reachable|failed to create sandbox/i.test(msg);
 }
 //#endregion
+//#region src/runtime/sandbox-backend.ts
+/**
+* Harnesses the sandbox accepts as a `backend.type`. `gemini` is a
+* `HarnessType` with no sandbox backend, so it is absent here and a profile
+* declaring it cannot run through this path.
+*
+* The double `satisfies` pins both directions: an entry the sandbox drops stops
+* compiling, and an entry that is not a harness stops compiling.
+*/
+const harnessBackends = [
+	"claude-code",
+	"nanoclaw",
+	"codex",
+	"opencode",
+	"kimi-code",
+	"pi",
+	"hermes",
+	"openclaw",
+	"amp",
+	"factory-droids",
+	"acp",
+	"cli-base"
+];
+function harnessAsBackendType(harness) {
+	return harnessBackends.includes(harness) ? harness : void 0;
+}
+/**
+* Resolve the backend `type`: an explicit override wins, then the profile's
+* `metadata.backendType` hint, then the profile's declared `harness`, else the
+* SDK's profile-driven default (`'opencode'` on the platform side).
+*
+* A declared `harness` the sandbox cannot run throws rather than falling
+* through: silently running a `gemini` profile on opencode returns a result
+* that means something other than it appears to, which is worse than no result.
+*/
+function resolveBackendType(profile, override) {
+	if (override?.type) return override.type;
+	const explicit = profile.metadata?.backendType;
+	if (typeof explicit === "string") return explicit;
+	const declared = profile.harness;
+	if (declared !== void 0) {
+		const backend = harnessAsBackendType(declared);
+		if (backend === void 0) throw new Error(`buildBackendOptions: profile declares harness "${declared}", which the sandbox has no backend for. Runnable harnesses: ${harnessBackends.join(", ")}. Set metadata.backendType to run it on a different backend deliberately.`);
+		return backend;
+	}
+	return "opencode";
+}
+/**
+* Build `CreateSandboxOptions` for `profile`, merging `overrides` and setting
+* `backend.profile`. `model`/`server` from an override backend pass through.
+*/
+function buildBackendOptions(profile, overrides) {
+	const base = overrides ?? {};
+	const overrideBackend = base.backend;
+	return {
+		...base,
+		backend: {
+			type: resolveBackendType(profile, overrideBackend),
+			profile,
+			...overrideBackend?.model ? { model: overrideBackend.model } : {},
+			...overrideBackend?.server ? { server: overrideBackend.server } : {}
+		}
+	};
+}
+//#endregion
 //#region src/runtime/sandbox-capabilities.ts
 const probeCache = /* @__PURE__ */ new WeakMap();
 /**
@@ -2402,10 +2645,11 @@ function readPromptOptions(loopCtx) {
 * result onto the `Executor` port (artifact + spend) and owns the teardown point. The complete
 * profile delivery — direct prompt/model plus materialized file-backed resources — lives there.
 *
-* Token accounting: ordinary harness CLI runs remain `budgetExempt`. Reproducible Codex mode
+* Token accounting: ordinary harness CLI runs remain `budgetExempt`, and their `Spend` marks
+* `tokensKnown: false` — the `{0,0}` is a floor, never a measured-free run. Reproducible Codex mode
 * parses the CLI's terminal JSONL usage and is metered by default; an absent usage event fails the
 * run instead of recording fabricated zero tokens. Codex does not report dollar cost, so that
-* channel is explicitly marked unknown on the resulting `Spend`.
+* channel is explicitly marked unknown on the metered path.
 *
 * @experimental
 */
@@ -2475,6 +2719,7 @@ function createWorktreeCliExecutor(options) {
 					input: 0,
 					output: 0
 				},
+				...usage ? {} : { tokensKnown: false },
 				usd: 0,
 				...usage ? { usdKnown: false } : {},
 				ms: Date.now() - started
@@ -2623,12 +2868,39 @@ function contentRef(prefix, value) {
 	}
 	return `${prefix}:${(h >>> 0).toString(16).padStart(8, "0")}`;
 }
-function zeroSpend() {
+/**
+* The spend of work that HAPPENED and reported no usage receipt.
+*
+* Not the same value as a plain zero even though both carry `{0,0}` tokens and `$0`. A bare zero
+* asserts a MEASUREMENT — "this ran and cost nothing" — and every consumer downstream reads it that
+* way: the pool keeps reporting `readout().tokensKnown === true`, the journal totals stay clean, the
+* OTEL span records a priced zero, and a caller's token-denominated ceiling can never fire no matter
+* how much the work really burned. A ceiling that cannot fire is worse than no ceiling, because it
+* reads as protection.
+*
+* `Spend.tokensKnown` is the marker the substrate already threads end to end for exactly this case
+* (`budget.ts`, `otel-spans.ts`, `spawn-journal.ts`, `supervisor.ts`): the work is recorded, the
+* zero is labelled a floor rather than a total, and every rollup that touches it reports its balance
+* as a ceiling rather than a measurement. Use this — never a bare zero — whenever a runtime cannot
+* see what its worker spent.
+*
+* DELIBERATELY NOT `usdKnown: false`, and this is not an oversight. On the dollar channel that flag
+* is not a marker but a REFUSAL: `budget.ts` treats unknown dollars under a dollar-capped root as a
+* reconcile violation and fails the child. Applying it here would contradict `budgetExempt`, whose
+* whole documented contract is that such a worker settles OUT of the conserved pool rather than
+* against it (`scope.ts`) — a worker the kernel already agreed not to budget would start failing
+* after its work had burned, which is a policy change about which configurations are allowed, not a
+* fix to how honestly spend is reported. The token marker taints only token accounting. Under the
+* current `budgetExempt` policy the surviving `usd: 0` remains dollar-known; callers that require
+* dollar accounting must use a backend that returns priced usage.
+*/
+function unmeteredSpend(ms) {
 	return {
 		iterations: 0,
 		tokens: zeroTokenUsage(),
+		tokensKnown: false,
 		usd: 0,
-		ms: 0
+		ms
 	};
 }
 /**
@@ -3172,6 +3444,10 @@ function leafVerdict(result) {
 * `budgetExempt: true`: it remains usable as a direct executor, while budgeted supervision
 * refuses it before process execution because the CLI exposes no usage receipt. teardown is SIGTERM → SIGKILL
 * with a grace window. Streaming: yields one `iteration` event on clean exit.
+*
+* Its terminal spend is `unmeteredSpend`, NOT a zero: an unmetered runtime that reports a plain
+* `0` is indistinguishable from one that measured zero, and every ceiling downstream then reads
+* as enforced while enforcing nothing.
 */
 const cliExecutor = (_spec, ctx) => {
 	const seam = readSeam(ctx, cliSeamKey, "cli");
@@ -3249,14 +3525,11 @@ const cliExecutor = (_spec, ctx) => {
 	});
 };
 async function* streamCliLeaf(args) {
+	const started = Date.now();
 	const prompt = taskToPrompt(args.task);
 	const proc = spawn(args.seam.bin, args.seam.args ?? [], {
 		...args.seam.cwd ? { cwd: args.seam.cwd } : {},
-		env: {
-			...process.env,
-			...args.traceEnv,
-			...args.seam.env ?? {}
-		},
+		env: mergeTraceEnv(process.env, args.traceEnv, args.seam.env),
 		stdio: [
 			"pipe",
 			"pipe",
@@ -3293,7 +3566,7 @@ async function* streamCliLeaf(args) {
 	args.onArtifact({
 		outRef: contentRef("cli", out),
 		out,
-		spent: zeroSpend()
+		spent: unmeteredSpend(Date.now() - started)
 	});
 	yield { kind: "iteration" };
 }
@@ -4858,6 +5131,35 @@ function belowFloorHint(harness) {
 	if (floor !== null) return `The ${harness} harness spends a measured minimum of ${floor} input tokens before any work, so this budget's maxTokens can never be satisfied. Raise maxTokens to at least ${floor}; retrying with a smaller budget will fail identically.`;
 	return "This budget's maxTokens is below the measured minimum a harness child spends before any work, so it can never be satisfied. Raise maxTokens to at least the floor for the child harness — measured floors (input tokens): " + measuredFloors.map(([h, f]) => `${h}=${f}`).join(", ") + " — retrying with a smaller budget will fail identically.";
 }
+/** Producer-side cleanliness for the `finding` event. The findings payload is arbitrary analyst
+*  output, the digest a subscriber computes (RFC 8785) throws on ANY `undefined` value — nested
+*  included — and a throwing subscriber leaves the event invisible to EVERY subscriber. The
+*  producer, not the digest, owns keeping the event canonical: an `undefined` payload is stripped
+*  to key-absence, everything else is JSON round-tripped (nested `undefined` object values drop,
+*  `undefined` array slots become `null`), and a payload JSON cannot represent at all (cycle,
+*  BigInt, bare function) becomes a record OF that fact — degraded findings beat a vanished
+*  event. */
+function canonicalFindingEvent(finding) {
+	if (finding.findings === void 0) {
+		const { findings: _absent, ...present } = finding;
+		return present;
+	}
+	try {
+		return {
+			...finding,
+			findings: JSON.parse(JSON.stringify(finding.findings))
+		};
+	} catch (error) {
+		return {
+			...finding,
+			findings: { nonCanonicalFindings: error instanceof Error ? error.message : String(error) }
+		};
+	}
+}
+/** Normalize the two spellings of an analyst-on-settle entry to the route form. */
+function normalizeAnalyzeOnSettle(entry) {
+	return typeof entry === "string" ? { kind: entry } : entry;
+}
 /** 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. */
@@ -5060,6 +5362,7 @@ function createCoordinationTools(opts) {
 	const questionPolicy = opts.questionPolicy ?? "auto";
 	const completedKeys = /* @__PURE__ */ new Set();
 	const keyByWorker = /* @__PURE__ */ new Map();
+	const profileNameByWorker = /* @__PURE__ */ new Map();
 	let unkeyedAssignmentOrdinal = nextUnkeyedAssignmentOrdinal(opts.scope);
 	for (const [key, prior] of opts.scope.resume?.keys ?? []) if (prior.state === "completed") completedKeys.add(key);
 	const nodeForWorker = (id) => opts.scope.view.nodes.find((node) => node.id === id) ?? opts.scope.resume?.view.nodes.find((node) => node.id === id);
@@ -5176,6 +5479,73 @@ function createCoordinationTools(opts) {
 		unwatchWorker(w.id);
 	};
 	let pendingSettlement;
+	const workerRouteNames = (workerId) => {
+		const names = /* @__PURE__ */ new Set();
+		const profileName = profileNameByWorker.get(workerId);
+		if (profileName !== void 0) names.add(profileName);
+		const label = nodeForWorker(workerId)?.label;
+		if (label !== void 0) names.add(label);
+		return names;
+	};
+	/** The LIVE worker a route destination names, by profile name first, label second. */
+	const liveWorkerIdNamed = (destination) => {
+		const live = opts.scope.view.nodes.filter((node) => isLive(node.status));
+		return live.find((node) => profileNameByWorker.get(node.id) === destination)?.id ?? live.find((node) => node.label === destination)?.id;
+	};
+	/**
+	* Deliver one routed analyst finding to its destination worker through the SAME authorized
+	* steer machinery a driver steer uses, so the delivery is recorded (`steer` event carrying
+	* `analyst`) and its outcome is a fact. No live destination ⇒ a record-only failed steer —
+	* observable, never a silent drop. A throw here must not kill the settle path: failures are
+	* recorded on the bus (a `steer` with `delivered: false`) before being swallowed, with ONE
+	* narrow exception — a bus that refuses the `delivery-attempt` record itself leaves only the
+	* `instruction` receipt (an attempt with no outcome = explicitly unknown, per
+	* recordDeliveryAttempt's own contract).
+	*/
+	const deliverRoutedFinding = async (route, findings) => {
+		const destination = route.to;
+		const text = route.directive === void 0 || route.directive.length === 0 ? safeJsonText(findings) : `${route.directive}\n\n${safeJsonText(findings)}`;
+		const targetId = liveWorkerIdNamed(destination);
+		if (targetId === void 0) {
+			await bus.publish({
+				type: "steer",
+				down: deepFreezeDetached({
+					receiptId: randomUUID(),
+					toWorker: destination,
+					instruction: text,
+					instructionDigest: canonicalCandidateDigest(text),
+					delivered: false,
+					outcome: "unknown-worker"
+				}),
+				analyst: route.kind
+			}, { queue: false });
+			return;
+		}
+		let instruction;
+		try {
+			instruction = authorizeInstruction("steer", targetId, text, false);
+			await recordInstruction(instruction);
+		} catch (cause) {
+			try {
+				await sendDown("steer", deepFreezeDetached({
+					receiptId: randomUUID(),
+					toWorker: targetId,
+					instruction: text,
+					instructionDigest: canonicalCandidateDigest(text),
+					delivered: false,
+					outcome: "runtime-error",
+					error: cause instanceof Error ? cause.message : String(cause)
+				}), route.kind);
+			} catch {}
+			return;
+		}
+		try {
+			await attemptDelivery(instruction, {
+				steer: instruction.instruction,
+				interrupt: false
+			}, { analyst: route.kind });
+		} catch {}
+	};
 	const flushPendingSettlement = async () => {
 		const pending = pendingSettlement;
 		if (!pending) return false;
@@ -5183,17 +5553,23 @@ function createCoordinationTools(opts) {
 		commitSettled(pending.settled, pending.worker);
 		pendingSettlement = void 0;
 		if (pending.analyze && pending.worker.status === "done" && pending.worker.trace.status === "available" && opts.analysts && opts.analyzeOnSettle?.length) {
-			const trace = await workerTraceAnalysisStore(pending.worker.trace, opts.blobs);
-			for (const analyst of opts.analyzeOnSettle) {
-				const findings = await opts.analysts.run(analyst, trace);
-				await bus.publish({
-					type: "finding",
-					finding: {
-						fromWorker: pending.worker.id,
-						analyst,
-						findings
-					}
-				});
+			const routes = opts.analyzeOnSettle.map(normalizeAnalyzeOnSettle);
+			const sourceNames = workerRouteNames(pending.worker.id);
+			const applicable = routes.filter((route) => route.over === void 0 || route.over.some((name) => sourceNames.has(name)));
+			if (applicable.length > 0) {
+				const trace = await workerTraceAnalysisStore(pending.worker.trace, opts.blobs);
+				for (const route of applicable) {
+					const findings = await opts.analysts.run(route.kind, trace);
+					await bus.publish({
+						type: "finding",
+						finding: canonicalFindingEvent({
+							fromWorker: pending.worker.id,
+							analyst: route.kind,
+							findings
+						})
+					});
+					if (route.to !== void 0) await deliverRoutedFinding(route, findings);
+				}
 			}
 		}
 		return true;
@@ -5236,11 +5612,15 @@ function createCoordinationTools(opts) {
 			drained += 1;
 		}
 	};
-	async function sendDown(type, down, questionId) {
+	async function sendDown(type, down, questionIdOrAnalyst) {
 		await bus.publish(type === "answer" ? {
 			type,
 			down,
-			questionId: str(questionId, "questionId")
+			questionId: str(questionIdOrAnalyst, "questionId")
+		} : questionIdOrAnalyst !== void 0 ? {
+			type,
+			down,
+			analyst: questionIdOrAnalyst
 		} : {
 			type,
 			down
@@ -5306,7 +5686,7 @@ function createCoordinationTools(opts) {
 		if (!isLive(node.status)) return "already-settled";
 		return "runtime-has-no-inbox";
 	};
-	const attemptDelivery = async (instruction, message) => {
+	const attemptDelivery = async (instruction, message, origin) => {
 		await recordDeliveryAttempt(instruction);
 		let delivered = false;
 		let outcome;
@@ -5328,7 +5708,7 @@ function createCoordinationTools(opts) {
 			...error !== void 0 ? { error } : {}
 		});
 		if (instruction.kind === "answer") await sendDown("answer", down, str(instruction.questionId, "questionId"));
-		else await sendDown("steer", down);
+		else await sendDown("steer", down, origin?.analyst);
 		if (error !== void 0) throw new Error(`coordination tools: delivery failed: ${error}`);
 		return down;
 	};
@@ -5496,7 +5876,7 @@ function createCoordinationTools(opts) {
 				raised += 1;
 				await bus.publish({
 					type: "finding",
-					finding: {
+					finding: canonicalFindingEvent({
 						fromWorker: id,
 						analyst: `online:${signal.detector}`,
 						findings: {
@@ -5509,7 +5889,7 @@ function createCoordinationTools(opts) {
 							at: span.endedAt,
 							progress: readProgress(id)
 						}
-					}
+					})
 				});
 			}
 		});
@@ -5637,6 +6017,7 @@ function createCoordinationTools(opts) {
 				if (res.ok) {
 					watchWorker(res.handle.id);
 					if (key !== void 0) keyByWorker.set(res.handle.id, key);
+					if (typeof profile.name === "string" && profile.name.length > 0) profileNameByWorker.set(res.handle.id, profile.name);
 				}
 				const priorHistory = res.ok && res.prior !== void 0 && res.prior.state !== "completed" ? {
 					resumed: res.prior.state,
@@ -6020,7 +6401,7 @@ function createCoordinationTools(opts) {
 		history: () => bus.history(),
 		raiseFinding: (finding) => bus.publish({
 			type: "finding",
-			finding
+			finding: canonicalFindingEvent(finding)
 		}).then(() => void 0),
 		stats: () => bus.stats(),
 		isStopped: () => stopped,
@@ -6050,6 +6431,16 @@ function nextUnkeyedAssignmentOrdinal(scope) {
 function deepFreezeDetached(value) {
 	return deepFreeze(structuredClone(value));
 }
+/** Stringify a findings payload for a routed delivery; never throws (a cyclic payload degrades to
+*  its String form rather than killing the settle path). */
+function safeJsonText(value) {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
 function deepFreeze(value, seen = /* @__PURE__ */ new Set()) {
 	if (value === null || typeof value !== "object" || seen.has(value)) return value;
 	seen.add(value);
@@ -8622,24 +9013,13 @@ async function serveCoordinationMcp(opts) {
 /** 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
-*  it for a specific topology. */
-const defaultSupervisorPrompt = [
-	"You are a supervisor accountable for DELIVERING the task — not for looking busy. You succeed only",
-	"when the deliverable is actually produced and verified, never on a worker reporting \"done\".",
-	"",
-	"Spawning a worker spends the shared, conserved budget — so delegate with intent, not by reflex:",
-	"- Do small, sequential work YOURSELF when you have work tools; spawn a worker when a sub-task is",
-	"  large, independent (parallelizable), or needs a clean context the current one has filled.",
-	"- Prefer the FEWEST workers that deliver. Over-spawning burns the budget and rarely helps.",
-	"",
-	"Manage the context lifecycle on long work: give each spawned worker a BOUNDED brief — the specific",
-	"sub-task plus only the interfaces/state it needs — never your whole history. When one chapter is",
-	"done, distill what the next chapter needs and spawn fresh, rather than steering one worker until",
-	"its context fills and degrades.",
-	"",
-	"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");
+*  it for a specific topology.
+*
+*  This is the registry's ONE supervisor policy (`supervisor/policy`), not this module's own text:
+*  the delegate front door (`supervisorInstructions`) derives from the same entry, so which front
+*  door built the supervisor no longer decides its work-vs-delegate policy — the package used to
+*  ship two contradictory defaults selected by entry point. */
+const defaultSupervisorPrompt = supervisorPolicyPrompt.text;
 /** 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. */
@@ -8973,6 +9353,20 @@ function externalExecutionId(kind, identity) {
 	}).slice(7)}`;
 }
 /**
+* The `trace-unpropagated` declaration for a worker backend, or `undefined` when the backend HAS a
+* propagation channel. The census (`WORKER_TRACE_PROPAGATION`) says WHETHER a backend propagates;
+* this maps the non-propagating arms to WHY: `router`/`router-tools`/`provider` have no worker
+* process to inherit an environment, `bridge`/`cli-worktree` have a worker but no environment
+* channel through their transport.
+*/
+function workerTraceUnpropagatedDeclaration(backend) {
+	if (WORKER_TRACE_PROPAGATION[backend]) return void 0;
+	return {
+		backend,
+		reason: backend === "router" || backend === "router-tools" || backend === "provider" ? "no-worker-process" : "no-env-channel"
+	};
+}
+/**
 * NOT a harness-name test — `ExecutorConfig.backend` is a discriminated-union TAG naming HOW a
 * profile is materialized (bridge / sandbox / cli-worktree / router / cli / provider), which is a
 * different axis from WHICH CLI runs. An exhaustive switch on a closed union tag is the correct
@@ -9519,6 +9913,7 @@ function supervise(profile, task, opts) {
 	assertProfileContract(canonicalProfile, isExternalSupervisor(canonicalProfile) ? driverMaterialization : options.brain ? promptControlProfileMaterialization : routerSupervisorProfileMaterialization, "supervise root");
 	const now = options.now ?? Date.now;
 	let spans;
+	const traceUnpropagated = options.backend ? workerTraceUnpropagatedDeclaration(options.backend.backend) : void 0;
 	let makeWorkerAgent = options.makeWorkerAgent;
 	if (!makeWorkerAgent) {
 		if (!options.backend) throw new ValidationError("supervise: provide opts.backend (where workers run) or opts.makeWorkerAgent");
@@ -9705,7 +10100,8 @@ function supervise(profile, task, opts) {
 			...options.now ? { now: options.now } : {},
 			...options.signal ? { signal: options.signal } : {},
 			...hooks ? { hooks } : {},
-			...recorder ? { workerTrace: recorder.workerTrace } : {}
+			...recorder ? { workerTrace: recorder.workerTrace } : {},
+			...recorder && traceUnpropagated ? { workerTraceUnpropagated: traceUnpropagated } : {}
 		});
 		if (!recorder) return run;
 		try {
@@ -9720,6 +10116,6 @@ function supervise(profile, task, opts) {
 	return start();
 }
 //#endregion
-export { allOf as $, DELEGATE_DESCRIPTION as A, runAgentRounds as At, DELEGATION_TRACE_MAX_SPANS as B, assessAuthoredProfile as Bt, createDelegateUiAuditHandler as C, createSteerableSandboxSession as Ct, DELEGATE_FEEDBACK_TOOL_NAME as D, createInbox as Dt, DELEGATE_FEEDBACK_INPUT_SCHEMA as E, sandboxSessionTraceSource as Et, defaultDelegateBudget as F, FileCoordinationLog as Ft, DelegationPersistenceError as G, supervisorInstructions as Gt, capDelegationTrace as H, canonicalizeAuthoredProfile as Ht, delegate as I, createSupervisorSpanRecorder as It, InMemoryDelegationStore as J, DelegationStateCorruptError as K, gateOnDeliverable as Kt, DelegationTaskQueue as L, assertModelAllowed as Lt, DELEGATE_TOOL_NAME as M, createSandboxLineage as Mt, createDelegateHandler as N, probeSandboxCapabilities as Nt, createDelegateFeedbackHandler as O, createSandboxForSpec as Ot, validateDelegateArgs as P, acquireSandbox as Pt, finalizeBestDelivered as Q, hashIdempotencyInput as R, assertProfileModelsAllowed as Rt, DELEGATE_UI_AUDIT_TOOL_NAME as S, DEFAULT_SANDBOX_STEERING_MAX_TURNS as St, DELEGATE_FEEDBACK_DESCRIPTION as T, decodeToolPart as Tt, composeLoopTraceEmitters as U, defaultProfileRichnessThresholds as Ut, buildDelegationTraceSpans as V, authoredWorker as Vt, createDelegationTraceCollector as W, profileRichnessFinding as Wt, eventToSnapshot as X, InMemoryFeedbackStore as Y, driverAgent as Z, DELEGATION_HISTORY_TOOL_NAME as _, createInMemoryRunContext as _t, resolveSupervisorProfile as a, sampleFromSettled as at, DELEGATE_UI_AUDIT_DESCRIPTION as b, createExecutorRegistry as bt, createInProcessTransport as c, bestSoFar as ct, DELEGATION_STATUS_INPUT_SCHEMA as d, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as dt, allWorkersStalled as et, DELEGATION_STATUS_TOOL_NAME as f, createCoordinationTools as ft, DELEGATION_HISTORY_INPUT_SCHEMA as g, createFileRunContext as gt, DELEGATION_HISTORY_DESCRIPTION as h, watchTrace as ht, assertCoordinationBinding as i, plateau as it, DELEGATE_INPUT_SCHEMA as j, runLoop as jt, validateDelegateFeedbackArgs as k, defaultSelectWinner as kt, createMcpServer as l, plateauLength as lt, validateDelegationStatusArgs as m, defaultToolDetectors as mt, supervise as n, createProgressTracker as nt, supervisorAgent as o, anytimeReport as ot, createDelegationStatusHandler as p, createEventBus as pt, FileDelegationStore as q, workerFromBackend as r, noProgressFor as rt, serveCoordinationMcp as s, areaUnderCurve as st, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, anyOf as tt, DELEGATION_STATUS_DESCRIPTION as u, renderAnytimeTable as ut, createDelegationHistoryHandler as v, cliWorktreeExecutor as vt, validateDelegateUiAuditArgs as w, createPushTraceSource as wt, DELEGATE_UI_AUDIT_INPUT_SCHEMA as x, createWorktreeCliExecutor as xt, validateDelegationHistoryArgs as y, createExecutor as yt, DELEGATION_TRACE_MAX_BYTES as z, asAuthoredProfile as zt };
+export { allOf as $, formatPromptHandle as $t, DELEGATE_DESCRIPTION as A, createSandboxForSpec as At, DELEGATION_TRACE_MAX_SPANS as B, assertProfileModelsAllowed as Bt, createDelegateUiAuditHandler as C, createWorktreeCliExecutor as Ct, DELEGATE_FEEDBACK_TOOL_NAME as D, decodeToolPart as Dt, DELEGATE_FEEDBACK_INPUT_SCHEMA as E, createPushTraceSource as Et, defaultDelegateBudget as F, probeSandboxCapabilities as Ft, DelegationPersistenceError as G, defaultProfileRichnessThresholds as Gt, capDelegationTrace as H, assessAuthoredProfile as Ht, delegate as I, acquireSandbox as It, InMemoryDelegationStore as J, analyzesFindingsReportPrompt as Jt, DelegationStateCorruptError as K, profileRichnessFinding as Kt, DelegationTaskQueue as L, FileCoordinationLog as Lt, DELEGATE_TOOL_NAME as M, runAgentRounds as Mt, createDelegateHandler as N, runLoop as Nt, createDelegateFeedbackHandler as O, sandboxSessionTraceSource as Ot, validateDelegateArgs as P, createSandboxLineage as Pt, finalizeBestDelivered as Q, dumbContinuationPassPrompt as Qt, hashIdempotencyInput as R, createSupervisorSpanRecorder as Rt, DELEGATE_UI_AUDIT_TOOL_NAME as S, createExecutorRegistry as St, DELEGATE_FEEDBACK_DESCRIPTION as T, createSteerableSandboxSession as Tt, composeLoopTraceEmitters as U, authoredWorker as Ut, buildDelegationTraceSpans as V, asAuthoredProfile as Vt, createDelegationTraceCollector as W, canonicalizeAuthoredProfile as Wt, eventToSnapshot as X, delegatesWorkerBriefPrompt as Xt, InMemoryFeedbackStore as Y, createPromptRegistry as Yt, driverAgent as Z, dumbContinuationFailPrompt as Zt, DELEGATION_HISTORY_TOOL_NAME as _, watchTrace as _t, resolveSupervisorProfile as a, sampleFromSettled as at, DELEGATE_UI_AUDIT_DESCRIPTION as b, cliWorktreeExecutor as bt, createInProcessTransport as c, bestSoFar as ct, DELEGATION_STATUS_INPUT_SCHEMA as d, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as dt, kernelPromptRegistry as en, allWorkersStalled as et, DELEGATION_STATUS_TOOL_NAME as f, canonicalFindingEvent as ft, DELEGATION_HISTORY_INPUT_SCHEMA as g, defaultToolDetectors as gt, DELEGATION_HISTORY_DESCRIPTION as h, createEventBus as ht, assertCoordinationBinding as i, gateOnDeliverable as in, plateau as it, DELEGATE_INPUT_SCHEMA as j, defaultSelectWinner as jt, validateDelegateFeedbackArgs as k, createInbox as kt, createMcpServer as l, plateauLength as lt, validateDelegationStatusArgs as m, normalizeAnalyzeOnSettle as mt, supervise as n, promptHandle as nn, createProgressTracker as nt, supervisorAgent as o, anytimeReport as ot, createDelegationStatusHandler as p, createCoordinationTools as pt, FileDelegationStore as q, supervisorInstructions as qt, workerFromBackend as r, supervisorPolicyPrompt as rn, noProgressFor as rt, serveCoordinationMcp as s, areaUnderCurve as st, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, naiveContinuationPrompt as tn, anyOf as tt, DELEGATION_STATUS_DESCRIPTION as u, renderAnytimeTable as ut, createDelegationHistoryHandler as v, createFileRunContext as vt, validateDelegateUiAuditArgs as w, DEFAULT_SANDBOX_STEERING_MAX_TURNS as wt, DELEGATE_UI_AUDIT_INPUT_SCHEMA as x, createExecutor as xt, validateDelegationHistoryArgs as y, createInMemoryRunContext as yt, DELEGATION_TRACE_MAX_BYTES as z, assertModelAllowed as zt };
 
-//# sourceMappingURL=supervise-BHHMtwP9.js.map
+//# sourceMappingURL=supervise-Dwq16u8n.js.map